yui-array.js revision eb86457f85638a9eb7c4d5f84eb367d24061abfb
550N/A(function() {
1233N/A/**
550N/A * YUI core
550N/A * @module yui
919N/A */
919N/A
919N/A
919N/Avar L = Y.Lang, Native = Array.prototype,
919N/A
550N/A/**
919N/A * Adds the following array utilities to the YUI instance
919N/A * @class YUI~array
919N/A */
550N/A
919N/A/**
919N/A * Y.Array(o) returns an array:
919N/A * - Arrays are return unmodified unless the start position is specified.
919N/A * - "Array-like" collections (@see Array.test) are converted to arrays
919N/A * - For everything else, a new array is created with the input as the sole item
919N/A * - The start position is used if the input is or is like an array to return
919N/A * a subset of the collection.
550N/A *
550N/A * @TODO this will not automatically convert elements that are also collections
550N/A * such as forms and selects. Passing true as the third param will
550N/A * force a conversion.
1233N/A *
550N/A * @method Array
550N/A * @static
550N/A * @param o the item to arrayify
550N/A * @param i {int} if an array or array-like, this is the start index
550N/A * @param al {boolean} if true, it forces the array-like fork. This
550N/A * can be used to avoid multiple array.test calls.
550N/A * @return {Array} the resulting array
550N/A */
550N/AA = function(o, i, al) {
550N/A var t = (al) ? 2 : Y.Array.test(o);
550N/A
1233N/A // switch (t) {
550N/A // case 1:
550N/A // // return (i) ? o.slice(i) : o;
1233N/A // case 2:
550N/A // return Native.slice.call(o, i || 0);
550N/A // default:
550N/A // return [o];
550N/A // }
if (t) {
return Native.slice.call(o, i || 0);
} else {
return [o];
}
};
Y.Array = A;
/**
* Evaluates the input to determine if it is an array, array-like, or
* something else. This is used to handle the arguments collection
* available within functions, and HTMLElement collections
*
* @method Array.test
* @static
*
* @todo current implementation (intenionally) will not implicitly
* handle html elements that are array-like (forms, selects, etc).
*
* @return {int} a number indicating the results:
* 0: Not an array or an array-like collection
* 1: A real array.
* 2: array-like collection.
*/
A.test = function(o) {
var r = 0;
if (L.isObject(o, true)) {
if (L.isArray(o)) {
r = 1;
} else {
try {
// indexed, but no tagName (element) or alert (window)
if ("length" in o &&
!("tagName" in o) &&
!("alert" in o) &&
(!Y.Lang.isFunction(o.size) || o.size() > 1)) {
r = 2;
}
} catch(ex) {}
}
}
return r;
};
/**
* Executes the supplied function on each item in the array.
* @method Array.each
* @param a {Array} the array to iterate
* @param f {Function} the function to execute on each item
* @param o Optional context object
* @static
* @return {YUI} the YUI instance
*/
A.each = (Native.forEach) ?
function (a, f, o) {
Native.forEach.call(a, f, o || Y);
return Y;
} :
function (a, f, o) {
var l = a.length, i;
for (i = 0; i < l; i=i+1) {
f.call(o || Y, a[i], i, a);
}
return Y;
};
/**
* Returns an object using the first array as keys, and
* the second as values. If the second array is not
* provided the value is set to true for each.
* @method Array.hash
* @static
* @param k {Array} keyset
* @param v {Array} optional valueset
* @return {object} the hash
*/
A.hash = function(k, v) {
var o = {}, l = k.length, vl = v && v.length, i;
for (i=0; i<l; i=i+1) {
o[k[i]] = (vl && vl > i) ? v[i] : true;
}
return o;
};
/**
* Returns the index of the first item in the array
* that contains the specified value, -1 if the
* value isn't found.
* @method Array.indexOf
* @static
* @param a {Array} the array to search
* @param val the value to search for
* @return {int} the index of the item that contains the value or -1
*/
A.indexOf = (Native.indexOf) ?
function(a, val) {
return a.indexOf(val);
} :
function(a, val) {
for (var i=0; i<a.length; i=i+1) {
if (a[i] === val) {
return i;
}
}
return -1;
};
/**
* Numeric sort convenience function.
* Y.ArrayAssert.itemsAreEqual([1, 2, 3], [3, 1, 2].sort(Y.Array.numericSort));
* @method numericSort
*/
A.numericSort = function(a, b) {
return (a - b);
};
})();