Page MenuHomeCode
Files F948325

lang.js
No OneTemporary
Actions

lang.js
View Options

if(!dojo._hasResource["dojo._base.lang"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojo._base.lang"] = true;
dojo.provide("dojo._base.lang");
// Crockford (ish) functions
dojo.isString = function(/*anything*/ it){
// summary: Return true if it is a String
return typeof it == "string" || it instanceof String; // Boolean
}
dojo.isArray = function(/*anything*/ it){
// summary: Return true if it is an Array
return it && it instanceof Array || typeof it == "array"; // Boolean
}
/*=====
dojo.isFunction = function(it){
// summary: Return true if it is a Function
// it: anything
}
=====*/
dojo.isFunction = (function(){
var _isFunction = function(/*anything*/ it){
return typeof it == "function" || it instanceof Function; // Boolean
};
return dojo.isSafari ?
// only slow this down w/ gratuitious casting in Safari since it's what's b0rken
function(/*anything*/ it){
if(typeof it == "function" && it == "[object NodeList]"){ return false; }
return _isFunction(it); // Boolean
} : _isFunction;
})();
dojo.isObject = function(/*anything*/ it){
// summary:
// Returns true if it is a JavaScript object (or an Array, a Function or null)
return it !== undefined &&
(it === null || typeof it == "object" || dojo.isArray(it) || dojo.isFunction(it)); // Boolean
}
dojo.isArrayLike = function(/*anything*/ it){
// summary:
// similar to dojo.isArray() but more permissive
// description:
// 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().
// return:
// If it walks like a duck and quicks like a duck, return true
var d = dojo;
return it && it !== undefined &&
// keep out built-in constructors (Number, String, ...) which have length
// properties
!d.isString(it) && !d.isFunction(it) &&
!(it.tagName && it.tagName.toLowerCase() == 'form') &&
(d.isArray(it) || isFinite(it.length)); // Boolean
}
dojo.isAlien = function(/*anything*/ it){
// summary:
// Returns true if it is a built-in function or some other kind of
// oddball that *should* report as a function but doesn't
return it && !dojo.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean
}
dojo.extend = function(/*Object*/ constructor, /*Object...*/ props){
// summary:
// Adds all properties and methods of props to constructor's
// prototype, making them available to all instances created with
// constructor.
for(var i=1, l=arguments.length; i<l; i++){
dojo._mixin(constructor.prototype, arguments[i]);
}
return constructor; // Object
}
dojo._hitchArgs = function(scope, method /*,...*/){
var pre = dojo._toArray(arguments, 2);
var named = dojo.isString(method);
return function(){
// arrayify arguments
var args = dojo._toArray(arguments);
// locate our method
var f = named ? (scope||dojo.global)[method] : method;
// invoke with collected args
return f && f.apply(scope || this, pre.concat(args)); // mixed
} // Function
}
dojo.hitch = function(/*Object*/scope, /*Function|String*/method /*,...*/){
// summary:
// 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.
// scope:
// The scope to use when method executes. If method is a string,
// scope is also the object containing method.
// method:
// A function to be hitched to scope, or the name of the method in
// scope to be hitched.
// example:
// | dojo.hitch(foo, "bar")();
// runs foo.bar() in the scope of foo
// example:
// | dojo.hitch(foo, myFunction);
// returns a function that runs myFunction in the scope of foo
if(arguments.length > 2){
return dojo._hitchArgs.apply(dojo, arguments); // Function
}
if(!method){
method = scope;
scope = null;
}
if(dojo.isString(method)){
scope = scope || dojo.global;
if(!scope[method]){ throw(['dojo.hitch: scope["', method, '"] is null (scope="', scope, '")'].join('')); }
return function(){ return scope[method].apply(scope, arguments || []); }; // Function
}
return !scope ? method : function(){ return method.apply(scope, arguments || []); }; // Function
}
/*=====
dojo.delegate = function(obj, props){
// summary:
// 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.
// description:
// 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.
// obj:
// The object to delegate to for properties not found directly on the
// return object or in props.
// props:
// an object containing properties to assign to the returned object
// returns:
// an Object of anonymous type
// example:
// | var foo = { bar: "baz" };
// | var thinger = dojo.delegate(foo, { thud: "xyzzy"});
// | thinger.bar == "baz"; // delegated to foo
// | foo.xyzzy == undefined; // by definition
// | thinger.xyzzy == "xyzzy"; // mixed in from props
// | foo.bar = "thonk";
// | thinger.bar == "thonk"; // still delegated to foo's bar
}
=====*/
dojo.delegate = dojo._delegate = function(obj, props){
// boodman/crockford delegation
function TMP(){};
TMP.prototype = obj;
var tmp = new TMP();
if(props){
dojo.mixin(tmp, props);
}
return tmp; // Object
}
dojo.partial = function(/*Function|String*/method /*, ...*/){
// summary:
// similar to hitch() except that the scope object is left to be
// whatever the execution context eventually becomes.
// description:
// Calling dojo.partial is the functional equivalent of calling:
// | dojo.hitch(null, funcName, ...);
var arr = [ null ];
return dojo.hitch.apply(dojo, arr.concat(dojo._toArray(arguments))); // Function
}
dojo._toArray = function(/*Object*/obj, /*Number?*/offset, /*Array?*/ startWith){
// summary:
// Converts an array-like object (i.e. arguments, DOMCollection)
// to an array. Returns a new Array object.
// obj:
// the object to "arrayify". We expect the object to have, at a
// minimum, a length property which corresponds to integer-indexed
// properties.
// offset:
// the location in obj to start iterating from. Defaults to 0. Optional.
// startWith:
// 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.
var arr = startWith||[];
for(var x = offset || 0; x < obj.length; x++){
arr.push(obj[x]);
}
return arr; // Array
}
dojo.clone = function(/*anything*/ o){
// summary:
// Clones objects (including DOM nodes) and all children.
// Warning: do not clone cyclic structures.
if(!o){ return o; }
if(dojo.isArray(o)){
var r = [];
for(var i = 0; i < o.length; ++i){
r.push(dojo.clone(o[i]));
}
return r; // Array
}
if(!dojo.isObject(o)){
return o; /*anything*/
}
if(o.nodeType && o.cloneNode){ // isNode
return o.cloneNode(true); // Node
}
if(o instanceof Date){
return new Date(o.getTime()); // Date
}
// Generic objects
var r = new o.constructor(); // specific to dojo.declare()'d classes!
for(var i in o){
if(!(i in r) || r[i] != o[i]){
r[i] = dojo.clone(o[i]);
}
}
return r; // Object
}
dojo.trim = function(/*String*/ str){
// summary:
// trims whitespaces from both sides of the string
// description:
// 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).
// The fastest but longest version of this function is located at
// dojo.string.trim()
return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); // String
}
}

File Metadata

Mime Type
text/plain
Expires
Sat, Apr 26, 15:49 (6 h, 7 m ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
24308
Default Alt Text
lang.js (8 KB)

Event Timeline