数组的常用方法

------------恢复内容开始------------

1.push()方法

   push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度。末尾添加，返回的是长度，会改变原数组

   eg: var arr=[1,2,3,5,6]

          var  brr= arr.push(9);

          console.log(arr)  // [1,2,3,5,6,9]

          console.log(brr) // 6

2.pop()方法

  pop() 方法用于删除并返回数组的最后一个元素。返回最后一个元素，会改变原数组。

  eg:var arr=[1,2,3,4,5]

       var brr=arr.pop();

       console.log(arr);// [1, 2, 3, 4]

       console.log(brr);// 5

3.unshift()方法

  unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。返回新长度，改变原数组。

   eg: var arr=[1,2,3,4,5]

        var brr=arr.unshift(8);

        console.log(arr);// [8,1,2,3,4,5]

        console.log(brr) // 6

4.shift()方法

   shift() 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。返回第一个元素，改变原数组。

   eg: var arr=[1,2,3,4,5]

          var brr=arr.shift();     

          console.log(arr);// [2,3,4,5]

          console.log(brr) // 1

5.slice()方法

  返回一个新的数组，包含从 start 到 end （不包括该元素）的 arrayObject 中的元素。返回选定的元素，该方法不会修改原数组。

eg:var arr=[1,2,3,4,5,6 ]

      var brr=arr.slice(0,2);

      console.log(arr); //[1,2,3,4,5,6 ]

      console.log(brr); // [1,2]

6.splice()方法

 splice() 方法可删除从 index 处开始的零个或多个元素，并且用参数列表中声明的一个或多个值来替换那些被删除的元素。如果从 arrayObject 中删除了元素，则返回的是含有被删除的元素的数组。splice() 方法会直接对数组进行修改。

eg: var arr=[1,2,3,4,5,6 ]

       var brr=arr.splice(0,2,9);    　

      console.log(arr); //[9, 3, 4, 5, 6]

      console.log(brr); // [1,2]

7.join()方法

  join() 方法用于把数组中的所有元素放入一个字符串。元素是通过指定的分隔符进行分隔的，默认使用','号分割，不改变原数组.

 eg: var arr=[1,2,3,4,5];

        var brr=arr.join();

        console.log(arr);// [1, 2, 3, 4, 5]

        console.log(brr);//  "1,2,3,4,5"

8.cancat()方法

 cancat()方法用于连接两个或多个数组。该方法不会改变现有的数组，仅会返回被连接数组的一个副本。

eg: 

 var arr1=[1,2,3]
 var arr2=[4,5,6]
 var arr3 = arr1.concat(arr2);
 console.log(arr1); //[1, 2, 3]
 console.log(arr3); //[1, 2, 3, 4, 5]

9.sort() 排序:按照 Unicode code 位置排序，默认升序

  eg:  var scores = [1, 10, 21, 2];

          scores.sort(); // [1, 10, 2, 21]

          var arr=['bsdxd','asdc','csdx'];

           arr.sort(); // ['asdc','bsdxd','csdx']

10.reverse() 方法：

     reverse() 方法用于颠倒数组中元素的顺序。返回的是颠倒后的数组，会改变原数组。

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

          arr.reverse(); //[4,3,2,1]

11.indexOf() 和 lastindexof():

    都接受两个参数：查找的值、查找起始位置不存在，返回 -1 ；存在，返回位置。indexOf 是从前往后查找， lastIndexOf 是从后往前查找。

   eg:  var a = [2, 9, 9];

   a.indexOf(2); // 0
   a.indexOf(7); // -1

 

 12.every()方法：

     对数组的每一项都运行给定的函数，每一项都返回 ture,则返回 true；

   eg:  function isBigEnough(element, index, array) {

      return element < 10;
    }    
     [2, 5, 8, 3, 4].every(isBigEnough);   // true

13.some()方法：

   对数组的每一项都运行给定的函数，任意一项都返回 ture,则返回 true

   eg:   function compare(element, index, array) {

      return element > 10;
    }    
   [2, 5, 8, 1, 4].some(compare);  // false
   [12, 5, 8, 1, 4].some(compare); // true

14.forEach()方法： 数组遍历

    eg:  var  array=[1,2,3,4,5,6];

           var newarr=[];

           array.forEach(function(e){

         　　newarr.push(e)

         })

15.find() 方法：

　传入一个回调函数，找到数组中符合当前搜索规则的第一个元素，返回它，并且终止搜索。

   eg: 

  let arr = [1, "2", 3, 3, "2"]
  console.log(arr.find(n => typeof n === "number")) // 1

16.findIndex() 方法：

     传入一个回调函数，找到数组中符合当前搜索规则的第一个元素，返回它的下标，终止搜索

   eg: 

 const arr = [1, "2", 3, 3, "2"]
 console.log(arr.findIndex(n => typeof n === "number")) // 0

17.from()方法：

  将类似数组的对象（array-like object）和可遍历（iterable）的对象转为真正的数组

   eg:  const bar = ["a", "b", "c"];

       Array.from(bar);// ["a", "b", "c"]

    Array.from('string') //["s", "t", "r", "i", "n", "g"]

18.fill()方法

   用新元素替换掉数组内的元素，可以指定替换下标范围。

   eg:  arr.fill(value, start, end)

 

19.keys()方法：返回迭代器，返回键值对的key 

   eg:

      //数组

     const arr = ['a', 'b', 'c'];
     for(let v of arr.keys()) {
       console.log(v)
     }
     // 0 1 2

  //Set
    var arr = new Set(['a', 'b', 'c']);
     for(let v of arr.keys()) {
       console.log(v)
     }
     // 'a' 'b' 'c'

  //Map
    const arr = new Map();
    arr.set('a', 'a');
    arr.set('b', 'b');
    for(let v of arr.keys()) {
     console.log(v)
    }
    // 'a' 'b'

20.values()方法：返回迭代器，返回键值对的value

   eg:  

 // 数组
  const arr = ['a', 'b', 'c'];
  for(let v of arr.values()) {
    console.log(v)
  }
  //'a' 'b' 'c'

 //Set
  const arr = new Set(['a', 'b', 'c']);
  for(let v of arr.values()) {
    console.log(v)
  }
 // 'a' 'b' 'c'

 //Map
  const arr = new Map();
  arr.set('a', 'a');
  arr.set('b', 'b');
  for(let v of arr.values()) {
    console.log(v)
  }  
  // 'a' 'b'

21.entries() 方法：返回迭代器：返回键值对

    eg:

  //数组
   const arr = ['a', 'b', 'c'];
   for(let v of arr.entries()) {
     console.log(v)
   }
   // [0, 'a'] [1, 'b'] [2, 'c']

  //Set
   const arr = new Set(['a', 'b', 'c']);
   for(let v of arr.entries()) {
    console.log(v)
   }
  // ['a', 'a'] ['b', 'b'] ['c', 'c']

  //Map
   const arr = new Map();
   arr.set('a', 'a');
   arr.set('b', 'b');
   for(let v of arr.entries()) {
     console.log(v)
   }
   // ['a', 'a'] ['b', 'b']

22.includes()方法：

   判断数组中是否存在该元素，参数：查找的值、起始位置，可以替换 ES5 时代的 indexOf 判断方式。indexOf 判断元素是否为 NaN，会判断错误。

   eg:   var a = [1, 2, 3];

      a.includes(2); // true

    a.includes(4); // false

 23.copyWithin() 方法：

   选择数组的某个下标，从该位置开始复制数组元素，默认从0开始复制。也可以指定要复制的元素范围。

eg: arr.copyWithin(target, start, end)
    const arr = [1, 2, 3, 4, 5]
    console.log(arr.copyWithin(3))
    // [1,2,3,1,2] 从下标为3的元素开始，复制数组，所以4, 5被替换成1, 2
    const arr1 = [1, 2, 3, 4, 5]
    console.log(arr1.copyWithin(3, 1)) 
    // [1,2,3,2,3] 从下标为3的元素开始，复制数组，指定复制的第一个元素下标为1，所以4, 5被替换成2, 3
    const arr2 = [1, 2, 3, 4, 5]
    console.log(arr2.copyWithin(3, 1, 2)) 
    // [1,2,3,2,5] 从下标为3的元素开始，复制数组，指定复制的第一个元素下标为1，结束位置为2，所以4被替换成2

 24.of()方法：用于将一组值，转换为数组。这个方法的主要目的，是弥补数组构造函数 Array() 的不足。因为参数个数的不同，会导致 Array() 的行为有差异。　

    eg:  

   Array()             // []
   Array(3)           // [, , ,]
   Array(3, 11, 8)    // [3, 11, 8]
   Array.of(7);       // [7]
   Array.of(1, 2, 3); // [1, 2, 3]
   Array(7);          // [ , , , , , , ]
   Array(1, 2, 3);    // [1, 2, 3]

------------恢复内容结束------------