diff options
Diffstat (limited to 'lib/dojo/_base/array.js')
-rw-r--r-- | lib/dojo/_base/array.js | 317 |
1 files changed, 250 insertions, 67 deletions
diff --git a/lib/dojo/_base/array.js b/lib/dojo/_base/array.js index 83c21c8d8..26fa1900d 100644 --- a/lib/dojo/_base/array.js +++ b/lib/dojo/_base/array.js @@ -5,75 +5,258 @@ */ -if(!dojo._hasResource["dojo._base.array"]){ -dojo._hasResource["dojo._base.array"]=true; +if(!dojo._hasResource["dojo._base.array"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo._base.array"] = true; dojo.require("dojo._base.lang"); dojo.provide("dojo._base.array"); + (function(){ -var _1=function(_2,_3,cb){ -return [(typeof _2=="string")?_2.split(""):_2,_3||dojo.global,(typeof cb=="string")?new Function("item","index","array",cb):cb]; -}; -var _4=function(_5,_6,_7,_8){ -var _9=_1(_6,_8,_7); -_6=_9[0]; -for(var i=0,l=_6.length;i<l;++i){ -var _a=!!_9[2].call(_9[1],_6[i],i,_6); -if(_5^_a){ -return _a; -} -} -return _5; -}; -dojo.mixin(dojo,{indexOf:function(_b,_c,_d,_e){ -var _f=1,end=_b.length||0,i=0; -if(_e){ -i=end-1; -_f=end=-1; -} -if(_d!=undefined){ -i=_d; -} -if((_e&&i>end)||i<end){ -for(;i!=end;i+=_f){ -if(_b[i]==_c){ -return i; -} -} -} -return -1; -},lastIndexOf:function(_10,_11,_12){ -return dojo.indexOf(_10,_11,_12,true); -},forEach:function(arr,_13,_14){ -if(!arr||!arr.length){ -return; -} -var _15=_1(arr,_14,_13); -arr=_15[0]; -for(var i=0,l=arr.length;i<l;++i){ -_15[2].call(_15[1],arr[i],i,arr); -} -},every:function(arr,_16,_17){ -return _4(true,arr,_16,_17); -},some:function(arr,_18,_19){ -return _4(false,arr,_18,_19); -},map:function(arr,_1a,_1b){ -var _1c=_1(arr,_1b,_1a); -arr=_1c[0]; -var _1d=(arguments[3]?(new arguments[3]()):[]); -for(var i=0,l=arr.length;i<l;++i){ -_1d.push(_1c[2].call(_1c[1],arr[i],i,arr)); -} -return _1d; -},filter:function(arr,_1e,_1f){ -var _20=_1(arr,_1f,_1e); -arr=_20[0]; -var _21=[]; -for(var i=0,l=arr.length;i<l;++i){ -if(_20[2].call(_20[1],arr[i],i,arr)){ -_21.push(arr[i]); -} -} -return _21; -}}); + var _getParts = function(arr, obj, cb){ + return [ + (typeof arr == "string") ? arr.split("") : arr, + obj || dojo.global, + // FIXME: cache the anonymous functions we create here? + (typeof cb == "string") ? new Function("item", "index", "array", cb) : cb + ]; + }; + + var everyOrSome = function(/*Boolean*/every, /*Array|String*/arr, /*Function|String*/callback, /*Object?*/thisObject){ + var _p = _getParts(arr, thisObject, callback); arr = _p[0]; + for(var i=0,l=arr.length; i<l; ++i){ + var result = !!_p[2].call(_p[1], arr[i], i, arr); + if(every ^ result){ + return result; // Boolean + } + } + return every; // Boolean + }; + + dojo.mixin(dojo, { + indexOf: function( /*Array*/ array, + /*Object*/ value, + /*Integer?*/ fromIndex, + /*Boolean?*/ findLast){ + // summary: + // locates the first index of the provided value in the + // passed array. If the value is not found, -1 is returned. + // description: + // This method corresponds to the JavaScript 1.6 Array.indexOf method, with one difference: when + // run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript + // 1.6's indexOf skips the holes in the sparse array. + // For details on this method, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf + + var step = 1, end = array.length || 0, i = 0; + if(findLast){ + i = end - 1; + step = end = -1; + } + if(fromIndex != undefined){ i = fromIndex; } + if((findLast && i > end) || i < end){ + for(; i != end; i += step){ + if(array[i] == value){ return i; } + } + } + return -1; // Number + }, + + lastIndexOf: function(/*Array*/array, /*Object*/value, /*Integer?*/fromIndex){ + // summary: + // locates the last index of the provided value in the passed + // array. If the value is not found, -1 is returned. + // description: + // This method corresponds to the JavaScript 1.6 Array.lastIndexOf method, with one difference: when + // run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript + // 1.6's lastIndexOf skips the holes in the sparse array. + // For details on this method, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/lastIndexOf + return dojo.indexOf(array, value, fromIndex, true); // Number + }, + + forEach: function(/*Array|String*/arr, /*Function|String*/callback, /*Object?*/thisObject){ + // summary: + // for every item in arr, callback is invoked. Return values are ignored. + // If you want to break out of the loop, consider using dojo.every() or dojo.some(). + // forEach does not allow breaking out of the loop over the items in arr. + // arr: + // the array to iterate over. If a string, operates on individual characters. + // callback: + // a function is invoked with three arguments: item, index, and array + // thisObject: + // may be used to scope the call to callback + // description: + // This function corresponds to the JavaScript 1.6 Array.forEach() method, with one difference: when + // run over sparse arrays, this implemenation passes the "holes" in the sparse array to + // the callback function with a value of undefined. JavaScript 1.6's forEach skips the holes in the sparse array. + // For more details, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/forEach + // example: + // | // log out all members of the array: + // | dojo.forEach( + // | [ "thinger", "blah", "howdy", 10 ], + // | function(item){ + // | console.log(item); + // | } + // | ); + // example: + // | // log out the members and their indexes + // | dojo.forEach( + // | [ "thinger", "blah", "howdy", 10 ], + // | function(item, idx, arr){ + // | console.log(item, "at index:", idx); + // | } + // | ); + // example: + // | // use a scoped object member as the callback + // | + // | var obj = { + // | prefix: "logged via obj.callback:", + // | callback: function(item){ + // | console.log(this.prefix, item); + // | } + // | }; + // | + // | // specifying the scope function executes the callback in that scope + // | dojo.forEach( + // | [ "thinger", "blah", "howdy", 10 ], + // | obj.callback, + // | obj + // | ); + // | + // | // alternately, we can accomplish the same thing with dojo.hitch() + // | dojo.forEach( + // | [ "thinger", "blah", "howdy", 10 ], + // | dojo.hitch(obj, "callback") + // | ); + + // match the behavior of the built-in forEach WRT empty arrs + if(!arr || !arr.length){ return; } + + // FIXME: there are several ways of handilng thisObject. Is + // dojo.global always the default context? + var _p = _getParts(arr, thisObject, callback); arr = _p[0]; + for(var i=0,l=arr.length; i<l; ++i){ + _p[2].call(_p[1], arr[i], i, arr); + } + }, + + every: function(/*Array|String*/arr, /*Function|String*/callback, /*Object?*/thisObject){ + // summary: + // Determines whether or not every item in arr satisfies the + // condition implemented by callback. + // arr: + // the array to iterate on. If a string, operates on individual characters. + // callback: + // a function is invoked with three arguments: item, index, + // and array and returns true if the condition is met. + // thisObject: + // may be used to scope the call to callback + // description: + // This function corresponds to the JavaScript 1.6 Array.every() method, with one difference: when + // run over sparse arrays, this implemenation passes the "holes" in the sparse array to + // the callback function with a value of undefined. JavaScript 1.6's every skips the holes in the sparse array. + // For more details, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/every + // example: + // | // returns false + // | dojo.every([1, 2, 3, 4], function(item){ return item>1; }); + // example: + // | // returns true + // | dojo.every([1, 2, 3, 4], function(item){ return item>0; }); + return everyOrSome(true, arr, callback, thisObject); // Boolean + }, + + some: function(/*Array|String*/arr, /*Function|String*/callback, /*Object?*/thisObject){ + // summary: + // Determines whether or not any item in arr satisfies the + // condition implemented by callback. + // arr: + // the array to iterate over. If a string, operates on individual characters. + // callback: + // a function is invoked with three arguments: item, index, + // and array and returns true if the condition is met. + // thisObject: + // may be used to scope the call to callback + // description: + // This function corresponds to the JavaScript 1.6 Array.some() method, with one difference: when + // run over sparse arrays, this implemenation passes the "holes" in the sparse array to + // the callback function with a value of undefined. JavaScript 1.6's some skips the holes in the sparse array. + // For more details, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/some + // example: + // | // is true + // | dojo.some([1, 2, 3, 4], function(item){ return item>1; }); + // example: + // | // is false + // | dojo.some([1, 2, 3, 4], function(item){ return item<1; }); + return everyOrSome(false, arr, callback, thisObject); // Boolean + }, + + map: function(/*Array|String*/arr, /*Function|String*/callback, /*Function?*/thisObject){ + // summary: + // applies callback to each element of arr and returns + // an Array with the results + // arr: + // the array to iterate on. If a string, operates on + // individual characters. + // callback: + // a function is invoked with three arguments, (item, index, + // array), and returns a value + // thisObject: + // may be used to scope the call to callback + // description: + // This function corresponds to the JavaScript 1.6 Array.map() method, with one difference: when + // run over sparse arrays, this implemenation passes the "holes" in the sparse array to + // the callback function with a value of undefined. JavaScript 1.6's map skips the holes in the sparse array. + // For more details, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map + // example: + // | // returns [2, 3, 4, 5] + // | dojo.map([1, 2, 3, 4], function(item){ return item+1 }); + + var _p = _getParts(arr, thisObject, callback); arr = _p[0]; + var outArr = (arguments[3] ? (new arguments[3]()) : []); + for(var i=0,l=arr.length; i<l; ++i){ + outArr.push(_p[2].call(_p[1], arr[i], i, arr)); + } + return outArr; // Array + }, + + filter: function(/*Array*/arr, /*Function|String*/callback, /*Object?*/thisObject){ + // summary: + // Returns a new Array with those items from arr that match the + // condition implemented by callback. + // arr: + // the array to iterate over. + // callback: + // a function that is invoked with three arguments (item, + // index, array). The return of this function is expected to + // be a boolean which determines whether the passed-in item + // will be included in the returned array. + // thisObject: + // may be used to scope the call to callback + // description: + // This function corresponds to the JavaScript 1.6 Array.filter() method, with one difference: when + // run over sparse arrays, this implemenation passes the "holes" in the sparse array to + // the callback function with a value of undefined. JavaScript 1.6's filter skips the holes in the sparse array. + // For more details, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter + // example: + // | // returns [2, 3, 4] + // | dojo.filter([1, 2, 3, 4], function(item){ return item>1; }); + + var _p = _getParts(arr, thisObject, callback); arr = _p[0]; + var outArr = []; + for(var i=0,l=arr.length; i<l; ++i){ + if(_p[2].call(_p[1], arr[i], i, arr)){ + outArr.push(arr[i]); + } + } + return outArr; // Array + } + }); })(); +/* +*/ + } |