javascript數組總結

　　數組是一個有序的集合，javascript數組中的元素的類型能夠是任意的，同一個數組不一樣元素之間的類型也是能夠不一樣的。數組也是對象，有個length屬性，記錄數組的長度。

 

1. 建立數組
   有兩種方法：
   　　數組直接量，var arr = [1,2,];這樣會建立一個有兩個元素的數組。之因此不是3個元素，是由於最後一個逗號是可選的。
   　　另一種是調用構造函數：
   　　    var arr = new Array(10);這樣會建立一個具備10個元素的數組；或者
             var arr = new Array(1，2,3,4,5,6);直接傳進數組元素
   　　
2. 數組元素的讀寫
   數組是特殊的對象，數組特殊在維護了一個length屬性。數組的索引其實也就是對象的屬性，0--2`32-2的屬性值是索引。0--2`32-2的索引會自動轉化爲字符串的屬性值。以下：

   var a = [1,2];
       console.log(a.[0])//1

   數組是對象，這由於着能夠給它添加屬性：

   var a = [];
   a.test = 'test';
   console.log(a.length);
   a['0'] = 3;
   console.log(a.length);
   console.log(a.test);//test
   console.log(a['0']);//3
   console.log(a[0])//3

   從上面也能夠看到，給數組添加‘0’的屬性，也會自動轉化成索引。

3. 數組長度
   length屬性老是比最大的一個索引大1（非稀疏數組）。這個length屬性有一些特殊的行爲。
   往數組添加索引時，自動維護：

   var a = [1,2,3];
       console.log(a.length);//3
       a[3] = 4;
       console.log(a.length);//4

   更改length爲比如今當前長度的非負整數的時候，大於等於長度的那些元素會被刪除：

   　　var a = [1,2,3,4,5,6,7,8,9];
       console.log(a.length);//9
       a.length = 8;
       console.log(a[8]);//undefined
       a.length = 7;
       console.log(a[7]);//undefined

   更改length爲比當前長度達的非負整數的時候，至關於增長了空白區域。

4. 數組遍歷
   使用for：

   for(var i = 0; i < array.length; i++){
           
       }

   這樣作有個問題就是：要訪問不少遍array的length屬性，因此更好的作法是下面這種：

   for(var i = 0, len = array.length; i < len; i++){
   
       }

    

   或者像下面這樣從後面開始遍歷：

   for(var i = array.length - 1; i >= 0; i--){
           
       }

   另外能夠用for/in來遍歷：

   for(var i in array){
           
       }

   可是這樣子帶來的問題就是，除了索引屬性以外，還會有繼承來的屬性、負整數屬性、字符串屬性也會被包含在其中。

   ecma5定義了一個forEach函數：

   　　var a = [1,2,3,4,5];
       a.forEach(function(index){
           console.log(index)
       })

    

   
   
   
5. 數組方法
   1. 　　轉換方法toString（）、toLocalString（）、valueOf（），join（）；
      valueOf獲得的仍是數組自己。而第2、第三個獲得的都是一個數組，其實是在每一個元素上調用了一次toString或toLocaleString函數。

      　　var a = [1,2,3,4,5];
          console.log(a.toLocaleString());//1,2,3,4,5
          console.log(a.toString());//1,2,3,4,5
          console.log(a.valueOf());//[1,2,3,4,5]

      並且會將數組扁平化：

      var a = [1,2,3,4,5,[ 6,7,[ 8,9] ] ];
          console.log(a.toLocaleString());// 1,2,3,4,5,6,7,8,9
          console.log(a.toString());// 1,2,3,4,5,6,7,8,9

      join方法是利用給定的字符將數組元素連成一個字符串。實際上對每一個元素調用了toString方法。

   2. var a = [1,2,3,4,5,[6,7,[8,9]]]
      console.log( a.join('*') );//1*2*3*4*5*6,7,8,9
      console.log(a);//var a = [1,2,3,4,5,[6,7,[8,9]]]

   3. 棧方法push（）、pop（）
      push會在數組後面添加一個元素，並增長length的值。

          var a = [1,2,3,4,5];
          console.log(a.length);//5
          a.push(6);
          console.log(a.length);//6
          console.log( a[a.length - 1] );//6

      pop恰好相反，它會返回刪除的元素。

   4. 隊列方法shift（）、unshift（）
      shift將數組的第一個元素刪除並返回，後面的元素往前移，減小length的值。

          var a = [1,2,3,4,5];
          console.log(a.length);//5
          a.shift();
          console.log(a.length);//4
          console.log( a[0] );//2

      unshift恰好相反。

   5. 重排序方法reverse（）、sort（）
      reverse方法是將數組反序。

          var a = [1,2,3,4,5];
          console.log( a.reverse() );//[5, 4, 3, 2, 1]
          console.log(a);//[5, 4, 3, 2, 1]

      能夠看到，reverse是直接改變數組自己的。
      另外一個sort方法接受一個函數做爲排序的依據。若是不傳這個參數，則是對每一個元素調用toString方法而後比較。也就是所有轉換爲字符串而後再比較。

          var a = [2,43,25,64,62,45,75,10,4,7]
          console.log(a.sort());//[10, 2, 25, 4, 43, 45, 62, 64, 7, 75]
          console.log(a);//[10, 2, 25, 4, 43, 45, 62, 64, 7, 75]

      若是傳入函數，則函數有兩個參數，就是兩個要進行比較的數據。如function（a1，a2）{}；要想a1排在前面就返回小於0；要想順序不變返回0；另外一種狀況你懂得。如想要按照數字的小到大排序。

      　　var a = [2,43,25,64,62,45,75,10,4,7]
          console.log(a.sort(function(a, b){
              return a - b;
          }));//[2, 4, 7, 10, 25, 43, 45, 62, 64, 75]
          console.log(a);//[2, 4, 7, 10, 25, 43, 45, 62, 64, 75]

   6. 操做方法concat()、slice（）、splice（）
      concat是將一個數組並接在另一個數組後面。

          var a = [1,2,3,4];
          var b = [5,6,7,[7,8],9];
          console.log(a.concat(b))//[1, 2, 3, 4, 5, 6, 7, [7,8], 9]
          console.log(a)//[1,2,3,4];
          console.log(b)//[5,6,7,[7,8],9]

      能夠看到concat並不會將數組扁平化、並且不會改變原數組。它是想建立一個a的副本，而後將b複製進去而後返回。
      
      slice是基於當前數組，建立一個新的數組。接受兩個參數，第二個參數是可選的。若是隻有一個參數，就是從指定位置到最後一個的項。若是有兩個參數，則是從第一個到第二個指定位置的項，但不包括最後一個。第二個參數能夠是負數，-1表明最後一個項，但不包括最後一個。

          var a = [1,2,3,4,5];
          console.log( a.slice(1) );//[2,3,4,5]
          console.log( a.slice(0, 3) );//[1,2,3]
          console.log( a.slice(0, -3) );;//[1,2]

      一樣的，slice不會改變原數組。而且當第二個參數的位置在第一個參數位置以前的時候，會返回一個空數組。
      
      splice功能很是強大，能夠刪除、插入、替換
      若是隻傳入兩個參數，就是刪除，第一個參數表明要刪除的其實位置，第二個參數表明要刪除的項的個數。

      　　var a = [1,2,3,4,5];
          console.log(a.splice(1,2));//[2,3]
          console.log(a);//[1,4,5]

      
      若是傳入兩個以上參數，而且第二個參數是0，就是插入。第一個參數表明要插入的位置，第三個以及之後的參數表明要插入的項。

          var a = [1,2,3,4,5];
          console.log(a.splice(1,0,7,8));//[]
          console.log(a);//[1,7,8,2,3,4,5]

      
      若是傳入兩個以上參數，而且第二個參數不是0，就是替換。第一個參數表明要替換的開始位置，第二個參數表明要替換掉多少個項，第三個以及之後的參數表明要替換進去的項。

          var a = [1,2,3,4,5];
          console.log(a.splice(1,2,7,8));//[2,3]
          console.log(a);//[1,7,8,4,5]

      最後看一個例子：

          var a = [1,2,3,4,5];
          console.log(a.splice(-1,2,7,8));//[5]
          console.log(a);//[1, 2, 3, 4, 7, 8]

      這個例子說明，第一個參數接受負數，-1表明最後一個項。

   7. 位置方法indexOf（）、lastIndexOf（）
      兩個方法的區別是一個從前日後找，一個從後往前找。返回第一個找到的項的位置。
      接受兩個參數，第一個是要查找的項，第二個是開始的位置。

          var a = [1,2,3,4,5,4,3,2,1]
          console.log(a.indexOf(4));//3
          console.log(a.lastIndexOf(4));//5

      
      
      
   8. 迭代方法forEach（）、some（）、map（）、filter()、every（）
      這些方法都接受兩個參數，第一個是一個將要被調用的函數，第二個參數是可選的，若是有第一個函數會做爲該參數的方法調用。傳入的函數有三個參數，數組元素、元素索引、數組自己
      
      forEach是對每一個項調用函數，沒有返回值。且不能用break提早結束。
      map對每一個項調用函數，返回函數返回值組成的數組。
      filter對每一個項調用函數，返回使函數返回值爲true的項組成的數組。該方法會跳過空元素。
      every對每一個項調用函數，若是每一個返回值都爲true才返回true。
      some對每一個項調用函數，若是每一個返回值都爲false才返回false。
   9. 歸併函數reduce（），reduceRight（）
      這些方法都接受兩個參數，第一個是一個將要被調用的函數，第二個參數是可選的，是傳遞個函數的初始值。傳入的函數有四個參數，上一次歸併結果、數組元素、元素索引、數組自己。
      reduce會從第一個項開始調用函數，函數返回值做爲第一個參數傳給下一次函數調用，以此類推，直到最後，返回一個最後的值做爲返回值。

      var a = [];
          for(var i = 1; i <= 100; i++){
              a[i-1] = i;
          }
          var resule = a.reduce(function(last, value, i, arr){
              return last + value
          })
          console.log(resule)//5050