ECMAScriptJS-数组方法

1、join()

Array.join()方法将数组中存有因素都转载为字符串并接连在一起,再次回到最平生成的字符串。

1 var a = [1,2,3];
2 a.join(); // => "1,2,3"
3 a.join(" "); // => "1 2 3"
4 a.join(""); // => "123"
5 var b = new Array(10);
6 b.join('-'); // => '---------' :9个连字号组成的字符串

Array.join()是Sting.split()的逆向操作,后者将字符串分割成多少块来创立八个数组。

2、reverse()

Array.reverse()将数组中的成分点到各类,重回逆序的数组。它是在原数组中重新排列它们。

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

3、sort()

Array.sort()将数组中的成分排序并重回排序后的数组。当不带参数调用sort()时,数组成分以字母表顺序排序(如有须求将权且转会为字符串进行比较)。

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

若数组包涵undefined元素,则它们会被排到数组底部。

当带参数时,必须给sort()方法传递1个相比函数:

  • 假使第1个参数应该在前,则赶回负值。
  • 假设多少个参数相等,则赶回零。
  • 要是第第三个参数应该在前,则赶回正值。

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

    1 var a = [‘ant’,’Bug’,’cat’,’Dog’];
    2 a.sort(); // 区分轻重缓急写排序:[‘Bug’,’Dog’,’ant’,’cat’]
    3 a.sort(function(s,t){ // 不区分轻重缓急写排序
    4 var a = s.toLowerCase();
    5 var b = t.toLowerCase();
    6 if(a < b) return -1; 7 if(a > b) return 1;
    8 return 0;
    9 }); // [‘ant’,’Bug’,’cat’,’Dog’]

 4、concat()

Array.concat()创制并赶回二个新数组,它归纳调用它的原始数组的成分和concat()每一个参数。concat()不会递归扁平化数组的数组,也不会修改调用的数组。

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

5、slice()

Array.slice()重回钦定数组的2个局部或子数组。四个参数分别钦定了一些的始发和终止地点,再次回到的数组包涵第2个参数的职位到不包蕴第四个参数的地点的全部数组成分。

万一头钦定第叁个参数,则赶回从早先地方到数组结尾的保有因素。

只要参数中出现负数,它象征相对于最终三个成分的岗位。

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

六 、splice()(先删除后插入)

Array.splice()是在数组中插入或删除成分的通用方法。splice()会修改调用的数组。splice()重临2个由删除成分结合的数组,或然只要没有去除成分则赶回二个空数组。

第1个参数钦赐了插入和(或)删除的原初地方;

第3个参数钦赐了相应从数组中剔除的成分个数,借使简单,将去除到数组结尾。

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

从第多个参数先导,钦命了急需插入到数组瓜月素,从第1个参数钦赐的职位上马插入。

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

7、push和pop()

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

push()在数组底部添加3个或几个因素,并重返数组的新长度。pop()则删除数组的末梢三个要素,减小数组的长短并回到它删除的值。七个措施都将修改原始数组。

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

8、unshift()和shift()

unshift()在数组底部添加一个或五个要素,再次来到数组的新长度。

shift()删除数组的率先个要素并将其回到,然后把剩下的成分前移。

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

注:当unshift()有多少个参数时,那一个参数是一遍性插入的而非一次八个地插入。那象征插入的成分的次第和它们在参数列表中的顺序一致。

9、toString()和toLocaleString()

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

注:那里与不采取其它参数的join()方法重临的字符串是如出一辙的。

 

ECMAScript5中的数组方法

1、fotEach()

fotEach()从头到尾遍历数组,为各个成分调用内定的函数。

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

2、map()

map()方法将调用的数组的各个元素传递给钦点的函数,并回到2个数组,它包含该函数的有着再次来到值。

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

map()和forEach()的差距:map()的参数函数必须有重回值;map()再次回到的是新数组,不修改调用数组。

注:假若是稀疏数组,再次回到的也是同等方法的疏散数组:它具备同样的尺寸,相同的缺点和失误元素。

3、filter()

filter()方法重临的数组成分是调用数组的1个子集。传递的函数是用来逻辑判定的:该函数重返true或false。

 1 a = [5,4,3,2,1];
 2 sub = a.filter(function(x){
 3     return x < 3;
 4 }); // [2,1]
 5 
 6 
 7 subodd = a.filter(function(x,i){
 8     return i%2==0;
 9 }); // [5,3,1]

注:filter()会跳过周全数组中缺少的元素,它回到的数组总是稠密的。故能够此来压缩稀疏数组的空缺:

1 // 压缩空缺
2 var dense = parse.filter(function{ return true; });
3 
4 // 压缩空缺并删除undefined和null元素
5 a = a.filter(function(x){
6 12     return x !== undefined && x !=null;
7 13 });

4、every()和some()

那四个措施是数组的逻辑判定:它们对数组成分采取内定的函数进行判定,重回true或false。

 1 a = [1,2,3,4,5];
 2 a.every(function(x){
 3     return x < 10; // true,所有的值都<10
 4 });
 5 a.every(function(x){
 6     return x % 2 == 0; // false:不是所有的值都是偶数
 7 });
 8 
 9 a.some(function(x){
10     return x % 2; // true:存在偶数的数组元素
11 });
12 a.some(isNaN); // false:不存在非数值元素

注:一旦every()和some()确认该再次回到什么值它们就会告一段落遍历数组成分。

5、reduce()和reduceRight()

那四个措施应用钦点的函数将数组成分举行重组,生成单个值。

1 var a = [1,2,3,4,5];
2 var sum = a.reduce(function(x,y){
3     return x+y;
4 },0); // 数组求和
5 
6 var max = a.reduce(function(){
7     return (x>y)?x:y;
8 }); // 求最大值

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

先是个参数为急需摸索的值,第二个参数是可选的,钦赐数组中的1个索引,从那边开端物色。第3个参数也足以是负数,代表相对于数组末尾的偏移量。