array-extras.js revision cc993d3cace28dec43cfc6f55b41961e90e76ba9
/**
Adds additional utility methods to the `Y.Array` class.
@module collection
@submodule array-extras
**/
/**
Returns the index of the last item in the array that contains the specified
value, or `-1` if the value isn't found.
@method lastIndexOf
@param {Array} a Array to search in.
@param {Any} val Value to search for.
@param {Number} [fromIndex] Index at which to start searching backwards.
Defaults to the array's length - 1. If negative, it will be taken as an offset
from the end of the array. If the calculated index is less than 0, the array
will not be searched and `-1` will be returned.
@return {Number} Index of the item that contains the value, or `-1` if not
found.
@static
@for Array
**/
// An undefined fromIndex is still considered a value by some (all?)
// native implementations, so we can't pass it unless it's actually
// specified.
a.lastIndexOf(val);
} :
i = len - 1;
}
for (; i > -1; --i) {
if (a[i] === val) {
return i;
}
}
}
return -1;
};
/**
Returns a copy of the specified array with duplicate items removed.
@method unique
@param {Array} a Array to dedupe.
@return {Array} Copy of the array with duplicate items removed.
@static
**/
// Note: the sort param is deprecated and intentionally undocumented since
// YUI 3.3.0. It never did what the API docs said it did (see the older
// comment below as well).
var i = 0,
results = [],
item, j;
for (; i < len; ++i) {
item = a[i];
// This loop iterates over the results array in reverse order and stops
// if it finds an item that matches the current input array item (a
// dupe). If it makes it all the way through without finding a dupe, the
// current item is pushed onto the results array.
break;
}
}
if (j === -1) {
}
}
// Note: the sort option doesn't really belong here... I think it was added
// because there was a way to fast path the two operations together. That
// implementation was not working, so I replaced it with the following.
// Leaving it in so that the API doesn't get broken.
if (sort) {
Y.log('The sort parameter is deprecated and will be removed in a future version of YUI.', 'warn', 'deprecated');
} else {
}
}
return results;
};
/**
Executes the supplied function on each item in the array. Returns a new array
containing the items for which the supplied function returned a truthy value.
@method filter
@param {Array} a Array to filter.
@param {Function} f Function to execute on each item.
@param {Object} [o] Optional context object.
@return {Array} Array of items for which the supplied function returned a
truthy value (empty if it never returned a truthy value).
@static
*/
function(a, f, o) {
return a.filter(f, o);
} :
function(a, f, o) {
var i = 0,
results = [],
item;
for (; i < len; ++i) {
if (i in a) {
item = a[i];
}
}
}
return results;
};
/**
The inverse of `Array.filter()`. Executes the supplied function on each item.
Returns a new array containing the items for which the supplied function
returned `false`.
@method reject
@param {Array} a the array to iterate.
@param {Function} f the function to execute on each item.
@param {object} [o] Optional context object.
@return {Array} The items for which the supplied function returned `false`.
@static
*/
A.reject = function(a, f, o) {
});
};
/**
Executes the supplied function on each item in the array. Iteration stops if the
supplied function does not return a truthy value.
@method every
@param {Array} a the array to iterate.
@param {Function} f the function to execute on each item.
@param {Object} [o] Optional context object.
@return {Boolean} `true` if every item in the array returns `true` from the
supplied function, `false` otherwise.
@static
*/
function(a, f, o) {
return a.every(f, o);
} :
function(a, f, o) {
for (var i = 0, l = a.length; i < l; ++i) {
if (i in a && !f.call(o, a[i], i, a)) {
return false;
}
}
return true;
};
/**
Executes the supplied function on each item in the array and returns a new array
containing all the values returned by the supplied function.
@example
// Convert an array of numbers into an array of strings.
Y.Array.map([1, 2, 3, 4], function (item) {
return '' + item;
});
// => ['1', '2', '3', '4']
@method map
@param {Array} a the array to iterate.
@param {Function} f the function to execute on each item.
@param {object} [o] Optional context object.
@return {Array} A new array containing the return value of the supplied function
for each item in the original array.
@static
*/
function(a, f, o) {
return a.map(f, o);
} :
function(a, f, o) {
var i = 0,
for (; i < len; ++i) {
if (i in a) {
}
}
return results;
};
/**
Executes the supplied function on each item in the array, "folding" the array
into a single value.
@method reduce
@param {Array} a Array to iterate.
@param {Any} init Initial value to start with.
@param {Function} f Function to execute on each item. This function should
update and return the value of the computation. It will receive the following
arguments:
@param {Any} f.previousValue Value returned from the previous iteration,
or the initial value if this is the first iteration.
@param {Any} f.currentValue Value of the current item being iterated.
@param {Number} f.index Index of the current item.
@param {Array} f.array Array being iterated.
@param {Object} [o] Optional context object.
@return {Any} Final result from iteratively applying the given function to each
element in the array.
@static
*/
function(a, init, f, o) {
// ES5 Array.reduce doesn't support a thisObject, so we need to
// implement it manually
}, init);
} :
function(a, init, f, o) {
var i = 0,
for (; i < len; ++i) {
if (i in a) {
}
}
return result;
};
/**
Executes the supplied function on each item in the array, searching for the
first item that matches the supplied function.
@method find
@param {Array} a the array to search.
@param {Function} f the function to execute on each item. Iteration is stopped
as soon as this function returns `true`.
@param {Object} [o] Optional context object.
@return {Object} the first item that the supplied function returns `true` for,
or `null` if it never returns `true`.
@static
*/
A.find = function(a, f, o) {
for (var i = 0, l = a.length; i < l; i++) {
if (i in a && f.call(o, a[i], i, a)) {
return a[i];
}
}
return null;
};
/**
Iterates over an array, returning a new array of all the elements that match the
supplied regular expression.
@method grep
@param {Array} a Array to iterate over.
@param {RegExp} pattern Regular expression to test against each item.
@return {Array} All the items in the array that produce a match against the
supplied regular expression. If no items match, an empty array is returned.
@static
*/
});
};
/**
Partitions an array into two new arrays, one with the items for which the
supplied function returns `true`, and one with the items for which the function
returns `false`.
@method partition
@param {Array} a Array to iterate over.
@param {Function} f Function to execute for each item in the array. It will
receive the following arguments:
@param {Any} f.item Current item.
@param {Number} f.index Index of the current item.
@param {Array} f.array The array being iterated.
@param {Object} [o] Optional execution context.
@return {Object} An object with two properties: `matches` and `rejects`. Each is
an array containing the items that were selected or rejected by the test
function (or an empty array if none).
@static
*/
A.partition = function(a, f, o) {
var results = {
matches: [],
rejects: []
};
});
return results;
};
/**
Creates an array of arrays by pairing the corresponding elements of two arrays
together into a new array.
@method zip
@param {Array} a Array to iterate over.
@param {Array} a2 Another array whose values will be paired with values of the
first array.
@return {Array} An array of arrays formed by pairing each element of the first
array with an item in the second array having the corresponding index.
@static
*/
var results = [];
});
return results;
};