數組方法總結---改變原數組和不改變數組（未完）

<script>
先來看看基礎
    // 1 數組定義方法  new Array 或 字面量
  var arr = new Array()

  var arr1 = [1, 2, 3, 4, 5, 6]
  </script>

需要注意的是 new Array（）創建的數組只有一位的時候，如果是數字，第一位代表的數組長度，而不是第一位的值，而且不能為小數；如果是字符串，該數組長度為1，第一位值為該字符串

 接下來是數組方法：可以先分為兩類  改變原數組和不改變原數組

1. 改變原數組：push() 用於在數組的末端添加一個或多個元素，並返回添加新元素后的數組長度

• // 1  push 用於在數組的末端添加一個或多個元素，並返回添加新元素后的數組長度
        var arr = [2, 3, 4];
        arr.push(33, 44, 55, 77);// (7) [2, 3, 4, 33, 44, 55, 77]

  而且在編輯器也可以看出進行多個參數

   

   

   既然知道push方法，我們模擬下push方法實現 

  var arr = [2, 3, 4];
        // arr.push(33, 44, 55, 77);//
        
        Array.prototype.push = function () {
          console.log(111); //   2 證明我們已經在原型鏈上 修改數組push方法
          
        }
        arr.push()   //1 此時打印 111

   Array.prototype.push = function () {
          for (var i = 0; i < arguments.length; i++) {
            this[this.length] = arguments[i]
          }
          return this.length
        }
       arr.push(222)// 打印 [2, 3, 4, 222]
       arr.push(333, 444, 555)  // 打印[2, 3, 4, 222, 333, 444, 555] // arguments.length 指向傳遞給當前函數的參數數量 

  1.改變原數組:  pop()  

  （刪除方法）（把數組的最后一位給截切出去）（括號里邊就不要想着傳參了 沒有用）每次執行，只能刪除一個

      var arr = [2, 3, 4];
      arr.pop() // [2, 3]
      arr.pop() // [2]

  1.改變原數組: unshift（從數組的最前邊添加數據和push剛好相反）（可以添加一個或多個）

•     var arr = [2, 3, 4];
      arr.unshift(111, 222, 333) //  [111, 222, 333, 2, 3, 4]
      arr.unshift(444, 555, 666) //  [444, 555, 666, 111, 222, 333, 2, 3, 4]

   1.改變原數組: shift (刪除數組的第一個元素,並且返回刪除的這個元素   這里傳參沒有用 )

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

  1.改變原數組: reverse （顛倒排列數組元素，返回改變后的數組-------》數組的第一個元素會變成最后一個，數組的最后一個元素變成第一個）

        let arr = [1, 2, 3, 4, 5, 6];
        arr.reverse(); // [6, 5, 4, 3, 2, 1]
        let ary = ["李信", "韓信", "上官婉兒", "露娜"];
        ary.reverse(); // ["露娜", "上官婉兒", "韓信", "李信"]

  1.改變原數組: sort (對數組成員進行排序，默認是按照字典順序排序) 先看例子

       let arr = [2, 3, 5, 7, 11, 23, 56 ,4, 6]
       arr.sort()  // [11, 2, 23, 3, 4, 5, 56, 6, 7]
       let arr1 = [4, 3, 2, 1]
       arr1.sort()  // [1, 2, 3, 4]
       let arr2 = [100, 102, 200, 300]
       arr2.sort() // [100, 102, 200, 300]
  
  

  MDN:也給出詳細介紹： 默認排序順序是在將元素轉換為字符串，然后比較它們的UTF-16代碼單元值序列時構建的  sort（）是可以傳入一個函數，

  let ary = [12, 3, 5, 23, 45, 56, 9];
        ary.sort((a, b) => {
          console.log(a, b);
        })
        // 打印結果
        //3 12
        //5 3
        //23 5
        //45 23
        //56 45
        //9 56

  let ary = [12, 3, 5, 23, 45, 56, 9];
        ary.sort((a, b) => a - b) // [3, 5, 9, 12, 23, 45, 56]
        ary = [11, 21, 2, 3, 23, 34, 45, 46]
        ary.sort((a, b) => b - a) // [46, 45, 34, 23, 21, 11, 3, 2]  
  這里記住一個規律 a-b 是升序  b -a 是降序 

  1.改變原數組: splice（n, m, ...）可以傳3個參數 ，並且第三個參數可以接受多個，表示：從索引n開始，刪除m個元素，后邊的參數則表示插入數組的新元素  例如：

        let arr = [2, 3, 4, 5, 6, 7, 8]
        let arr1 = arr.splice(3, 3) //[5, 6, 7]  表示從索引3 開始 刪除3個元素
            arr//   [2, 3, 4, 8]
        //1 當只有一個參數的時候 表示從該索引開始，一直刪除到數組最后一個元素 
        let ary = [22, 33, 44, 55, 66, 77]
        let ary1 = ary.splice(2)  //[44, 55, 66, 77]
            ary //此時ary為  [22, 33]
            // 所以我們用這個方法也可以清空一個數組  
        //2 當有2個參數的時候  表示從索引n開始， 刪除m個元素 
        let array = [11, 22, 33, 44, {a: 1}, {name: 'james'}]
        const res = array.splice(0, 4)   // [11, 22, 33, 44]
        array //此時array為  [{a: 1}, {name: 'james'}
  
        //3 當有3個參數的時候  表示從索引n開始， 刪除m個元素,並且在索引n處 添加/插入新的元素
          let myFish = ['衛鞅', '白圭', '嬴政', '白起', '蒙毅', '張儀']
          const removed = myFish.splice(6, 0, '荊南', '荊軻') // []
          myFish// ["衛鞅", "白圭", "嬴政", "白起", "蒙毅", "張儀", "荊南", "荊軻"]
  
  該數組可以實現我們數組的增加 刪除 

  2 .不改變原數組方法  concat()  方法用於合並兩個或多個數組。此方法不會更改現有數組，而是返回一個新數組

   var num1 = [1,2,3]
   var num2 = [11,22]
   var num3 = num1.concat(num2) //[1, 2, 3, 11, 22]

  2 .不改變原數組方法 join() 以指定參數作為分隔符，將所有數組成員連接為一個字符串返回。如果不提供參數，默認用逗號分隔

  這里記住第一點，如果是使用join方法，首先想到的是該方法會把數組轉換成字符串，轉換成字符 

• 如果數組成員是undefined或null或空位，會被轉成空字符串

• join（）是把數組按照傳入的參數轉化成字符串  

• Split（）是把字符串按照傳入的參數轉化成數組

•   var arr1 = ['JavaScript', 'Java', 'Go']
      var num1 = arr1.join()
      var num2 = arr1.join("")
      var num3 = arr1.join(",")
      var num4 = arr1.join("|")
  
      console.log(num1) //"JavaScript,Java,Go"
      console.log(num2) //"JavaScriptJavaGo"
      console.log(num3) //"JavaScript,Java,Go"
      console.log(num4) // "JavaScript|Java|Go"
  

   　　var arr2 = [undefined, 11, null,22]

      var num = arr2.join('-') //"-11--22"

  2. 不改變原數組 toString（）把數組變成字符串的方法

• var a = [1,'james','衛鞅']
  a.toString() // "1,james,衛鞅"

  2.不改變原數組  slice() 截取數組一部分，並返回，原數組不變

  slice（截取數組）和splice相似但是又有區別

  當沒有參數的時候，截取整個數組

  當有一個參數的時候，是從該位開始，一直截取到最后；

  當有2個參數的時候，是從該位開始，截取到該位（不包含該位）

•  var arr1 = ['JavaScript', 'Java', 'Go', 'C++', 'C']
      var num1 = arr1.slice() //["JavaScript", "Java", "Go", "C++", "C"]
      var num2 = arr1.slice(0) //["JavaScript", "Java", "Go", "C++", "C"]
      var num3 = arr1.slice(1) //["Java", "Go", "C++", "C"]
      var num4 = arr1.slice(1,3) // ["Java", "Go"]

  slice()方法的一個重要應用，是將類似數組的對象轉為真正的數組

• var obj = {
        "0": 'a',
        "1": 'b',
        "2": 'c',
        length: 3
      }
      var n = Array.prototype.slice.call(obj) // ["a", "b", "c"]