Function
object to delegate to for properties not found directly on the return object or in props.
object containing properties to assign to the returned object
Returns a new object which "looks" to obj for properties which it does not have a value for. Optionally takes a bag of properties to seed the returned object with initially.
This is a small implementaton of the Boodman/Crockford delegation pattern in JavaScript. An intermediate object constructor mediates the prototype chain for the returned object, using it to delegate down to obj for property lookup when object-local lookup fails. This can be thought of similarly to ES4's "wrap", save that it does not act on types but rather on pure objects.
an Object of anonymous type
var foo = { bar: "baz" };
var thinger = dojo.delegate(foo, { thud: "xyzzy"});
thinger.bar == "baz"; // delegated to foo
foo.thud == undefined; // by definition
thinger.thud == "xyzzy"; // mixed in from props
foo.bar = "thonk";
thinger.bar == "thonk"; // still delegated to foo's barFunction
the object to "arrayify". We expect the object to have, at a minimum, a length property which corresponds to integer-indexed properties.
the location in obj to start iterating from. Defaults to 0. Optional.
An array to pack with the properties of obj. If provided, properties in obj are appended at the end of startWith and startWith is the returned array.
Converts an array-like object (i.e. arguments, DOMCollection) to an array. Returns a new Array with the elements of obj.
Function
String to be trimmed
Trims whitespace from both sides of the string
String Returns the trimmed string
This version of trim() was selected for inclusion into the base due to its compact size and relatively good performance (see [Steven Levithan's blog](http://blog.stevenlevithan.com/archives/faster-trim-javascript) Uses String.prototype.trim instead, if available. The fastest but longest version of this function is located at dojo.string.trim()
String
Function
Return true if it is a String
Boolean
Function
Return true if it is an Array. Does not work on Arrays created in other windows.
Boolean
Function
Return true if it is a Function
Function
Returns true if it is a JavaScript object (or an Array, a Function or null)
Function
similar to dojo.isArray() but more permissive
Doesn't strongly test for "arrayness". Instead, settles for "isn't a string or number and has a length property". Arguments objects and DOM collections will return true when passed to dojo.isArrayLike(), but will return false when passed to dojo.isArray().
If it walks like a duck and quacks like a duck, return `true`
Boolean
Function
Returns true if it is a built-in function or some other kind of oddball that *should* report as a function but doesn't
Boolean
Function
Adds all properties and methods of props to constructor's prototype, making them available to all instances created with constructor.
Object
Function
mixed
Function
The scope to use when method executes. If method is a string, scope is also the object containing method.
A function to be hitched to scope, or the name of the method in scope to be hitched.
Returns a function that will only ever execute in the a given scope. This allows for easy use of object member functions in callbacks and other places in which the "this" keyword may otherwise not reference the expected scope. Any number of default positional arguments may be passed as parameters beyond "method". Each of these values will be used to "placehold" (similar to curry) for the hitched function.
Function
dojo.hitch(foo, "bar")(); runs foo.bar() in the scope of foo
dojo.hitch(foo, myFunction); returns a function that runs myFunction in the scope of foo
Expansion on the default positional arguments passed along from
hitch. Passed args are mixed first, additional args after.
var foo = { bar: function(a, b, c){ console.log(a, b, c); } };
var fn = dojo.hitch(foo, "bar", 1, 2);
fn(3); // logs "1, 2, 3"
var foo = { bar: 2 };
dojo.hitch(foo, function(){ this.bar = 10; })();
execute an anonymous function in scope of fooFunction
similar to hitch() except that the scope object is left to be whatever the execution context eventually becomes.
Calling dojo.partial is the functional equivalent of calling: dojo.hitch(null, funcName, ...);
Function
Function
Clones objects (including DOM nodes) and all children. Warning: do not clone cyclic structures.
anything|Node|Date|RegExp|Object
Function
String to be used as a template.
If an object, it is used as a dictionary to look up substitutions. If a function, it is called for every substitution with following parameters: a whole match, a name, an offset, and the whole template string (see https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/String/replace for more details).
Optional regular expression objects that overrides the default pattern.
Must be global and match one item. The default is: /\{([^\}]+)\}/g,
which matches patterns like that: "{xxx}", where "xxx" is any sequence
of characters, which doesn't include "}".Performs parameterized substitutions on a string. Throws an exception if any parameter is unmatched.
String Returns the substituted string.
String
// uses a dictionary for substitutions:
dojo.replace("Hello, {name.first} {name.last} AKA {nick}!",
{
nick: "Bob",
name: {
first: "Robert",
middle: "X",
last: "Cringely"
}
});
// returns: Hello, Robert Cringely AKA Bob!
// uses an array for substitutions:
dojo.replace("Hello, {0} {2}!",
["Robert", "X", "Cringely"]);
// returns: Hello, Robert Cringely!
// uses a function for substitutions:
function sum(a){
var t = 0;
dojo.forEach(a, function(x){ t += x; });
return t;
}
dojo.replace(
"{count} payments averaging {avg} USD per payment.",
dojo.hitch(
{ payments: [11, 16, 12] },
function(_, key){
switch(key){
case "count": return this.payments.length;
case "min": return Math.min.apply(Math, this.payments);
case "max": return Math.max.apply(Math, this.payments);
case "sum": return sum(this.payments);
case "avg": return sum(this.payments) / this.payments.length;
}
}
)
);
// prints: 3 payments averaging 13 USD per payment.
// uses an alternative PHP-like pattern for substitutions:
dojo.replace("Hello, ${0} ${2}!",
["Robert", "X", "Cringely"], /\$\{([^\}]+)\}/g);
// returns: Hello, Robert Cringely!Object