011-js常用数组方法

1.创建数组

js中创建数组有两种方式：

• 使用Array构造函数

var name = new Array(2);  // 创建一个length为2的数组
var name = new Array(['James', 'Jack']);  // 创建了包含两个字符串的数组

• 使用数组字面量

var name = ['James', 'Jack'];  // // 创建了包含两个字符串的数组

2.检测数组

• instanceof

var name = ['James', 'Jack'];
console.log(name instanceof Array);  // true

• Array.isArray()

var name = ['James', 'Jack'];
console.log(Array.isArray(name));  // true

3.转换方法

• toString()

调用数组的toString()方法会返回由数组中每个值的字符串形式拼接而成的一个以逗号分隔的字符串

var name = ['James', 'Jack'];
console.log(name.toString());  // 'James,Jack'

• valueOf()

valueOf()返回的是原数组

var name = ['James', 'Jack'];
console.log(name.valueOf());  // [ 'James', 'Jack' ]

• join()

使用join()方法可以将数组转换为字符串。在给后端传值的时候，经常遇到将数组转成字符串传递过去，这方法就派上用场了。

var name = ['James', 'Jack'];
console.log(name.join());  // James,Jack
console.log(name.join('|'));  // James|Jack

4.栈方法

栈是一种LIFO(Last-In-First-Out，后进先出)的数据结构（后续会有博客描述此种数据结构），也就是最新添加的最早被移除。数组中就有push()和pop()方法就可以实现类似于栈的这种行为。

• push()

push()方法可以接收任意数量的参数，把它们逐个添加到数组末尾，并返回修改后数组的长度。

var name = ['James', 'Jack'];
console.log(name.push('Jerry'));  // 3
console.log(name);  // [ 'James', 'Jack', 'Jerry' ]

• pop()

pop()方法从数组末尾移除最后一项，减少数组的length值，然后返回移除的项。

var name = ['James', 'Jack', 'Jerry'];
console.log(name.pop());  // 'Jerry'
console.log(name);  // [ 'James', 'Jack' ]

5.队列方法

队列是一种FIFO(First In First Out,先进先出)的数据结构（后续会有博客描述此种数据结构）。队列在末端添加项，从列表的前端移除。使用push方法添加，再使用shift()方法移除，就实现了类似队列的数据结构了。

• shift()

var name = ['James'];
name.push('Jack');
name.push('Jerry');
console.log(name.shift());  // 'James'
console.log(name);  // [ 'Jack', 'Jerry' ]

我们看到最先加入数组的最先被移除。

• unshift()

与shift相对应的方法就是unshift()方法了，它在数组的前端添加任意个项并返回数组的新长度。因此使用unshif()和pop()方法组合也能模式实现队列。在数组的前端添加，在数组的末端移除。

var name = ['James'];
name.unshift('Jack');
name.unshift('Jerry');
console.log(name.pop());  // 'James'
console.log(name);  // [ 'Jerry', 'Jack' ]

6.排序方法

• reverse()

reverse()方法就是倒序数组

var values = [1,2,3,4,5,6];
values.reverse();
console.log(values);  // [ 6, 5, 4, 3, 2, 1 ]

• sort()

默认情况下sort()方法按照升序的方式排列数组，即最小的放在最前面，最大的放在之后面

var values = [1, 11, 21, 10, 15, 66];
values.sort();
console.log(values);  // [ 1, 10, 11, 15, 21, 66 ]

但是我们发现排序结果与我们想象的不一致，因为sort()方法会调用数组项的toString()方法，然后比较字符串，所以sort()方法比较的是字符串，而不是数字。所以就有了下面这种方式来改进sort()方法。

var values = [1, 11, 21, 10, 15, 66];

function compare(value1, value2) {
    if(value1 > value2) {
        return 1;
    } else if(value1 < value2) {
        return -1;
    } else {
        return 0;
    }
}

values.sort(compare);
console.log(values)  // [ 1, 10, 11, 15, 21, 66 ]

如要要实现降序，把return 1和return -1调换位置即可。

7.操作方法

• concat()

concat()方法可以基于当前数组中所有项创建一个新数组。这个方法会先创建一当前数组的一个副本，然后将接收到的参数添加到这个副本的末尾，最后返回新构建的数组。如果concat方法没有传参，返回当前数组，如果传入一个或者多个数组，则将参数中数组每一项都添加到该数组中，如果传递的不是数组，则这些值被简单的添加到该数组的末尾。

var name1 = ['James', 'Jack'];
var name2 = name1.concat(['Jerry'], ['Green', 'Harris']);
var name3 = name1.concat();
var name4 = name1.concat('Antony');
console.log(name1);  // [ 'James', 'Jack' ]
console.log(name2);  // [ 'James', 'Jack', 'Jerry', 'Green', 'Harris' ]
console.log(name3);  // [ 'James', 'Jack' ]
console.log(name4);  // [ 'James', 'Jack', 'Antony' ]

• slice()

slice()方法基于当前数组中的一个或者对个项创建一个新数组。slice()方法接收一个活两个参数。在只有一个参数的情况下，slice()方法返回从该参数指定位置到当前数组末尾的所有项，如果是两个参数，该方法返回起始和结束位置之前的项但不包括结束位置的项。注意：```slice()方法不会影响原数组。

var name1 = [ 'James', 'Jack', 'Jerry', 'Green', 'Harris' ];
var name2 = name1.slice(2);
var name3 = name1.slice(1,3);
console.log(name1);  // [ 'James', 'Jack', 'Jerry', 'Green', 'Harris' ]
console.log(name2);  // [ 'Jerry', 'Green', 'Harris' ]
console.log(name3);  // [ 'Jack', 'Jerry' ]

• splice()

splice()方法会返回一个数组，该数组中包含从原始数组中删除的项（如果没有删除，就返回空数组），原数组变为改变后的数组。

splice()方法有3中使用方式：

1. 删除：指定2个参数，要删除的第一项的位置和要删除的项数。

var name1 = [ 'James', 'Jack', 'Jerry'];
var name2 = name1.splice(0,2);
console.log(name1);  // [ 'Jerry' ]
console.log(name2);  // [ 'James', 'Jack' ]

2. 插入：指定3个参数或3个以上参数。起始位置、0（要删除的项数）和要插入的项。如果要插入多个项，可以再传入第四、第五…多个项。

var name1 = [ 'James', 'Jack', 'Jerry'];
var name2 = name1.splice(1, 0, 'Green', 'Harris');
console.log(name1);  // [ 'James', 'Green', 'Harris', 'Jack', 'Jerry' ]
console.log(name2);  // []

3. 替换：指定3个参数或3个以上参数。起始位置、要删除的项数和要插入的任意数量的项。

var name1 = [ 'James', 'Jack', 'Jerry']; 
var name2 = name1.splice(1, 2, 'Green', 'Harris');
console.log(name1);  // [ 'James', 'Green', 'Harris' ]
console.log(name2);  // [ 'Jack', 'Jerry' ]

8.位置方法

位置方法有两个：indexOf()和lastIndexOf()，这两个方法都接收两个参数，要查找的项（可选）和表示查到起点位置的索引。indexOf()是从前往后查找，lastIndexOf()是从后往前查找。这连个方法都返回要查找的项在数组中的位置，如果没有查到，就返回-1。

var numbers = [2, 6, 8, 34, 75, 28];
console.log(numbers.indexOf(8));  // 2
console.log(numbers.indexOf(3));  // -1
console.log(numbers.indexOf(8, 1));  // 2
console.log(numbers.indexOf(8,4));  // -1

console.log(numbers.lastIndexOf(8));  // 2
console.log(numbers.lastIndexOf(3));  // -1
console.log(numbers.lastIndexOf(8, 1));  // -1
console.log(numbers.lastIndexOf(8,4));  // 2

9.迭代方法

• every()

  对数组中的每一项运行给定函数，如果该函数对每一项都返回true，则返回true

var numbers = [1,3,5,2,4,5,6,7,5];

var everyResult1 = numbers.every(function(item, index) {
    return item > 3;
})
console.log(everyResult1);  // false

var everyResult2 = numbers.every(function(item, index) {
    return item > 0;
})
console.log(everyResult2);  // true

• filter()

  对数组中的每一项运行给定函数，返回该函数会返回true的项组成的数组

var numbers = [1,3,5,2,4,5,6,7,5];

var filterResult = numbers.filter(function(item, index) {
    return item > 5;
})

console.log(filterResult)  // [ 6, 7 ]

• forEach()

  对数组中的每一项运行给定函数，这个方法没有返回值

var numbers = [1,3,5,2,4,5,6,7,5];
	numbers.forEach(function(item, index) {
	console.log(item);
})

• map()

  对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组

var numbers = [1,3,5,2,4,5,6,7,5];
var mapResult = numbers.map(function(item, index) {
	return item * 2;
})
	
console.log(mapResult);  // [ 2, 6, 10, 4, 8, 10, 12, 14, 10 ]

• some()

  对数组中的每一项运行给定函数，如果该函数对任一项返回true，则返回true

var numbers = [1,3,5,2,4,5,6,7,5];
var someResult = numbers.some(function(item, index) {
    return item > 5;
})

console.log(someResult);  // true

10.归并方法

reduce()和reduceRight()两个方法都会迭代数组的所有项，然后构建一个最终返回的值。reduce()方法从数组的第一项开始，逐个遍历到最后，而reduceRight()方法从数组的最后一项开始，向前遍历到第一项。

这两个方法都接收两个参数：一个在每一项上调用的函数和（可选的）作为归并基础的初始值。传给reduce()和reduceRight()的函数接收4个参数：前一个值、当前值、项的索引和数组对象。这个函数返回的任何值都会作为第一个参数自动传给下一项。第一次迭代发生在数组的第二项上，因此第 一个参数是数组的第一项，第二个参数就是数组的第二项。

var number = [1, 2, 3, 4, 5, 6];

var numberResult = number.reduce(function(prev, cur, index, array) {
    return prev + cur;
})

console.log(numberResult);  // 21

参考：《JavaScript高级程序设计》