模拟实现ECMAScript5新增的数组方法

ECMAScript5 新增了十个数组方法，这些方法只有在ie9及以上浏览器中可以被使用，下面是对于这些方法的模拟实现。

一、Array.isArray(element)

　　该方法用于判断传入的对象是否为数组类型，返回true和false。

    Array.newIsArray = function(element){
        return Object.prototype.toString.call(element).slice(8,-1).toLocaleLowerCase() === 'array';
    }

　　

二、.indexOf(element)

　　该方法用于查找传入对象在数组中的位置，并返回该位置，若没有找到则返回-1，该方法不能用于寻找undefined。

　　indexOf方法可以和~符配合使用。按位运算符~会将传入数字取反并减一，所以-1就会变成0，这时候把它放在判断条件中会被隐式转换为false。

    Array.prototype.newIndexOf = function(element){
        var index = -1;
        for(var i = 0; i < this.length; i++){
            if(this[i] === element && this[i] !== undefined){
                index = i;
                break;
            }
        }
        return index;
    };
    var a = [1,2,3,4,,,5];
    console.log(a.newIndexOf(undefined));

　　

三、lastIndexOf(element)

　　该方法与indexOf(element)作用和返回值相同，唯一不同的地方是它是从右向左寻找。

    Array.prototype.newLastIndexOf = function(element){
        var index = -1;
        for(var i = this.length - 1; i >= 0; i--){
            if(this[i] === element && this[i] !== undefined){
                index = i;
                break;
            }
        }
        return index;
    };
    var a = [1,2,3,4,5,2,,,3];
    console.log(a.newLastIndexOf(undefined));

　　

四、forEach(function(element, index, array){})

　　遍历数组，参数为一个回调函数，有三个传参：当前元素、当前元素索引、整个数组，该方法会跳过保留缺失成员，不会破坏原数组。

    Array.prototype.newForEach = function(fn){
        for(var i = 0; i < this.length; i++){
            if(i in this){
                fn(this[i], i, this);
            }
        }
    };
    var a = [1,2,3,undefined,undefined,4,5,2,3];
    a.forEach(function(e, i, arr){
        console.log(e, i, arr);
    })

　　

五、every(function(element, index, array){})

　　使用传入的回调函数遍历数组，当所有回调都返回true时，every方法返回true，否则返回false。该方法会跳过保留缺失成员，不会破坏原数组。

    Array.prototype.newEvery = function(fn){
        var status = true;
        for(var i = 0; i < this.length; i++){
            if(i in this){
                if(!(status = !!fn(this[i], i, this))){
                    break;
                }
            }
        }
        return status;
    };
    var a = [1,2,3,4,5,2,undefined,,3];
    console.log(a.newEvery(function(){
        console.log(arguments);
        return 1;
    }));

　　

六、some(function(element, index, array){})

　　使用传入的回调函数遍历数组，当有回调返回true时，some方法返回true，否则返回false。该方法会跳过保留缺失成员，不会破坏原数组。

    Array.prototype.newSome = function(fn){
        var status = false;
        for(var i = 0; i < this.length; i++){
            if(i in this){
                if(status = !!fn(this[i], i, this)){
                    break;
                }
            }
        }
        return status;
    };
    var a = [1,2,3,4,5,2,undefined,,3];
    console.log(a.newSome(function(){
        console.log(arguments);
        return 0;
    }));

　　

七、map(function(element, index, array){})

　　使用传入的回调函数遍历数组，使用遍历数组返回的内容组成一个新的数组，该方法会跳过空元素，但是最终结果保留缺失成员的位置，不会破坏原数组。

    Array.prototype.newMap = function(fn){
        var array = new Array(this.length);
        for(var i = 0; i < this.length; i++){
            if(i in this){
                array[i] = fn(this[i], i, this);
            }
        }
        return array;
    };
    var a = [1,2,3,4,5,2,undefined,,3];
    console.log(a.newMap(function(element, index, array){
        console.log(arguments);
        return element;
    }))

　

八、filter(function(element, index, array){})

　　使用传入的回调函数遍历数组，最终返回一个新数组，该数组中包含所有回调函数返回true的元素，不会破坏原数组。

    Array.prototype.newFilter = function(fn){
        var array = [];
        for(var i = 0; i < this.length; i++){
            if((i in this) && fn(this[i], i, this)){
                array.push(this[i]);
            }
        }
        return array;
    };
    var a = [1,2,3,4,5,2,undefined,,3];
    console.log(a.newFilter(function(element, index, array){
        console.log(arguments);
        return element;
    }))

　　

九、reduce(function(accumulator, currentValue, currentIndex, array){})

　　使用传入的回调函数遍历数组，返回最后一个回调函数调用的返回值，跳过缺失成员，不会破坏原数组。

    Array.prototype.newReduce = function(fn){
        if(this.length === 0){
            throw new TypeError('Reduce of empty array with no initial value');
        }
        var result;
        for(var i = 0; i < this.length; i++){
            if(i in this){
                if(!result){
                    result = this[i];
                }else{
                    result = fn(result, this[i], i, this);
                }
            }
        }
        return result;
    };
    var a = [,,1,2,3,4,,6,7];
    console.log(a.newReduce(function(a,b){
        console.log(arguments);
        return a + b;
    }))

　　

十、reduceRight(function(accumulator, currentValue, currentIndex, array){})

　　该方法作用于reduce相同，唯一区别是它是从右往左开始遍历。

    Array.prototype.newReduceRight = function(fn){
        if(this.length === 0){
            throw new TypeError('Reduce of empty array with no initial value');
        }
        var result;
        for(var i = this.length - 1; i >= 0; i--){
            if(i in this){
                if(!result){
                    result = this[i];
                }else{
                    result = fn(result, this[i], i, this);
                }
            }
        }
        return result;
    };
    var a = [,,1,2,3,4,,6,7];
    console.log(a.newReduceRight(function(a,b){
        console.log(arguments);
        return a + b;
    }))

　　

 

转载于:https://www.cnblogs.com/muyunren/p/6587476.html