参数：compareFunction
可选。用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序。

如果指明了compareFunction，那么数组会按照调用该函数的返回值排序。即 a 和 b 是两个将要被比较的元素：

比较函数格式如下（字符串与数组都可以比较）:

function compare(a, b) {
 if (a < b ) { // 按某种排序标准进行比较, a 小于 b
 return -1;
 }
 if (a > b ) {
 return 1;
 }
 // a must be equal to b
 return 0;
}

3. Array.prototype.unshift()

var arr = [1, 2];
arr.unshift(-2, -1); // = 5
// arr is [-2, -1, 1, 2]

4. Array.prototype.concat()

返回新的数组（浅拷贝），不会影响原数组。

var num1 = [1, 2, 3],
 num2 = [4, 5, 6],
 num3 = [7, 8, 9];

var nums = num1.concat(num2, num3);

console.log(nums); 
// results in [1, 2, 3, 4, 5, 6, 7, 8, 9];

var alpha = ['a', 'b', 'c'];

var alphaNumeric = alpha.concat(1, [2, 3]);

console.log(alphaNumeric); 
// results in ['a', 'b', 'c', 1, 2, 3]

5. Array.prototype.forEach()

array.forEach(callback(currentValue, index, array){
 //do something
}, thisArg)

array.forEach(callback[, thisArg])

其中：thisArg为可选参数，当执行回调 函数时用作this的值（参考对象）。

下列函数也有thisArg这个可选参数，用法与Array.prototype.forEach()一致：

6. Array.prototype.map()

使用技巧案例

// 下面的语句返回什么呢:
["1", "2", "3"].map(parseInt);
// 你可能觉的会是[1, 2, 3]
// 但实际的结果是 [1, NaN, NaN]

// 通常使用parseInt时,只需要传递一个参数.
// 但实际上,parseInt可以有两个参数.第二个参数是进制数.
// 可以通过语句"alert(parseInt.length)===2"来验证.
// map方法在调用callback函数时,会给它传递三个参数:当前正在遍历的元素, 
// 元素索引, 原数组本身.
// 第三个参数parseInt会忽视, 但第二个参数不会,也就是说,
// parseInt把传过来的索引值当成进制数来使用.从而返回了NaN.

function returnInt(element) {
 return parseInt(element, 10);
}

['1', '2', '3'].map(returnInt); // [1, 2, 3]
// 意料之中的结果

// 也可以使用简单的箭头函数，结果同上
['1', '2', '3'].map( str => parseInt(str) );

// 一个更简单的方式:
['1', '2', '3'].map(Number); // [1, 2, 3]
// 与`parseInt` 不同，下面的结果会返回浮点数或指数:
['1.1', '2.2e2', '3e300'].map(Number); // [1.1, 220, 3e+300]

7.Array.prototype.reduce()

Array.prototype.reduceRight()是与其用法类似，是从右向左遍历。

参数：

reduce如何运行

[0, 1, 2, 3, 4].reduce(function(accumulator, currentValue, currentIndex, array){
 return accumulator + currentValue;
}, 10);

// 20

实例：将二维数组转化为一维

var flattened = [[0, 1], [2, 3], [4, 5]].reduce(
 function(a, b) {
 return a.concat(b);
 },
 []
);
// flattened is [0, 1, 2, 3, 4, 5]

实例：使用扩展运算符和initialValue绑定包含在对象数组中的数组

// friends - an array of objects 
// where object field "books" - list of favorite books 
var friends = [{
 name: 'Anna',
 books: ['Bible', 'Harry Potter'],
 age: 21
}, {
 name: 'Bob',
 books: ['War and peace', 'Romeo and Juliet'],
 age: 26
}, {
 name: 'Alice',
 books: ['The Lord of the Rings', 'The Shining'],
 age: 18
}];

// allbooks - list which will contain all friends' books + 
// additional list contained in initialValue
var allbooks = friends.reduce(function(prev, curr) {
 return [...prev, ...curr.books];
}, ['Alphabet']);

// allbooks = [
// 'Alphabet', 'Bible', 'Harry Potter', 'War and peace', 
// 'Romeo and Juliet', 'The Lord of the Rings',
// 'The Shining'
// ]

实例：数组去重

let arr = [1,2,1,2,3,5,4,5,3,4,4,4,4];
let result = arr.sort().reduce((init, current)=>{
 if(init.length===0 || init[init.length-1]!==current){
 init.push(current);
 }
 return init;
}, []);
console.log(result); //[1,2,3,4,5]