define("dojo/_base/array", ["./kernel", "../has", "./lang"], function(dojo, has, lang){ // module: // dojo/_base/array // our old simple function builder stuff var cache = {}, u; function buildFn(fn){ return cache[fn] = new Function("item", "index", "array", fn); // Function } // magic snippet: if(typeof fn == "string") fn = cache[fn] || buildFn(fn); // every & some function everyOrSome(some){ var every = !some; return function(a, fn, o){ var i = 0, l = a && a.length || 0, result; if(l && typeof a == "string") a = a.split(""); if(typeof fn == "string") fn = cache[fn] || buildFn(fn); if(o){ for(; i < l; ++i){ result = !fn.call(o, a[i], i, a); if(some ^ result){ return !result; } } }else{ for(; i < l; ++i){ result = !fn(a[i], i, a); if(some ^ result){ return !result; } } } return every; // Boolean }; } // indexOf, lastIndexOf function index(up){ var delta = 1, lOver = 0, uOver = 0; if(!up){ delta = lOver = uOver = -1; } return function(a, x, from, last){ if(last && delta > 0){ // TODO: why do we use a non-standard signature? why do we need "last"? return array.lastIndexOf(a, x, from); } var l = a && a.length || 0, end = up ? l + uOver : lOver, i; if(from === u){ i = up ? lOver : l + uOver; }else{ if(from < 0){ i = l + from; if(i < 0){ i = lOver; } }else{ i = from >= l ? l + uOver : from; } } if(l && typeof a == "string") a = a.split(""); for(; i != end; i += delta){ if(a[i] == x){ return i; // Number } } return -1; // Number }; } var array = { // summary: // The Javascript v1.6 array extensions. every: everyOrSome(false), /*===== every: function(arr, callback, thisObject){ // summary: // Determines whether or not every item in arr satisfies the // condition implemented by callback. // arr: Array|String // the array to iterate on. If a string, operates on individual characters. // callback: Function|String // a function is invoked with three arguments: item, index, // and array and returns true if the condition is met. // thisObject: Object? // may be used to scope the call to callback // returns: Boolean // description: // This function corresponds to the JavaScript 1.6 Array.every() method, with one difference: when // run over sparse arrays, this implementation 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 // | array.every([1, 2, 3, 4], function(item){ return item>1; }); // example: // | // returns true // | array.every([1, 2, 3, 4], function(item){ return item>0; }); }, =====*/ some: everyOrSome(true), /*===== some: function(arr, callback, thisObject){ // summary: // Determines whether or not any item in arr satisfies the // condition implemented by callback. // arr: Array|String // the array to iterate over. If a string, operates on individual characters. // callback: Function|String // a function is invoked with three arguments: item, index, // and array and returns true if the condition is met. // thisObject: Object? // may be used to scope the call to callback // returns: Boolean // description: // This function corresponds to the JavaScript 1.6 Array.some() method, with one difference: when // run over sparse arrays, this implementation 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 // | array.some([1, 2, 3, 4], function(item){ return item>1; }); // example: // | // is false // | array.some([1, 2, 3, 4], function(item){ return item<1; }); }, =====*/ indexOf: index(true), /*===== indexOf: function(arr, value, fromIndex, 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 // arr: Array // value: Object // fromIndex: Integer? // findLast: Boolean? // returns: Number }, =====*/ lastIndexOf: index(false), /*===== lastIndexOf: function(arr, value, 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 // arr: Array, // value: Object, // fromIndex: Integer? // returns: Number }, =====*/ forEach: function(arr, callback, 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 array.every() or array.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 implementation 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: // | array.forEach( // | [ "thinger", "blah", "howdy", 10 ], // | function(item){ // | console.log(item); // | } // | ); // example: // | // log out the members and their indexes // | array.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 // | array.forEach( // | [ "thinger", "blah", "howdy", 10 ], // | obj.callback, // | obj // | ); // | // | // alternately, we can accomplish the same thing with lang.hitch() // | array.forEach( // | [ "thinger", "blah", "howdy", 10 ], // | lang.hitch(obj, "callback") // | ); // arr: Array|String // callback: Function|String // thisObject: Object? var i = 0, l = arr && arr.length || 0; if(l && typeof arr == "string") arr = arr.split(""); if(typeof callback == "string") callback = cache[callback] || buildFn(callback); if(thisObject){ for(; i < l; ++i){ callback.call(thisObject, arr[i], i, arr); } }else{ for(; i < l; ++i){ callback(arr[i], i, arr); } } }, map: function(arr, callback, thisObject, Ctr){ // summary: // applies callback to each element of arr and returns // an Array with the results // arr: Array|String // the array to iterate on. If a string, operates on // individual characters. // callback: Function|String // a function is invoked with three arguments, (item, index, // array), and returns a value // thisObject: Object? // may be used to scope the call to callback // returns: Array // description: // This function corresponds to the JavaScript 1.6 Array.map() method, with one difference: when // run over sparse arrays, this implementation 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] // | array.map([1, 2, 3, 4], function(item){ return item+1 }); // TODO: why do we have a non-standard signature here? do we need "Ctr"? var i = 0, l = arr && arr.length || 0, out = new (Ctr || Array)(l); if(l && typeof arr == "string") arr = arr.split(""); if(typeof callback == "string") callback = cache[callback] || buildFn(callback); if(thisObject){ for(; i < l; ++i){ out[i] = callback.call(thisObject, arr[i], i, arr); } }else{ for(; i < l; ++i){ out[i] = callback(arr[i], i, arr); } } return out; // Array }, filter: function(arr, callback, thisObject){ // summary: // Returns a new Array with those items from arr that match the // condition implemented by callback. // arr: Array // the array to iterate over. // callback: Function|String // 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: Object? // may be used to scope the call to callback // returns: Array // description: // This function corresponds to the JavaScript 1.6 Array.filter() method, with one difference: when // run over sparse arrays, this implementation 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] // | array.filter([1, 2, 3, 4], function(item){ return item>1; }); // TODO: do we need "Ctr" here like in map()? var i = 0, l = arr && arr.length || 0, out = [], value; if(l && typeof arr == "string") arr = arr.split(""); if(typeof callback == "string") callback = cache[callback] || buildFn(callback); if(thisObject){ for(; i < l; ++i){ value = arr[i]; if(callback.call(thisObject, value, i, arr)){ out.push(value); } } }else{ for(; i < l; ++i){ value = arr[i]; if(callback(value, i, arr)){ out.push(value); } } } return out; // Array }, clearCache: function(){ cache = {}; } }; 1 && lang.mixin(dojo, array); return array; });