Array的方法

1. slice()对应string的substring(),它截取数组的部分元素,返回一个新的数组:

            var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
            arr.slice(0, 3); // 从索引0开始，到索引3结束，但不包括索引3: ['A', 'B', 'C']
            arr.slice(3); // 从索引3开始到结束: ['D', 'E', 'F', 'G']

注意到:slice()的参数包含开始索引,不包含结束索引  
         如果不给slice()传递参数,将从头到尾截取所有元素,利用这一点,我们很容易复制一个数组:  


                var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
                var aCopy = arr.slice();
                aCopy; // ['A', 'B', 'C', 'D', 'E', 'F', 'G']
                aCopy === arr; // false

   2. push()和pop() , push()想数组末尾加若干元素,pop()删除数组最后一个元素,并返回该元素:

            var arr = [1, 2];
            arr.push('A', 'B'); // 返回Array新的长度: 4
            arr; // [1, 2, 'A', 'B']
            arr.pop(); // pop()返回'B'
            arr; // [1, 2, 'A']
            arr.pop(); arr.pop(); arr.pop(); // 连续pop 3次
            arr; // []
            arr.pop(); // 空数组继续pop不会报错，而是返回undefined
            arr; // [] 

3.unshift()和shift(),  unshift()向Array头部插入若干元素,  shift()则是删除数组的第一个元素:

          var arr = [1, 2];
          arr.unshift('A', 'B'); // 返回Array新的长度: 4
          arr; // ['A', 'B', 1, 2]
          arr.shift(); // 'A'
          arr; // ['B', 1, 2]
          arr.shift(); arr.shift(); arr.shift(); // 连续shift 3次
          arr; // []
          arr.shift(); // 空数组继续shift不会报错，而是返回undefined
          arr; // []

4.sort(), 对当前Array排序,它会直接修改当前Array的元素位置,直接调用时,按默认的顺序排序:

        var arr = ['B', 'C', 'A'];
        arr.sort();
        arr; // ['A', 'B', 'C']

5.reverse(),把整个的Array元素反转:

       var arr = ['one', 'two', 'three'];
       arr.reverse(); 
       arr; // ['three', 'two', 'one']


6.splice()方法是修改数组的"万能方法",它可以从制定索引的位置开始,删除若干元素,再从该位置添加若干元素:

             //删除又添加
             var arr = ['Microsoft', 'Apple', 'Yahoo', 'AOL', 'Excite', 'Oracle'];
              // 从索引2开始删除3个元素,然后再添加两个元素:
              arr.splice(2, 3, 'Google', 'Facebook'); // 返回删除的元素 ['Yahoo', 'AOL', 'Excite']
              arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']

             // 只删除,不添加:
            arr.splice(2, 2); // ['Google', 'Facebook']
            arr; // ['Microsoft', 'Apple', 'Oracle']

             // 只添加,不删除:
           arr.splice(2, 0, 'Google', 'Facebook'); // 返回[],因为没有删除任何元素
           arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']

7.concat()把当前数组与另一个数组链接起来,返回一个新的数组:

           var arr = ['A', 'B', 'C'];
           var added = arr.concat([1, 2, 3]);
           added; // ['A', 'B', 'C', 1, 2, 3]
           arr; // ['A', 'B', 'C']

      实际上concat()可以接收任意多个元素和数组,并自动把数组拆开,然后全部添加到新的数组里:

          var arr = ['A', 'B', 'C'];
          arr.concat(1, 2, [3, 4]); // ['A', 'B', 'C', 1, 2, 3, 4]

8.join()将当前数组按制定的字符串连接起来,然后返回连接后的字符串:

            var arr = ['A', 'B', 'C', 1, 2, 3];
            arr.join('-'); // 'A-B-C-1-2-3'
            如果Array的元素不是字符串，将自动转换为字符串后再连接

9.find() ,找到匹配的就返回该匹配的元素

       //最右边的barcode 是前面已经给出的

   const cartItem = cartItems.find(cartItem => cartItem.item.barcode === barcode);
cartItems 是一个数组，它里面的每个元素我们自己把它叫 cartItem（也可以是别的，因为是虚有的） ， 每一个元素是一个 key ：item，value ：内容是一系列包含barcode 的键值对，只要找到固定的barcode，即 cartItem.item.barcode===barcode为true ，该find（）函数就返回 该元素cartItem 

10. map（），改变数组的每个元素

                    使用数组的map()方法：
                    比如：array = [1,2,3];   
                    let arr = array.map(i => i *2)  ; // i表示数组array 的每一个元素, 这样 i 的值聚会被改变为 i*2
                   结果: arr = [2, 4, 6];

                   代码中的实例:  

         let buildReceiptItems = (cartItems, promotions) => {
             return cartItems.map(cartItem => {
              let promotionType = getPromotionType(cartItem.item.barcode, promotions);
              let {subtotal, saved} = discount(cartItem, promotionType);
              return {cartItem, subtotal, saved};  
           })
         };

                  代码解释:   1. map函数中的参数cartItem 表示 数组cartITems 的每一个元素,该cartItem 会被map函数中的

                                         返回值 {cartItme,subtotal,saved} 替换
                                    2.ES新特性: 当一个对象的 key 和 value 完全一样的时候,可以只写一个
　　　　　　             比如：return {cartItem：cartItem , subtotal : subtotal, saved : saved}   
                                            等价于   return { cartItem, subtotal, saved };  

11.includes（） 
              ES6 数组的新方法 includes() ,比 find() 简单,只是去找一个数组里面有没包含一个指定的元素 ，

         function getPromotionType(barcode, promotions) {
             const promotion = promotions.find(promotion => promotion.barcodes.incluses(barcode));
             return promotion ? promotion.type : undefined;
          };

12.some() 判断数组师是否包含一个元素，返回的是一个true or false 

           arr.some(callback[, thisArg]) 
some 为数组中的每一个元素执行一次 callback 函数，直到找到一个使得 callback 返回一个“真值”（即可转换为布尔值 true 的值）。如果找到了这样一个值，some 将会立即返回 true。否则，some 返回 false。callback 只会在那些”有值“
索引上被调用，不会在那些被删除或从来未被赋值的索引上调用。  
some 被调用时不会改变数组

        var number = [2, 5, 8, 1, 4].some( element =>  element >= 10 ) ;
       // passed is true
        var number = [12, 5, 8, 1, 4].some( element => element >= 10 );
       // passed is true

       const promotion = promotions.find(promotion => promotion.barcodes.some(b => b === barcode));

13.filter() 一个数组变成另外一个数组

 arr.filter(callback[, thisArg])   
callback用来测试数组的每个元素的函数。调用时使用参数 (element, index, array)。返回true表示保留该元素（通过测试），false则不保留。
filter 为数组中的每个元素调用一次 callback 函数，并利用所有使得 callback 返回 true或 等价于 true 的值 的元素 创建一个新数组。
callback 只会在已经赋值的索引上被调用，对于那些已经被删除或者从未被赋值的索引不会被调用。那些没有通过callback 测试的元素会被跳过，不会被包含在新数组中。
           
     例子：筛选排除掉所有的小值  ， 下例使用 filter 创建了一个新数组，该数组的元素由原数组中值大于 10 的元素组成。

         var filtered = [12, 5, 8, 130, 44].filter( number => element >= 10 ); // filtered is [12, 130, 44] 

14 . reduce（）
 数组 arr = [1,2,3,4] 求数组的累加求和

var arr = [1,2,3,4];

arr.reduce( function ( pre,cur ) {  return pre + cur  } ) ;      // return 10

prev: 第一项的值或者上一次叠加的结果

cur: 当前会参与叠加的项

 

15.every()

 

 

 

数组的方法学习（查询）网址： https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/filter