关于javascript:数组方法重构与迭代

数组办法重构

1.Array.prototype.pop()

(1) pop() 办法用于删除数组的最初一个元素并返回删除的元素。留神：此办法会扭转数组的长度！语法：array.pop()
    返回值：所有类型  返回删除的元素
    var fruits = ["Banana", "Orange", "Apple", "Mango"];
    fruits.pop();
    console.log(fruits);
    //fruits 后果输入：Banana,Orange,Apple
(2) 重构 pop() 办法
    Array.prototype.myPop = function(){if(this.length==''){return undefined;}else{var result = this[this.length-1];
            this.length--;
            return result;
        }
    }

    var arr = [1,2,3,4,5];
    console.log(arr);
    var result = arr.myPop();
    console.log(result);
后果如图：![图片.png](/img/bVcUyCl)

2.Array.prototype.push()

(1)push() 办法可向数组的开端增加一个或多个元素，并返回新的长度。留神：新元素将增加在数组的开端，此办法扭转数组的长度
    语法：array.push(item1, item2, ..., itemX)
    返回值：Number  数组新长度
      var fruits = ["Banana", "Orange", "Apple", "Mango"];
      // push()  增加元素到开端  参数是要增加的元素 返回值是批改之后数组的长度【扭转原数组】fruits.push("Kiwi")
      console.log(fruits);
      //fruits 后果输入：Banana,Orange,Apple,Mango,Kiwi
(2)push() 办法重构    
    Array.prototype.myPush = function(){for(var i = 0; i<arguments.length; i++){this[this.length]=arguments[i];
        }
    }
    var arr = [1,2,3,4,5];
    console.log(arr);
    var result = arr.myPush('a');
    console.log(result);
    后果如图：![图片.png](/img/bVcUyCC)

3.Array.prototype.shift()

(1) shift() 办法用于把数组的第一个元素从其中删除，并返回第一个元素的值。留神：此办法扭转数组的长度！返回值：任何类型（*）数组原来的第一个元素的值（移除的元素）。var fruits = ["Banana", "Orange", "Apple", "Mango"];
    fruits.shift()
    console.log(fruits);
    //fruits 后果输入:Orange,Apple,Mango
(2) shift() 办法重构
    Array.prototype.myShift = function(){var result = this[0];
        for(var i=0; i<this.length; i++){this[i]=this[i+1];
        }
        this.length--;
        return result;
    }
    var arr = [1,2,4,5];
    console.log(arr);
    var result = arr.myShift();
    console.log(result);
    console.log(arr);
    后果如图：![图片.png](/img/bVcUyCV)

4.Array.prototype.myUnshift()

(1)unshift() 办法可向数组的结尾增加一个或更多元素，并返回新的长度。留神：该办法将扭转数组的数目
    语法：array.unshift(item1,item2, ..., itemX)
    参数：item1,item2,...,itemX  形容：可选。向数组起始地位增加一个或者多个元素
    返回值：Type 形容 Number 数组新长度
      var fruits = ["Banana", "Orange", "Apple", "Mango"];
      fruits.unshift("Lemon","Pineapple");
      console.log(fruits)
      //fruits 将输入：Lemon,Pineapple,Banana,Orange,Apple,Mango
(2)unshift() 办法重构
    Array.prototype.myUnshift = function(){
        var sum = this.length+arguments.length;
        for(var i=sum; i>0; i--){if(i>arguments.length){this[i-1]=this[i-1-arguments.length];
            }else{this[i-1]=arguments[i-1];
            }
        }
        return sum;
    }
    var arr = [1,2,3,4,5];
    console.log(arr);
    var result = arr.myUnshift('a','b','c');
    console.log(result);
    console.log(arr);
后果如图：![图片.png](/img/bVcUyDM)

迭代办法重构

1.Array.prototype.forEach()

(1)forEach() 办法用于调用数组的每个元素，并将元素传递给回调函数
    留神: forEach() 对于空数组是不会执行回调函数的。语法：array.forEach(function(currentValue, index, arr), thisValue)
    参数：

    返回值：undefined
    var numbers = [4, 9, 16, 25];
    numbers.forEach(function (number, index) {console.log(index + '--' + number);
    })
    // 0 -- 4
    // 1 -- 9
    // 2 -- 16
    // 3 -- 25
(2) forEach() 办法重构
    Array.prototype.myForEach = function(fun,){for(var i=0; i<this.length; i++){fun(this[i],i,this);
        }
    }
    var arr = [1,2,3];
    var result = arr.myForEach(function(){console.log(item,index,arr);
    });
    console.log(result);

2.Array.prototype.every()

(1)every() 办法用于检测数组所有元素是否都合乎指定条件（通过函数提供）。every() 办法应用指定函数检测数组中的所有元素：a. 如果数组中检测到有一个元素不满足，则整个表达式返回 *false*，且残余的元素不会再进行检测。b. 如果所有元素都满足条件，则返回 true。留神：every() 不会对空数组进行检测。every() 不会扭转原始数组。语法：array.every(function(currentValue,index,arr), thisValue)
    参数：

    返回值：布尔值。如果所有元素都通过检测返回 true，否则返回 false。检测数组 *ages* 的所有元素是否都大于等于 18 :
    var ages = [32, 33, 16, 40];

    var result = ages.every(function (age) {return age >= 18})
    console.log(result);// 输入后果为:false
(2)every() 办法重构
    Array.prototype.myEvery = function(fun,obj){for(var i=0; i<this.length; i++){if(!(obj?fun.bind(obj)(this[i]):fun(this[i]))){return false;}
        }
        return true;
    }
    var arr = [1,2,3,4,5];
    var result = arr.myEvery(function(item){console.log(this);// 指向全局
        return item>1;// 短路准则
    },{name:'zhangsan'})// 第二个对象存在时 this 指向这个对象
    console.log(result);

3.Array.prototype.some();

(1)some() 办法用于检测数组中的元素是否满足指定条件（函数提供）some() 办法会顺次执行数组的每个元素：a. 如果有一个元素满足条件，则表达式返回 *true* , 残余的元素不会再执行检测。b. 如果没有满足条件的元素，则返回 false。留神：some() 不会对空数组进行检测。some() 不会扭转原始数组。语法：array.some(function(currentValue,index,arr),thisValue)
    参数：

    返回值：布尔值。如果数组中有元素满足条件返回 true，否则返回 false。// 检测数组中是否有元素大于 18:
    var ages = [32, 33, 16, 40];

    var result = ages.some(function (age) {return age >= 18})
    console.log(result);// 输入后果为:true
(2)some() 办法重构
    Array.prototype.mySome = function(fun,obj){for(var i=0; i<this.length; i++){if(obj?fun.bind(obj)(this[i]):fun(this[i])){return true;}
        }
        return false;
    }
    var arr = [1,2,3,4,5];
    var result = arr.mySome(function(item){console.log(this);
        return item>1;
    },{name:'zhangsan'});
    console.log(result);

4.Array.prototype.filter()

(1)filter() 办法创立一个新的数组，新数组中的元素是通过查看指定数组中符合条件的所有元素。留神：filter() 不会对空数组进行检测。filter() 不会扭转原始数组。语法：array.filter(function(currentValue,index,arr), thisValue)
    参数：

    返回值：返回数组，蕴含了符合条件的所有元素。如果没有符合条件的元素则返回空数组。// 返回数组 *ages* 中所有元素都大于 18 的元素: 
    var ages = [32, 33, 16, 40];

    var result = ages.filter(function (age) {return age >= 18})
    console.log(result);// 输入后果为:[32, 33, 40]
(2)filter() 办法重构
    Array.prototype.myFilter = function(fun,obj){var result = [];
        for(var i=0; i<this.length; i++){if(obj?fun.bind(obj)(this[i]):fun(this[i])){result.push(this[i]);
            }
        }
        return result;
    }
    var arr = [1,2,3,4,5];
    var result = arr.myFilter(function(item){console.log(this);
        return item>2;
    },{name:'zhangsan'});
    console.log(result);

5.Array.prototype.map()

(1)map() 办法返回一个新数组，数组中的元素为原始数组元素调用函数解决后的值。map() 办法依照原始数组元素程序顺次解决元素。留神：map() 不会对空数组进行检测。map() 不会扭转原始数组。语法：array.map(function(currentValue,index,arr), thisValue)
   参数：

    返回值: 返回一个新数组，数组中的元素为原始数组元素调用函数解决后的值。// 返回一个数组，数组中元素为原始数组的平方根:
      var numbers = [4, 9, 16, 25];
      var result = numbers.map(function (number) {return Math.sqrt(number)
      })
      console.log(result);// 输入后果为:[2, 3, 4, 5]
      Array.prototype.myMap = function(fun,obj){var result = [];
          for(var i=0; i<this.length; i++){result.push(obj?fun.bind(obj)(this[i]):fun(this[i]));
          }
          return result;
      }
      var arr = [1,2,3,4,5];
      var result = arr.myMap(function(item){console.log(this);// 全局对象
          return item+1;// 新数组 数组元素 +1
      },{name:'zhangsan'})// 此时 this 指向 name
      console.log(result);