数组方法every,some,map,reduce

every：全部满足条件就返回true，否则返回false,只要不满足条件，就不再继续遍历。

传参：可传两个参数第一个是function(ele, index, self)必传但是ele，index，self看情况传。ele代表数组的某一项，index代表索引，self代表数组本身。第二个参数改变this指向，可传可不传

some:有一个满足条件就返回true，否则false，就算最后返回false，也会遍历完整个数组

举例

var demo = [
                {name : '重庆', 
                 NO : 1,
                 city : '重庆'
                },
                {name : '北京', 
                 NO : 2,
                 city : '北京'
                },
                {name : '四川', 
                 NO : 3,
                 city : '成都'
                },
            ]

            var flag = demo.every(function(ele, index, self){
                console.log(ele, index, self);
                return ele.NO > 0;
            })
            console.log(flag);

var flag = demo.every(function(ele, index, self){
                console.log(ele, index, self);
                return ele.NO > 2;
            })
            console.log(flag);

some

var flag = demo.some(function(ele, index, self){
                console.log(ele, index, self);
                return ele.NO > 2;
            })
            console.log(flag);

重写every方法

Array.prototype.myEvery = function (func) {
            var _arr = this,
                len = _arr.length,
                param2 = arguments[1] || window,
                flag = true;
            for (var i = 0; i < len; i++){
                if (!func.apply(param2, [_arr[i], i, _arr])){
                    flag = false;
                    break;
                }
            }
            return flag;
        }

试试效果：

var flag = demo.myEvery(function(ele, index, self) {
        console.log(ele, index, self);
        return ele.NO > 0;
      });
      console.log(flag);

map:传参和意义和上面一样，映射数组中的每一项，返回一个新数组，不要返回引用值，会导致原数组被修改

var demo = [
        { name: "重庆", NO: 1, city: "重庆" },
        { name: "北京", NO: 2, city: "北京" },
        { name: "四川", NO: 3, city: "成都" }
      ];
var result =  demo.map(function(ele, index, self){
            if(ele.NO != 0){
                return ele.name + 'good';
            }else{
                return;
            }
        })
        console.log(result);      

重写map方法

Array.prototype.myMap = function (func) {
            var _arr = this,
                len = _arr.length,
                param2 = arguments[1] || window,
                newArr = [];
            for (var i = 0; i< len; i++){
                newArr.push( func.apply(param2, [_arr[i]], i, _arr));//为了防止改变原数组 最好使用深度克隆
            }
            return newArr;
        };
        
var result =  demo.myMap(function(ele, index, self){
            if(ele.NO != 0){
                return ele.name + 'good';
            }else{
                return;
            }
        })
        console.log(result);

reduce:两个参数都必须，第一个是函数function，参数分别是prevValue(初始值)，ele，index，self。第二个参数是initValue（初始化值）。执行的时候initvalue就是prevValue的值，每次执行都需要返回一个值，作为下一次prevValue，相当于接力。

举例理解

var demo = [
        { name: "重庆", NO: 1, city: "重庆" },
        { name: "北京", NO: 2, city: "北京" },
        { name: "四川", NO: 3, city: "成都" }
      ];
        var initValue = 'good';
        var result = demo.reduce(function(prevValue, ele, index, self){
            ele.NO += 1;
            console.log(prevValue, ele, index, self);
            return prevValue;
        }, initValue);

这里的good就是prevValue，因为每次都返回prevValue，所以每次都输出good

重写reduce方法

Array.prototype.myReduce = function (func, initValue) {
            var _arr = this,
                len = _arr.length,
                param2 = arguments[2] || window;
                for (var i = 0; i < len; i++){
                    initValue = func.apply(param2, [initValue, _arr[i], i, _arr]);
                }
                return initValue;
        };
 var demo = [
        { name: "重庆", NO: 1, city: "重庆" },
        { name: "北京", NO: 2, city: "北京" },
        { name: "四川", NO: 3, city: "成都" }
      ];
        var initValue = 'good';
        var result = demo.myReduce(function(prevValue, ele, index, self){
            ele.NO += 1;
            console.log(prevValue, ele, index, self);
            return prevValue;
        }, initValue);

数组方法filter
数组方法forEach