数组的操作方法简介

一、排序方法

reverse()：倒序

改变数组本身，返回值也是改变后的数组

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

sort()：重排序

改变数组本身，返回值也是改变后的数组

• 默认情况下按升序排列，会对数组中每项调用 toString() 转型后将字符串对比(就算数组中是数字，对比的也是字符串)

var b = [0, 1, 5, 10, 15];
b.sort();
console.info(b);       // [0, 1, 10, 15, 5]

• 可接收一个比较函数，两两比较，以便指定哪个值位于哪个值前面
  比较函数，返回负数，则正序，返回正数则倒序；

function compare(value1, value2) {
    if (value1<value2) {
        return -1;
    } else if(value>value2) {
        return 1;
    } else {
        return 0;
    }
}
var b = [0, 1, 10, 5, 15];
b.sort(compare);          // [0, 1, 5, 10, 15]

• 可简化比较函数

function compare(value1, value2) {
    return value1 - value2;
}
var b = [0, 1, 10, 5, 15];
b.sort(compare);          // [0, 1, 5, 10, 15]

二、操作方法

concat()：数组合并

不会改变原来的数组，返回合并好的新数组
参数：拼接在后面的数组

var a = [1, 2, 3, 4, 5];
var b = ['a', 'b', 'c', 'd', 'e'];
var c = a.concat(b);        // a 后面拼接 b
console.info(a);            // [1, 2, 3, 4, 5]
console.info(b);            // ["a", "b", "c", "d", "e"]
console.info(c);            // [1, 2, 3, 4, 5, "a", "b", "c", "d", "e"]

缺点：占用双倍内存；

slice()：截取数组

不会改变原来数组，返回截取的项组成的数组
参数：
1、返回项的起始索引（包含）
2、返回项的结束索引（不包含）（可选，若无则截取到最后）

var c = [1, 2, 3, 4, 5, "a", "b", "c", "d", "e"];
var d = c.slice(1, 5);
console.info(c);            // [1, 2, 3, 4, 5, "a", "b", "c", "d", "e"]
console.info(d);            // [2, 3, 4, 5]

• 如果参数是负数则用数组长度加上参数来确定位置；
• 如果结束位置小于起始位置，返回空数组；

splice()：增删改查

改变原来数组，返回被删除项组成的数组
参数：
1、操作起始位置的索引（包含）
2、删除的项数（从起始位置往后删）
3、后面的所有参数都是插入的项（插入项的第一项位置就是起始位置索引）

删除：

var num = [1, 2, 3, 4, 5];
var removed = num.splice(1, 1);                 // 从位置 1 开始删除一项
console.info(num);                              // [1, 3, 4, 5]
console.info(removed);                          // [2]

插入：

var num = [1, 2, 3, 4, 5];
var removed = num.splice(1, 0, 3);              // 从位置 1 开始删除一项
console.info(num);                              // [1, 3, 2, 3, 4, 5]
console.info(removed);                          // []

替换：

var num = [1, 2, 3, 4, 5];
var removed = num.splice(1, 2, 5, 5, 5);
console.info(num);                  // [1, 5, 5, 5, 4, 5]
console.info(removed);              // [2, 3]

三、位置方法

indexOf() 和 lastIndexOf()：查询目标在数组中的位置

不改变原来数组，返回目标位置索引，若未查到，返回 -1
indexOf() 方法从数组开头向后查找，lastIndexOf() 方法从数组末尾向前查找
查找时会用全等操作符
参数：
1、查找目标（可为字符串或正则）
2、查找起始位置索引

var num = [1, 2, 3, 4, 5, 4, 3, 2, 1];
console.info(num.indexOf(4));                // 3
console.info(num.indexOf('4'));              // -1
console.info(num.lastIndexOf(4));            // 5
console.info(num.indexOf(4, 4));             // 5
console.info(num.lastIndexOf(4, 4));         // 3

四、迭代方法

every()：

对数组每一项使用回调函数，如果该函数对每一项都返回 true，才返回 true，否则返回 false
参数：
1、数组项的值
2、该项在数组中的索引
3、数组对象本身

var num = [1, 2, 3, 4, 5, 4, 3, 2, 1];
var everyResult = num.every(function(item, index, array) {
    return item > 2;
});
console.info(everyResult);              // false

some()：

对数组每一项使用回调函数，如果该函数对任意一项返回 true，就返回 true，否则返回 false
参数：
1、数组项的值
2、该项在数组中的索引
3、数组对象本身

var num = [1, 2, 3, 4, 5, 4, 3, 2, 1];
var someResult = num.some(function(item, index, array) {
    return item > 2;
});
console.info(someResult);              // true

filter()：

对数组每一项使用回调函数，返回该函数会返回 true 的项组成的数组

var num = [1, 2, 3, 4, 5, 4, 3, 2, 1];
var filterResult = num.filter(function(item, index, array) {
    return item > 2;
});
console.info(filterResult);           // [3, 4, 5, 4, 3]

map()：

对数组每一项使用回调函数，返回每次函数调用后返回的结果组成的数组

var num = [1, 2, 3, 4, 5, 4, 3, 2, 1];
var mapResult = num.map(function(item, index, array) {
    return item + 2;
});
console.info(mapResult);            // [3, 4, 5, 6, 7, 6, 5, 4, 3]

forEach()：

对数组每一项使用回调函数，这个方法没有返回值也不需要回调函数返回（不改变原来数组）

var num = [1, 2, 3, 4, 5, 4, 3, 2, 1];
var newNum = [];
var forEachResult = num.forEach(function(item, index, array) {
    newNum.push(item + 2);
});
console.info(num);                        // [1, 2, 3, 4, 5, 4, 3, 2, 1]
console.info(newNum);                     // [3, 4, 5, 6, 7, 6, 5, 4, 3]
console.info(forEachResult);              // undefined

五、归并方法

reduce() 和 reduceRight()

不改变数组本身，迭代数组的所有项，构建一个最终的返回值；
reduce() 方法从前往后逐个遍历
reduceRight() 方法从后往前逐个遍历
参数：
1、在每一项上调用的函数
2、作为并归基础的初始值（可选）
传入的函数参数：
1、前一个值（有初始值时从初始值开始）
2、当前值
3、项的索引
4、数组对象
传入函数的返回值会作为第一个参数传给下一次

/* 求所有值之和 */
var num = [1, 2, 3, 4, 5, 4, 3, 2, 1];
var sum = num.reduce(function(prev, cur, index, array) {
    return prev + cur;
});
console.info(num);              // [1, 2, 3, 4, 5, 4, 3, 2, 1]
console.info(sum);              // 25

/* 合并两个数组 */
var num = [1, 2, 3, 4, 5];
var str = ['a', 'b', 'c', 'd', 'e'];
var add = str.reduce(function(prev, cur, index, array) {
    prev.push(cur);
    return prev;
}, num);
console.info(add);              // [1, 2, 3, 4, 5, "a", "b", "c", "d", "e"]