創(chuàng)建數(shù)組

1. 通過一個數(shù)字參數(shù)，創(chuàng)建指定長度的數(shù)組

var arr = new Array(2);
// arr = [undefined, undefined]

1. 通過一個非數(shù)字參數(shù) 或 多個參數(shù)創(chuàng)建一個擁有元素的數(shù)組

var arr1 = new Array('1');
var arr2 = new Array(1, 'b');
// arr1 = ['1']
// arr2 = [1, 'b']

1. 通過直接量創(chuàng)建數(shù)組

var arr = [1, 'b'];

數(shù)組元素的簡單修改

1. 指定數(shù)組某個位置的元素（有則修改，無則添加）

var arr = [];
arr[1] = ['b'];// arr = [undefined, 'b']
arr[0] = ['a'];// arr = ['a', 'b'] 

1. push 向數(shù)組后面添加一個元素

var arr = [0];
var arrLength = arr.push(1);
// arrLength = 2; arr = [0, 1]

1. unshift 向數(shù)組前面插入一個元素

var arr = ['b'];
var arrLength = arr.unshift('a');
// arrLength = 2; arr = ['a', 'b'];

數(shù)組元素的刪除

1. delete 偽刪除（數(shù)組length不變）

var arr1 = arr2 = [0, 1];
delete arr1[0];
arr2[0] = undefined;
// arr1.toString() == arr2.toString()
// arr1.length == arr2.length

1. length 賦值刪除

var arr = [0, 1, 2];
arr.length = 1;// arr = [0]

1. pop 刪除數(shù)組的第一個元素

var arr = [0, 1];
var firstItem = arr.pop();
// arr = [1]; firstItem = 0;

1. shift 刪除數(shù)組的最后一個元素

var arr = [0, 1];
var lastItem = arr.shift();
// arr = [0]; lastItem = 1;

splice 實現(xiàn)數(shù)組的復雜修改

array.splice(start, deleteCount[, item1[, item2[, ...]]])
返回由被刪除元素組成的數(shù)組

• start
  修改數(shù)組的開始位置

• deleteCount
  要移除數(shù)組元素的個數(shù)，可選，不指定則從start刪除至數(shù)組末尾

• itemN
  要添加進數(shù)組的元素，可選，不指定則只刪除數(shù)組元素

1. 刪除元素

var arr1 = arr2 = [0, 1, 2, 3];
arr1.splice(2);// arr1 = [0, 1]
arr2.length = 2;// arr2 = [0, 1]
arr1.splice(0, 1);// arr1 = [1];

1. 向指定位置前插入元素，即從指定位置開始 刪除0個元素 并插入元素

var arr = [0, 1];
arr.splice(1, 0, 2, 'b');// [0,2,'b',1]

1. 替換元素,即從指定位置開始 刪除一些元素 并插入元素

var arr = [0, 1, 2];
arr.splice(1, 1, 'b');// arr = [0, 'b', 2]

slice 提取數(shù)組元素

arr.slice([begin[, end]])

• begin
  從該索引處開始提取原數(shù)組中的元素，負數(shù)則表示從原數(shù)組中的倒數(shù)第幾個元素開始提取。

• end
  從該索引處結束提取原數(shù)組中的元素，負數(shù)則表示在原數(shù)組中的倒數(shù)第幾個元素結束提取。如果end被省略，則slice會一直提取到原數(shù)組末尾。

1. 數(shù)組的簡單復制

var arr = [1, 2, 3];
var arr2 = arr.slice();
// arguments像數(shù)組又不是數(shù)組
// 我們可以通過slice將它轉換成數(shù)組
function fn() {
      var arr = [].slice.call(arguments);
}

1. 元素提取

var arr = [0, 1, 2, 3];
arr.slice(0, 1);// [0]
arr.slice(-2);// [2, 3]
arr.slice(-2, -1);// [2]

1. 快速獲取最后一個元素

Array.prototype.last = function() {
      return this.slice(-1)[0];
}

concat 合并數(shù)組

var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])
cancat 方法把所有參數(shù)中的 數(shù)組類型的參數(shù)中的元素 以及 非數(shù)組類型的參數(shù)本身 按順序拼接到原數(shù)組后 并返回拼接后的新數(shù)組。

var arr = [0].concat(1, [2, 3]);
// arr = [0, 1, 2, 3]

slice，concat 實現(xiàn)對數(shù)組的“ 無損修改”

有時候我們不想修改原數(shù)組，而是想在不影響原數(shù)組的基礎上，通過對數(shù)組元素的操作與組織，產生一個新數(shù)組。拋磚引玉：

// 根據(jù)索引值移除數(shù)組成員
Array.prototype.removeAt = function(i) {
    return this.slice(0, i).concat(this.slice(i + 1));
}
// 移除數(shù)組成員
Array.prototype.remove = function(item) {
    var index = this.indexOf(item);
    return this.removeAt(index);
}
// 根據(jù)索引值替換元素
Array.prototype.replaceAt = function(i, item) {
    return this.slice(0, i)
        .concat(item, this.slice(i + 1));
}
// 替換元素
Array.prototype.replace = function(item, newItem) {
    var index = this.indexOf(item);
    return this.replaceAt(index, newItem);
}
// 插入元素
Array.prototype.insertAt = function(i, item) {
    return this.slice(0, i)
        .concat(item, this.slice(i));
}
// 最后一個成員
Array.prototype.last = function() {
    return this.slice(-1)[0];
}

some，every 測試數(shù)組元素

1. some 判斷有沒有滿足條件的元素

[1, 2, 3].some((item, index) => {
    console.log(index);
    // 返回 true 時中止
    return item < 2;
});
// true
// 循環(huán)執(zhí)行1次

1. every 判斷是不是所有元素都滿足條件

[1, 2, 3].every((item, index) => {
    console.log(index);
    // 返回 false 時中止
    return item < 2;
});
// false;
// 循環(huán)執(zhí)行兩次

filter 篩選數(shù)組元素

[1, 2, 3].filter((item, index) => item < 3);
// [1, 2]
// 不影響原數(shù)組

map 對數(shù)組元素做計算得到新數(shù)組

[0, 1, 2].map((item, index) => String.fromCharCode(+item + 65));
// ['A', 'B', 'C']
// 不影響原數(shù)組

reduce 累加數(shù)組元素

1. prev從第一個起，cur從第二個起，index從1起

[1, 2, 3].reduce((prev, cur, index, array) => prev + cur);
// 6

2. 帶初始值的reduce，prev從初始值開始，cur從第一個值開始，index從0開始

[1, 2, 3].reduce((prev, cur, index, array) => prev + cur, 4);
// 10