JavaScript-JS数组方法有哪些

• join()
• reverse()
• sort()
• concat()
• slice()
• splice()
• push()和pop()
• unshift()和shift()
• toString和toLocaleString()
• forEach()
• map()
• filter()
• every和some()
• reduce()和reduceRight()

Array.join()

Array.join()方法将数组中所有元素都转化为字符串并连接在一起，返回最后生成的字符串。可以指定一个可选的字符串在生成的字符串中来分割数组的各个元素。如果不指定分隔符，默认使用逗号。如一下代码所示：

var a = [1, 2, 3];     // 创建一个包含三个元素的数组
a.join();              // => "1,2,3"
a.join(" ");           // => "1 2 3"
a.join("");            // => "123"
var b = new Array(10); // 长度为10的空数组
b.join('-');           // => "---------"：9个连字号组成的字符串

Array.join()方法是String.split()方法的逆向操作，后者是将字符串分割成若干块来创建一个数组。

Array.reverse()

Array.reverse()方法将数组中的元素颠倒顺序，返回逆序的数组。它采取了替换；换句话说，它不通过重新排列的元素创建新的数组，而是在原先的数组中重新排列它们。例如，下面的代码使用reverse()和join()方法生成字符串“3,2,1”：

var a = [1,2,3];
a.reverse().join() // ⇒ "3,2,1",并且现在的a是[3,2,1]

Array.sort()

Array.sort()方法将数组中的元素排序并返回排序后的数组。当不带参数调用sort()时，数组元素以字母表顺序排序（如有必要将临时转化为字符串进行比较）：

var a = new Array("banana", "cherry", "apple");
a.sort()
var s = a.join(","); // s == "apple,banana,cherry"

如果数组包含undefined元素，它们会被排到数组的尾部。

为了按照其他方式而非字母表顺序进行数组排序，必须给sort()方法传递一个比较函数。该函数决定了它的两个参数在排好序的数组中的先后顺序。假设第一个参数应该在前，比较函数应该返回一个小于0的数值。反之，假设第一个参数应该在后，函数应该返回一个大于0的数值。并且，假设两个值相等（也就是说，它们的顺序无关紧要），函数应该返回0.因此，例如，用数值大小而非字母表顺序进行数组排序，代码如下：

var a = [33, 4, 1111, 222];
a.sort();                          // 字母表顺序： 1111, 222, 33, 4
a.sort(function (a, b) {           // 数值顺序： 4， 33， 222， 1111
	return a - b;                  // 根据顺序，返回，返回负数、0、正数
});
a.sort(function(a,b){return b-a}); // 数值大小相反的顺序

注意，这里使用匿名函数表达式非常方便。既然比较函数只使用一次，就没有必要给他们命名了。

另外一个数组排序的例子，也许需要对一个字符串数组执行不区分大小写的字母表排序，比较函数首先将参数都转化为小写字符串（使用toLowerCase()方法），再开始比较：

var a = ['ant', 'Bug', 'cat', 'Dog'];
a.sort();                // 区分大小写的排序：['Bug', 'Dog', 'ant', 'cat']
a.sort(function (s, t) { // 不区分大小写的排序
	var a = s.toLowerCase();
	var b = t.toLowerCase();
	if (a < b) return -1;
	if (a > b) return 1;
	return 0;
});                      // => ['ant', 'Bug', 'cat', 'Dog']

Array.concat()

Array.concat()方法创建并返回一个新数组，它的元素包括调用concat()的原始数组的元素和concat()的每个参数。如果这些数组中的任何一个自身是数组，则连接的是数组的元素，而非数组本身。但要注意，concat()不会递归扁平化数组的数组。concat()也不会修改调用的数组。下面有一些示例：

var a = [1,2,3];
a.concat(4, 5);         // 返回 [1,2,3,4,5]
a.concat([4,5]);        // 返回 [1,2,3,4,5]
a.concat([4,5], [6,5]); // 返回 [1,2,3,4,5,6,7]
a.concat(4, [5,[6,7]]); // 返回 [1,2,3,4,5,[6,7]]

Array.slice()

Array.slice()方法返回指定数组的一个片段或子数组。它的两个参数分别指定了片段的开始和结束的位置。返回的数组包含第一个参数指定的位置和所有到但不含第二个参数指定的位置之间的所有数组元素。如果只指定一个参数，返回的数组将包含从开始位置到数组结尾的所有元素。例如，参数-1指定了最后一个元素，而-3指定了倒数第三个元素。注意，slice()不会修改调用的数组。下面有一些示例：

var a = [1,2,3,4,5];
a.slice(0,3);   // 返回 [1,2,3]
a.slice(3);     // 返回 [4,5]
a.slice(1,-1);  // 返回 [2,3,4]
a.slice(-3,-2); // 返回 [3]

Array.filter()

filter()方法返回的数组元素是调用的数组的一个子集。传递的函数是用来逻辑判定的：该函数返回true或false。调用判定函数就像调用forEach()和map()一样。如果返回值为true或能转化为true的值，那么传递给判定函数的元素就是就是这个子集的成员，它将被添加到一个作为返回值的数组中。例如：

a = [5, 4, 3, 2, 1];
smallvalues = a.flter(function(x) { return x < 3 }); // [2, 1]
everyother = a.filter(function(x,i) { return i%2===0 }); // [5, 3, 1]

注意，filter()会跳过稀疏数组中缺少的元素，它的返回值总是稠密的。为了压缩稀疏数组的空缺，代码如下：

var dense = sparse.filter(function() { return true; });

甚至，压缩空缺并删除undefined和null元素，可以这样filter()：

a = a.filter(function(x) { return x !== undefined && x !== null; });