JavaScript---迭代方法

最近在看javascript高级程序设计，第五章引用类型里面讲到了迭代方法，之前一直不太搞的清楚，现在梳理一下。
总共有五个迭代方法：

• every() : 对数组中的每一项运行给定函数，如果该函数对每一项都返回true,则返回true
• some() : 对数组中的每一项运行给定函数，如果该函数对任一项返回true,则返回true
• filter() : 对数组中的每一项运行给定函数，返回该函数会返回true的成员
• forEach() : 对数组中的每一项运行给定函数，这个方法没有返回值
• map() : 对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组

以上方法都不会修改原数组中的值。
每个方法接受两个参数，第一个参数是函数，函数内部接受三个参数，数组项的值，该项在数组中的位置，和数组对象本身。第二个参数是运行该函数的作用域对象，可选。

every()

var arr = [1,2,3,4,5];
var result = arr.every((item,index)=>{
        return item>0
    })
result;   //true

var arr = [1,2,3,4,5];
var result = arr.every((item,index)=>{
        return item>2
    })
result;   //false

浏览器内部实现

Array.prototype.every=function(callbackfn,thisArg){
    var T,K;
    var me=this;
    // 判断第一个参数是否为函数
    if(typeof callbackfn !== 'function'){
        throw new TypeError()
    }
    // 判断是否存在第二个参数
    if(arguments.length>1){ 
        T=thisArg;
    }
    K=0;
    while(k<this.length){
        var kValue;

        if(k in me){
            kValue=me[k];
            var testResult = callbackfn.call(T,kValue,k,me)
            // 在callback函数中返回为false时直接返回false
            if(!testResult){
                return false;
            }
        }
        k++;
    }
    return true;
}

---

some()

var arr = [1,2,3,4,5];
var result = arr.some((item,index)=>{
        return item>4
    })
result;   //true

var arr = [1,2,3,4,5];
var result = arr.some((item,index)=>{
        return item>5
    })
result;   //false

浏览器内部实现

Array.prototype.some=function(callback,thisArg){
    var me=this;
    if(typeof callback !== 'function'){
        throw new TypeError();
    }
    var len=this.length;
    var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
    for(var i=0;i<len;i++){
        //有任何一个满足的就返回true
        if(i in me && callback.call(thisArg,me[i],i,me)){
            return true;
        }
    }
    return false;
}

---

filter()

var arr = [1,2,3,4,5];
var result = arr.filter((item,index)=>{
        return item>2
    })
result;   //[3,4,5]

var arr = [1,2,3,4,5];
var result = arr.filter((item,index)=>{
        return item>5
    })
result;   //[]

浏览器内部实现

Array.prototype.filter=function(callback,thisArg){
    var me=this;
    if(typeof callback !== 'function'){
        throw new TypeError();
    }
    var len=this.length;
    var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
    var res=[];
    for(var i=0;i<len;i++){
        // 满足回掉函数则加入数组返回
        if(i in me && callback.call(thisArg,me[i],i,t)){
            res.push(me[i])
        }
    }
    return res; 
}

---

forEach()

var arr=[1,2,3,4,5];
arr.forEach((item,index)=>{
    console.log(item)
})
//纯操作，不带返回值
//1 2 3 4 5

浏览器内部实现

Array.prototype.forEach=function(callback,thisArg){
    var T,K;
    var me=this;
    // 判断第一个参数是否为函数
    if(typeof callbackfn !== 'function'){
        throw new TypeError()
    }
    // 判断是否存在第二个参数
    if(arguments.length>1){ 
        T=thisArg;
    }
    K=0;
    while(k<me.length){
        var kValue;
        if(k in me){
            kValue=me[k];
            callback.call(T,kValue,k,me)
        }
        k++;
    }
}

---

map()

var arr=[1,2,3,4,5];
arr.map((item,index)=>{
    return item+1
})
//[2,3,4,5,6]

浏览器内部实现

Array.prototype.map=function(callback,thisArg){
    var k; 
    var me=this;
    var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
    if (typeof callback !== 'function') {
        throw new TypeError(callback + ' is not a function');
    }
    k=0;
    var arr=new Array(me.length);
    while (k<me.length){
        var kValue, mappedValue;
        if(k in me){
            kValue=me[k];
            mappedValue=callback.call(thisArg,kValue,k,me);
            arr[k]=mappedValue
        }
    }
    return arr;
}