array.concat(item…)

concat 方法产生了一个新数组，它包含一份 array 的浅复制，并把一个或多个参数 item 附加在其后。如果参数 item 是一个数组，那么它的每个元素会被分别添加。

var a = ['a', 'b', 'c'];
var b = [1, 2, 3];
var c = a.concat(b, 'another'）;
console.log(c); // ['a', 'b', 'c', 1, 2, 3, 'another']

array.join(separator)

join 方法把一个 array 构造成一个字符串。它先把 array 中的每个元素构造成一个字符串，接着用一个 separator 分隔符把它们连接在一起。默认的 separator 是逗号’,’。要想做到无缝连接可以用空字符串’’作为 separator 。

1
2
3

var a = ['a', 'b', 'c'];
var b = a.join(''）;
console.log(b); // 'abcd'

array.push(item…)

push 方法把一个或多个参数 item 附加到一个数组的尾部。和 cacat 方法不同的是，它会修改 array ，如果参数 item 是一个数组，它会把参数数组作为单个元素整个添加到数组中，并返回这个 array 的新长度值。

var a = ['a', 'b', 'c'];
var b = [1, 2, 3];
var c = a.push(b, 'another'）;
console.log(a); // ['a', 'b', 'c', [1, 2, 3], 'another']
console.log(c); // 5

array.pop()

pop 和 push 方法使得数组 array 可以像堆栈（stack）一样工作。 pop 方法移除 array 中的最后一个元素并返回该元素。如果 array 是空数组，会返回 undefined 。

var a = ['a', 'b', 'c'];
var b = a.pop(）;
console.log(a); // ['a', 'b']
console.log(b); // 'c'

array.unshift(item…)

unshift 方法像 push 方法一样，用于把元素添加到数组中，不同的是 unshift 是把 item 插入到 array 的开始部分。返回 array 的新长度值。

var a = ['a', 'b', 'c'];
var b = [1, 2, 3];
var c = a.unshift(b, 'another'）;
console.log(a); // [[1, 2, 3], 'another', 'a', 'b', 'c']
console.log(c); // 5

array.shift()

shift 方法删除数组 array 的第 1 个元素并返回该元素。如果这个数组是空的，返回 undefined 。

var a = ['a', 'b', 'c'];
var b = a.shift(）;
console.log(a); // ['b', 'c']
console.log(b); // 'a'

array.reverse()

reverse 方法反转 array 里的元素的顺序，并返回 array 本身。

var a = ['a', 'b', 'c'];
var b = a.reverse(）;
console.log(a); // ['c', 'b', 'a']
console.log(b); // ['c', 'b', 'a']

array.slice(start, end)

slice 方法对 array 中的一段做浅复制。首先复制 array[start] ，一直复制到 array[end] 为止（不包含array[end]，可以理解为返回 [array[start], array[end]) ）。end 参数是可选的，默认值是该数组的长度 array.length。如果两个参数的任何一个为负数， array.length 会和它们相加，试图让它们变成非负数。如果start 大于等于 array.length ，得到的结果将是一个新的空数组。

var a = ['a', 'b', 'c'];
var b = a.slice(0, 1); // ['a']
var c = a.slice(1);    // ['b', 'c']
var d = a.slice(1, 2); // ['b']

array.splice(start, deleteCount, item…)

splice 方法从 array 中移除一个或多个元素，并用新的 item 替换它们。参数 start 是从数组 array 中移除元素的开始位置。参数 deleteCount 是要移除元素的个数。如果有额外的参数，那些 item 会插入到被移除元素的位置上。它会返回一个包含被移除元素的数组。

var a = ['a', 'b', 'c'];
var b = a.splice(1, 1, 'x', 'y');
console.log(a); // ['a', 'x', 'y', 'c']
console.log(b); // ['b']

array.sort(compareFn)

sort 方法是对 array 中的内容进行排序，它不能正确地给一组数字排序：

1
2
3

var n = [4, 54, 12, 15, 21];
n.sort();
console.log(n); // [12, 15, 21, 4, 54]

JavaScript 的默认比较函数把要被排序的元素都视为字符串。它尚未足够只能到在比较这些元素之前先检测它们的类型，所以当它比较这些数字的时候，会把它们转化为字符串，于是得到一个错的离谱的结果。
我们可以使用自己的比较函数来替换默认的比较函数。我们的比较函数应该接收两个从那沪深，并且如果这两个参数相等则返回 0 ，如果第 1 个参数应该排列在前面，则返回一个负数，如果第二个参数应该排列在前面，则返回一个正数。

n.sort(function (a, b) {
  return a - b;
});
console.log(n); // [4, 12, 15, 21, 54]

上面这个函数可以使数字正确排序，但它不能使字符串排序。如果我们想要给任何包含简单值的数组排序，必须要做更多工作：

var m = ['aa', 'bb', 'a', 4, 8, 15, 16, 23, 42];
m.sort(funciton (a. b) {
  if (a === b) {
    return 0;
  }
  if (typeof a === typeof b) {
    return a < b ? -1 : 1;
  }
  return typeof a < typeof b ? -1 : 1;
});
console.log(m); // [4, 8, 15, 16, 23, 42, 'a', 'aa', 'bb']

sort 方法是不稳定的，关于 sort 方法的实现，在 V8 引擎中是小于 10 个元素时，采用插入排序，大于 10 个元素时采用快速排序。其他浏览器有用归并排序（Firefox）或选择排序的。