JS-数组方法

1、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);
b.join('-'); // => '---------' ：9个连字号组成的字符串

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

2、reverse()

Array.reverse()将数组中的元素点到顺序，返回逆序的数组。它是在原数组中重新排列它们。

var a = [1,2,3];
a.reverse(); // a=[3,2,1]

3、sort()

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

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

若数组包含undefined元素，则它们会被排到数组尾部。

当带参数时，必须给sort()方法传递一个比较函数：

• 如果第一个参数应该在前，则返回负值。
• 如果两个参数相等，则返回零。
• 如果第第二个参数应该在前，则返回正值。

var a = [33,4,1111,222];
a.sort(); // 字母表顺序：[1111,222,33,4]
a.sort(function(a,b){ // 数值顺序[4,33,222,1111]
    return a-b;
});
a.sort(function(a,b){return b-a}); // 数值大小相反顺序

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']

 4、concat()

Array.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,7]); // [1,2,3,4,5,6,7]
a.concat(4,[5,[6,7]]); // [1,2,3,4,5,[6,7]] 

5、slice()

Array.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]

6、splice()（先删除后插入）

Array.splice()是在数组中插入或删除元素的通用方法。splice()会修改调用的数组。splice()返回一个由删除元素组成的数组，或者如果没有删除元素则返回一个空数组。

第一个参数指定了插入和（或）删除的起始位置；

第二个参数指定了应该从数组中删除的元素个数，如果省略，将删除到数组结尾。

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

从第三个参数开始，指定了需要插入到数组中元素，从第一个参数指定的位置开始插入。

var a = [1,2,3,4,5];
a.splice(2,0,'a','b'); // 返回[];a 是[1,2,'a','b',3,4,5]
a.splice(2,2,[1,2],3); // 返回['a','b'];a是[1,2,[1,2],3,4,5]

7、push和pop()

push()和pop()允许将数组当做栈来使用。

push()在数组尾部添加一个或多个元素，并返回数组的新长度。pop()则删除数组的最后一个元素，减小数组的长度并返回它删除的值。两个方法都将修改原始数组。

var stack = [];
stack.push(1,2); // stack:[1,2]；返回2
stack.pop(); // stack:[1]；返回2

8、unshift()和shift()

unshift()在数组头部添加一个或多个元素，返回数组的新长度。

shift()删除数组的第一个元素并将其返回，然后把余下的元素前移。

var a = [];
a.unshift(1); // [1]，返回：1
a.unshift(22); // [22,1]，返回：2
a.shift(); // [1]，返回：22
a.unshift(3,[4,5]); // [3,[4,5],1]，返回：3

注：当unshift()有多个参数时，这些参数是一次性插入的而非一次一个地插入。这意味着插入的元素的顺序和它们在参数列表中的顺序一致。

9、toString()和toLocaleString()

[1,2,3].toString();       // ‘1,2,3’
["a","b","c"].toString(); // 'a,b,c'
[1,[2,"c"]].toString();   // '1,2,c'

注：这里与不使用任何参数的join()方法返回的字符串是一样的。

ECMAScript5中的数组方法

1、fotEach()

fotEach()从头到尾遍历数组，为每个元素调用指定的函数。

var data = [1,2,3,4,5];
var sum = 0;
data.forEach(function(v,i,a){ // v：数组元素，i：元素索引，a：数组本身
    a[i] = v + 1;
});
data // [2,3,4,5,6]

2、map()

map()方法将调用的数组的每个元素传递给指定的函数，并返回一个数组，它包含该函数的所有返回值。

a = [1,2,3];
b = a.map(function(){
  return x*x;
}); // [1,4,9]

map()和forEach()的差异：map()的参数函数必须有返回值；map()返回的是新数组，不修改调用数组。

注：如果是稀疏数组，返回的也是相同方式的稀疏数组：它具有相同的长度，相同的缺失元素。

3、filter()

filter()方法返回的数组元素是调用数组的一个子集。传递的函数是用来逻辑判定的：该函数返回true或false。

a = [5,4,3,2,1];
sub = a.filter(function(x){
    return x < 3;
}); // [2,1]


subodd = a.filter(function(x,i){
    return i%2==0;
}); // [5,3,1]

注：filter()会跳过系数数组中缺少的元素，它返回的数组总是稠密的。故可以此来压缩稀疏数组的空缺：

// 压缩空缺
var dense = parse.filter(function{ return true; });

// 压缩空缺并删除undefined和null元素
a = a.filter(function(x){
12     return x !== undefined && x !=null;
13 });

4、every()和some()

这两个方法是数组的逻辑判定：它们对数组元素应用指定的函数进行判定，返回true或false。

a = [1,2,3,4,5];
a.every(function(x){
    return x < 10; // true，所有的值都<10
});
a.every(function(x){
    return x % 2 == 0; // false：不是所有的值都是偶数
});

a.some(function(x){
    return x % 2; // true：存在偶数的数组元素
});
a.some(isNaN); // false：不存在非数值元素

注：一旦every()和some()确认该返回什么值它们就会停止遍历数组元素。

5、reduce()和reduceRight()

这两个方法使用指定的函数将数组元素进行组合，生成单个值。

var a = [1,2,3,4,5];
var sum = a.reduce(function(x,y){
    return x+y;
},0); // 数组求和

var max = a.reduce(function(){
    return (x>y)?x:y;
}); // 求最大值

reduce()有两个参数，第一个为执行操作的函数，第二个为可选参数，为传递给函数的初始值。

6、indexOf()和lastIndexOf()

这两个方法搜索整个数组中具有给定值的元素，返回找到的第一个元素的索引，若没有找到则返回-1.

indexOf()从头至尾搜索，lastIndexOf()反向搜索。

a = [0,1,2,1,0];
a.indexOf(1); // 返回 1
a.lastIndexOf(1); // 返回 3
a.indexOf(3); // 返回 -1

第一个参数为需要搜索的值，第二个参数是可选的，指定数组中的一个索引，从那里开始搜索。第二个参数也可以是负数，代表相对于数组末尾的偏移量。