數組的經常使用方法

------------恢復內容開始------------

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]

------------恢復內容結束------------