數組API（1）

棧要領 (後進先出)

在棧的頂部舉行插進去和移除操縱，運用
push 和
pop 要領連繫（會修正原始數組）

• 在數組末端插進去(push能夠增加多項) push

  var arr=[1,2,3];
  var m=arr.push('m');
  console.log(m);  // 4 ，插進去末端，並返回修正後數組的長度
  console.log(arr); // [1, 2, 3, "m"]

• 移除末了一項 pop

  var arr=[1,2,3];
  var n=arr.pop();
  console.log(n);  // 3 移除末了一項，並返回這一項
  console.log(arr); // [1, 2]

行列要領 (先進先出)

運用
shift 要領(移除數組第一個項並返回該項，用時數組長度減1)連繫
push ，就能夠像操縱行列一樣操縱數組（會修正原始數組）

• 移除數組第一個項並返回該項 shift

  var arr=[1,2,3];
  var s=arr.shift();
  console.log(s);  // 1 移除第一項，並返回這一項
  console.log(arr); // [2, 3]

• 在數組前端增加恣意個項並返回新數組的長度 unshift,運用 unshift 和 pop能夠從相反的方一直模仿行列

  var arr=[1,2,3];
  var l=arr.unshift(4,5);
  console.log(l);  // 5 向數組前端增加兩項，並返回修正後的數組長度
  console.log(arr); // [4, 5, 1, 2, 3]

重排序要領 （會修正原始數組）

• reverse

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

• sort

  var arr=[1,8,10,22,31,3];
  arr.sort();
  console.log(arr); // [1, 10, 22, 3, 31, 8]

  sort並沒有像我們預期的舉行排序，
  sort 排序時，會挪用數組每一項的
  toString() 要領，縱然數組的一切項都是数字，也是轉換成字符串舉行比較的，平常
  sort 要領會吸收一個比較函數，以便我們舉行排序。

  var arr = [1, 8, 10, 22, 31, 3];
  
  function compare(v1, v2) {
    if (v1 < v2) {
      return -1;
    } else if (v1 > v2) {
      return 1;
    } else {
      return 0;
    }
  }
  arr.sort(compare);
  console.log(arr); // [1, 3, 8, 10, 22, 31]
  // 比較函數還能夠如許寫
  function compare(v1, v2) {
    return v1 - v2;
  }

reverse 和
sort 的返回值是經由排序后的數組;

操縱要領

• concat 基於當前數組的一切項建立一個新數組 (不會修正原數組)

  var arr = ['a', 'b', 'c']
  // 當增加空數組時
  var arr1 = arr.concat([]);
  var arr2 = arr.concat();
  // 增加一般項
  var arr3 = arr.concat('');
  var arr4 = arr.concat(null, undefined);
  var arr5 = arr.concat('d');
  // 增加數組
  var arr6 = arr.concat(['d', 'e', 'f']);
  // 增加一般項和數組
  var arr7 = arr.concat('m', 'n', ',', ['d', 'e', 'f']);
  // 增加子項為數組的數組
  var arr8 = arr.concat(['d', 'e', 'f', ['x', 'y']]);
  // 增加兩個數組
  var arr9 = arr.concat(['m', 'n', ','], ['d', 'e', 'f']);
  console.log(arr)  // ["a", "b", "c"]
  console.log(arr1) // ["a", "b", "c"]
  console.log(arr2) // ["a", "b", "c"]
  console.log(arr3) // ["a", "b", "c", ""]
  console.log(arr4) // ["a", "b", "c", null, undefined]
  console.log(arr5) // ["a", "b", "c", "d"]
  console.log(arr6) // ["a", "b", "c", "d", "e", "f"]
  console.log(arr7) // ["a", "b", "c", "m", "n", ",", "d", "e", "f"]
  console.log(arr8) // ["a", "b", "c", "d", "e", "f", Array(2)]
  console.log(arr9) // ["a", "b", "c", "m", "n", ",", "d", "e", "f"]

• slice 基於當前數組中的一或多個項建立一個新數組，返回值是新數組(會修正原數組)

  • 刪除 須要兩個參數，肇端位置和要刪除的項數

    // 從第三項最先，刪除0項
    var arr = ['a', 'b', 'c', '1', '2', 's']
    var arr1 = arr.splice(3, 0)
    console.log(arr); // ['a', 'b', 'c', '1', '2', 's']
    console.log(arr1); // []
    // 從第三項最先，刪除2項
    var arr = ['a', 'b', 'c', '1', '2', 's']
    var arr2 = arr.splice(3, 2)
    console.log(arr); // ["a", "b", "c", "s"]
    console.log(arr2); //  ["1", "2"]
    // 肇端值大於數組長度
    var arr = ['a', 'b', 'c', '1', '2', 's']
    var arr3 = arr.splice(7, 1)
    console.log(arr);
    console.log(arr3);
    // 為負數的狀況 從倒數項最先盤算
    var arr = ['a', 'b', 'c', '1', '2', 's']
    var arr4 = arr.splice(-2, 2)
    console.log(arr); // ["a", "b", "c", "1"]
    console.log(arr4); // ["2", "s"]
    // 項數為負，返回為空
    var arr = ['a', 'b', 'c', '1', '2', 's']
    var arr5 = arr.splice(2,-2)
    console.log(arr); // ["a", "b", "c", "1", "2", "s"]
    console.log(arr5);// []

  • 插進去 須要三個參數，肇端位置、要刪除的項數(0)和要插進去的項

    // 不刪除，插進去
    var arr = ['a', 'b', 'c', '1', '2', 's']
    var arr2 = arr.splice(2,0,'x')
    console.log(arr); //["a", "b", "x", "c", "1", "2", "s"]
    console.log(arr2); // []

  • 替代 須要三個參數，肇端位置、要刪除的項數(0)和要插進去的項

    // 刪除並插進去
    var arr = ['a', 'b', 'c', '1', '2', 's']
    var arr1 = arr.splice(2,2,'x')
    console.log(arr); // ["a", "b", "x", "2", "s"]
    console.log(arr1); //  ["c", "1"]
    // 插進去數組
    var arr = ['a', 'b', 'c', '1', '2', 's']
    var arr3 = arr.splice(2, 0, 'x', [1, 2, 3])
    console.log(arr); // ["a", "b", "x", Array(3), "c", "1", "2", "s"]
    console.log(arr3); // []

位置要領 (不會修正原數組)

參數 要查找的項和肇端位置(可選)，查找的項用
=== 操縱，必需完整相稱，查找到，返回位置下標，未找到，返回
-1

• indexOf 從數組最先位置向後查找
• lastIndexOf 從數組末端向前查找

迭代要領 (不會修正原數組)

參數 兩個參數，要在每一項上運轉的函數和運轉該函數的作用域對象(可選)——影響
this 的值；

• some 對數組中的每一項運轉給定函數，假如任一項都返回 true,則返回 true;
• every 對數組中的每一項運轉給定函數，假如每一項都返回 true,則返回 true;

• filter 對數組中的每一項運轉給定函數，返回該函數返回值為 true 的項所構成的數組;

  var arr = [-1, 22, 4, -2, 19, 0]
  var result = arr.filter(function(ele, index, arr) {
    return (ele > 0)
  })
  console.log(arr); // [-1, 22, 4, -2, 19, 0]
  console.log(result); // [22, 4, 19]

• forEach 對數組中的每一項運轉給定函數，該要領沒有返回值;

• map 對數組中的每一項運轉給定函數，返回該函數每次挪用效果構成的數組;(假如map函數中沒有 return ，則返回一個長度即是元素組的值為 undefined 的數組)

  var arr = [-1, 22, 4, -2, 19, 0]
  var result = arr.map(function(ele, index, arr) {
    return (ele * 2)
  })
  console.log(arr); // [-1, 22, 4, -2, 19, 0]
  console.log(result); // [-2, 44, 8, -4, 38, 0]

合併要領(ES5新增)

兩個要領都邑迭代數組一切項，然後構建一個終究返回的值。(不會修正原數組)

參數:在每一項上挪用的函數和作為合併基本的初始值(可選的)。改函數吸收4個參數：前一個值、當前值、項的索引和數組對象。

• reduce 從數組第一項最先，逐一遍歷到末了

• reduceRight 從數組末了一項最先，逐一遍歷到末了

  // 一個數組自動乞降要領
  var arr = [1, 2, 3, 4, 5]
  var result = arr.reduce(function(pre, cur, index, arr) {
    return pre + cur
  }, 0)
  console.log(arr); //[1, 2, 3, 4, 5]
  console.log(result); //15

  // 盤算一個數組中，統一個字符湧現的次數(固然for輪迴也很輕易完成)
  var arr = ['A','B', 'C', 'A', 'D', 'C', 'B', 'E', 'C', 'D']
  var result = arr.reduce(function(pre, cur, index) {
    pre[cur] = pre[cur] ? ++pre[cur] : 1;
    return pre;
  }, {})
  console.log(result); // {A: 2, B: 2, C: 3, D: 2, E: 1}