ES5中，Array新增API（下）之reduceRight、every、indexOf、lastIndexOf

reduceRight

原型：

//标准
reduceRight(callback[,initialValue])

//简单示例
arr.reduceRight(function (previousValue, item, index, Array) {
    return xxx;    //xxx表示省略
});

简单说明：

和reduce几乎一样，唯一区别是，他从数组的最右边开始。只要理解了reduce就能理解这个

兼容性扩展：

if (!Array.prototype.reduceRight) {
    Array.prototype.reduceRight = function (callback, initialValue) {
        var previousValue = initialValue || this[this.length - 1];//如果不指定intialValue,则默认为数组的第一个元素
        //如果不指定initialValue（即第二个参数），i从1（第二个元素）开始遍历，否则就从0（第一个元素）开始遍历
        for (var i = (initialValue ? this.length - 1 : this.length - 2); i > -1; i--) {
            //previousValue 累加每一次返回的结果
            if (this[i])
                previousValue = callback(previousValue, this[i], i, this);
        }
        return previousValue;
    }
}

every

原型：

//标准
every(callback, thisArg);

//简单示例
arr.every(function(item, index, array){
    return item > xx;
});

简单说明：

返回值是true或者false
初始情况下是true；
然后遍历数组，有一个不满足，则为false，并且终止遍历过程。

回调函数的this依然默认指向window，或者是every的第二个参数。

空数组的every返回结果是true。

兼容性扩展：

if (!Array.prototype.every) {
    Array.prototype.every = function (callback, thisArg) {
        var result = true;
        for (var i = 0; i < this.length; i++) {
            if (this[i]) {
                if (!callback.call(thisArg ? thisArg : window, this[i], i, this)) {
                    result = false;
                    break;
                }
            }
        }
        return result; //所有元素都符合条件，返回true
    }
}

indexOf

原型：

//标准
arr.indexOf(searchElement, fromIndex);

//简单示例
[1,2,3].indexOf(2);    //1（数组的第二个元素）
[1,2,3].indexOf(4);    //-1（未找到，注意，-1不是false，隐式转换后他的值为true）

简单说明：

用于查找第一个参数是否在数组中；
如果不在，返回-1；
如果在，返回在数组中遇见的第一个的下标；
例如：[1,2,3,2].indexOf(2)的返回值是1，虽然第二个和第四个元素都是，但是先遇见第二个，而第二个的下标是1

如果indexOf有第二个参数，那么从数组中第二个参数所指向的下标位置开始往后找；
例如：[1,2,3,2].indexOf(2,2)的返回值是3，因为开始下标是2（即第三个元素3），因此从第三个开始，遇见的第一个2的下标是2；
判断时含第二个参数所指向的数组元素

兼容性写法：

if (!Array.prototype.indexOf) {
    Array.prototype.indexOf = function (searchElement, fromIndex) {
        var result = -1;
        for (var i = fromIndex ? fromIndex : 0; i < this.length; i++) {
            if (this[i]) {
                if (searchElement === this[i]) {
                    result = i;
                    break;
                }
            }
        }
        return result; //所有元素都符合条件，返回true
    }
}

lastIndexOf

注意：

Index的I是大写

原型：

//标准
arr.lastIndexOf(searchElement, fromIndex);

//简单示例
[1,2,1].lastIndexOf(1);    //2
[1,2,1].lastIndexOf(1, 1);    //0

简单说明：

和indexOf几乎一样，唯一区别是从后往前找；

下标指的是正常的下标（即从前往后的），不要想多了。

兼容性写法：

if (!Array.prototype.lastIndexOf) {
    Array.prototype.lastIndexOf = function (searchElement, fromIndex) {
        var result = -1;
        for (var i = (fromIndex ? fromIndex : this.length - 1); i > -1; i--) {
            if (this[i]) {
                if (searchElement === this[i]) {
                    result = i;
                    break;
                }
            }
        }
        return result; //所有元素都符合条件，返回true
    }
}