JavaScript Array 常用方法

创建数组

1. 通过一个数字参数，创建指定长度的数组

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

1. 通过一个非数字参数 或 多个参数创建一个拥有元素的数组

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

1. 通过直接量创建数组

var arr = [1, 'b'];

数组元素的简单修改

1. 指定数组某个位置的元素（有则修改，无则添加）

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

1. push 向数组后面添加一个元素

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

1. unshift 向数组前面插入一个元素

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

数组元素的删除

1. delete 伪删除（数组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 删除数组的第一个元素

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

1. shift 删除数组的最后一个元素

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

splice 实现数组的复杂修改

array.splice(start, deleteCount[, item1[, item2[, ...]]])
返回由被删除元素组成的数组

• start
  修改数组的开始位置

• deleteCount
  要移除数组元素的个数，可选，不指定则从start删除至数组末尾

• itemN
  要添加进数组的元素，可选，不指定则只删除数组元素

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 提取数组元素

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

• begin
  从该索引处开始提取原数组中的元素，负数则表示从原数组中的倒数第几个元素开始提取。

• end
  从该索引处结束提取原数组中的元素，负数则表示在原数组中的倒数第几个元素结束提取。如果end被省略，则slice会一直提取到原数组末尾。

1. 数组的简单复制

var arr = [1, 2, 3];
var arr2 = arr.slice();
// arguments像数组又不是数组
// 我们可以通过slice将它转换成数组
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 合并数组

var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])
cancat 方法把所有参数中的 数组类型的参数中的元素 以及 非数组类型的参数本身 按顺序拼接到原数组后 并返回拼接后的新数组。

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

slice，concat 实现对数组的“ 无损修改”

有时候我们不想修改原数组，而是想在不影响原数组的基础上，通过对数组元素的操作与组织，产生一个新数组。抛砖引玉：

// 根据索引值移除数组成员
Array.prototype.removeAt = function(i) {
    return this.slice(0, i).concat(this.slice(i + 1));
}
// 移除数组成员
Array.prototype.remove = function(item) {
    var index = this.indexOf(item);
    return this.removeAt(index);
}
// 根据索引值替换元素
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 测试数组元素

1. some 判断有没有满足条件的元素

[1, 2, 3].some((item, index) => {
    console.log(index);
    // 返回 true 时中止
    return item < 2;
});
// true
// 循环执行1次

1. every 判断是不是所有元素都满足条件

[1, 2, 3].every((item, index) => {
    console.log(index);
    // 返回 false 时中止
    return item < 2;
});
// false;
// 循环执行两次

filter 筛选数组元素

[1, 2, 3].filter((item, index) => item < 3);
// [1, 2]
// 不影响原数组

map 对数组元素做计算得到新数组

[0, 1, 2].map((item, index) => String.fromCharCode(+item + 65));
// ['A', 'B', 'C']
// 不影响原数组

reduce 累加数组元素

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