arrayMethods

declaration

 arrayMethods 

var arrayMethods = module.exports = {
    // find: see below
    // findIndex: see below
    appendArray: appendArray,
    prependArray: prependArray,
    toArray: toArray,
    object: object,
    mapToObject: mapToObject,
    unique: unique,
    deepForEach: deepForEach,
    spliceItem: spliceItem
};

nativeArrayMethodsNames

declaration

 nativeArrayMethodsNames 

var nativeArrayMethodsNames = [ 'join', 'pop', 'push', 'concat',
    'reverse', 'shift', 'unshift', 'slice', 'splice',
    'sort', 'filter', 'forEach', 'some', 'every',
    'map', 'indexOf', 'lastIndexOf', 'reduce', 'reduceRight'];

var nativeArrayMethods = mapToObject.call(nativeArrayMethodsNames,
        function(methodName) {
            return Array.prototype[methodName];
        });

__.extend.call(arrayMethods, nativeArrayMethods);

find

property

 arrayMethods.find 

Option name	Type	Description
self	Array	array to search in
callback	Function	should return true for item to pass the test, passed value, index and self as parameters
thisArg	Object	optional context (this) of callback call
return	Any

arrayMethods.find = Array.prototype.find
    || utils.makeFindMethod(arrayMethods.some, 'value');

findIndex

property

 arrayMethods.findIndex 

Option name	Type	Description
self	Array	array to search in
callback	Function	should return true for item to pass the test, passed value, index and self as parameters
thisArg	Object	optional context (this) of callback call
return	Integer

arrayMethods.findIndex = Array.prototype.findIndex
    || utils.makeFindMethod(arrayMethods.some, 'index');

appendArray

function

 appendArray() 

Option name	Type	Description
self	Array	An array that will be modified
arrayToAppend	Array	An array that will be appended
return	Array

function appendArray(arrayToAppend) {
    if (! arrayToAppend.length) return this;
    if (! Array.isArray(arrayToAppend))
        arrayToAppend = toArray.call(arrayToAppend);
    
    var args = [this.length, 0].concat(arrayToAppend);
    arrayMethods.splice.apply(this, args);

    return this;
}

prependArray

function

 prependArray() 

Option name	Type	Description
self	Array	An array that will be modified
arrayToAppend	Array	An array that will be prepended
return	Array

function prependArray(arrayToPrepend) {
    if (! arrayToPrepend.length) return this;
    if (! Array.isArray(arrayToPrepend))
        arrayToPrepend = toArray.call(arrayToPrepend);

    var args = [0, 0].concat(arrayToPrepend);
    arrayMethods.splice.apply(this, args);

    return this;
}

spliceItem

function

 spliceItem() 

Option name	Type	Description
self	Array	An array that will be modified
item	Any	item to be removed
return	Array

function spliceItem(item) {
    var index = this.indexOf(item);
    if (index >= 0) this.splice(index, 1);
    return this;
}

toArray

function

 toArray() 

Option name	Type	Description
self	PseudoArray	Object with numeric property length
return	Array

function toArray() {
    return arrayMethods.slice.call(this);
}

object

function

 object() 

Option name	Type	Description
self	Array	Array of keys
values	Array, any	Optional array of values or the value to be assigned to each property.
return	Object

function object(values) {
    var obj = {}
        , valuesIsArray = Array.isArray(values);
    arrayMethods.forEach.call(this, function(key, index) {
        obj[key] = valuesIsArray ? values[index] : values;
    });

    return obj;
}

mapToObject

function

 mapToObject() 

Option name	Type	Description
self	Array	An array which values will become keys of the result
callback	Function	Callback is passed value, index and self and should return value that will be included in the result.
thisArg	Object	An optional context of iteration (the valueof this), will be undefined if this parameter is not passed.
return	Object

function mapToObject(callback, thisArg) {
    var result = {};
    Array.prototype.forEach.call(this, function(value, index) {
        result[value] = callback.call(thisArg, value, index, this);
    }, this);
    return result;
}

unique

function

 unique() 

Option name	Type	Description
self	Array	original array
callback	Function	comparison function, should return true for equal items, "===" is used if not passed.
return	Array

function unique(callback) {
    var filtered = [];
    if (! callback)
        itemIndex = itemIndexOf;

    this.forEach(function(item) {
        var index = itemIndex(item);
        if (index == -1)
            filtered.push(item);
    });

    return filtered;


    function itemIndex(item) {
        return arrayMethods.findIndex.call(filtered, function(it) {
            return callback(item, it);
        });
    }

    function itemIndexOf(item) {
        return filtered.indexOf(item);
    }
}

deepForEach

function

 deepForEach() 

Option name	Type	Description
self	Array	array of elements and arraysto iterate.
callback	Function	called for each item that is not an array. Callback is passed item, index and original array as parameters.
thisArg	Any	optional callback envocation context

function deepForEach(callback, thisArg) {
    var index = 0, arr = this;
    _deepForEach.call(this);

    function _deepForEach() {
        arrayMethods.forEach.call(this, function(value) {
            if (Array.isArray(value))
                _deepForEach.call(value);
            else
                callback.call(thisArg, value, index++, arr);
        });
    }
}