数组

1、创建数组

数组直接量

var empty = [];  //没有元素的数组
var primes = [2,3,4,5,6];  //有5个数值的数组
var misc = [1.1,true,'a']  //3个不同类型的元素

var base = 1024;
var table = [base,base+1,base+2,base+3];  //不一定要是常量，可以是任何的表达式

var b = [[1,{x:1,y:2}],[2,{x:3,y:4}]];  //可以包含对象直接量或其他数组直接量
var count = [1,,3];  //如果数组直接量中的某个值，省略的元素将被赋予undefined指

var undefs = [,,]  //数组有2个元素。数组直接量的语法允许有可选的结尾的逗号，所以这里只有两个元素而非三个

使用构造函数 new Array()

var a = new Array();  //该方法创建一个没有任何元素的空数组，等同于数组直接量[]
var b= new Array(10);  //调用时有个一参数，它指定长度。可以用来预分频一个数组空间，注意，数组中没有存储值，甚至数组的索引属性'0','1'等还未定义

var c = new Array(5,4,3,'test');  //显示指定两个或者多个数组元素或者数组的一个非数值元素

 

2、数组元素的读和写

var a= [1,2,3];

var value = a[0];  //读第0个元素
a[3] = 4  //写第3个元素

console.log(a.length);  //4：数组长度

 

3、稀疏数组

稀疏数组就是包含从0开始的不连续索引的数组

var a = new Array(5);  //数组没有元素，但是a.length是5
var b = [];  //创建一个空数组，length=0
b[1000] = 0  //赋值添加一个元素，但是设置的length为1001

 

4、数组长度

如果为一个数组元素赋值，它的索引i大于或等于现有数组的长度时，length属性的值将设置为i+1

设置length属性为一个小于当前长度的非负整数n时，当前数组中的那些索引值大于或等于n的元素将从中删除

var a = [1,2,3,4,5];
console.log(a.length);  //5
a.length = 3;  //现在a为[1,2,3]
console.log(a);
a.length = 0;  //删除所有的元素
a.length = 5;  //长度为5，但是没有元素，就像new Array(5)

 

5、数组元素的添加和删除

为新索引赋值

var a = [];
a[0] = 'zero';
a[1] = 'one';
console.log(a);  //['zero','one']

push() -- 在数组末尾增加一个或者多个元素

var b = [];
b.push('zero');  //末尾添加一个元素。a=['zero']
b.push('one','two');  //再添加两个元素。a=['zero','one','two']
console.log(b)  //['zero','one','two']

unshift() -- 在数组的首部插入一个元素

var c =['three'];
c.unshift('two');
c.unshift('zero','one');
console.log(c);  //["zero", "one", "two", "three"]

用delete运算符删除数组元素，不会修改数组的length属性

var d = [1,2,3];
delete d[1];  //索引1的位置不再有元素
console.log(1 in d);  //false:数组索引1并未在数组中定义
console.log(d.length);  //3:delete操作并不影响数组长度

pop() -- 删除最后一个元素，并返回数组的长度

var e = [1,2,3,4,5];
e.pop();
console.log(e);  //[1,2,3,4]
console.log(e.pop());  //4

shit() -- 删除第一个元素，并返回数组的长度

var f = [1,2,3,4,5];
f.shift();
f.shift();
console.log(f);  //[3,4,5]
console.log(f.shift());  //3

 

6、数组方法

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

var a = [1,2,3,4];
console.log(a.join());  //'1,2,3,4'
console.log(a.join(''));  //'1234'
console.log(a.join(' '));  //'1 2 3 4'
console.log(a.join('-'));  //'1-2-3-4'

Array.reverse() -- 将数组中的元素颠倒顺序，返回逆序的数组。不通过重新排列的元素创建新的数组，而是在原先的数组中重新排列他们

var b = [1,2,3,4];
b.reverse();
console.log(b);  //[4,3,2,1]

Array.sort() -- 将数组中的元素排序并返回排序后的数组。

当不带参数调用sort()时，数组元素以字母表顺序排序（如有必要将临时转化为字符串进行比较）。如果数组包含undefined元素，它们会被排到数组的尾部。

为按照其他方式而非字母表顺序进行数组排序，必须给sort()方法传递一个比较函数。该函数决定了它的两个参数在排好序的数组中的先后顺序。假设第一个参数应该在前，比较函数返回一个小于0的数值。反之，返回一个大于0的数值

var c = [111,22,4,3]
var d = ['banana','cherry','apple'];
d.sort();
c.sort();
console.log(c);  //字母表顺序：[111,22,3,4]
console.log(d);  //["apple","banana","cherry"]
c.sort(function(a,b){
    return a-b;
});
console.log(c);  //[3,4,22,111]
c.sort(function(a,b){
    return b-a;
});
console.log(c);  //[111,22,4,3]

Array.concat() -- 创建并返回一个新的数组,他的元素包括调用concat()的原始数组的元素和concat()的每个参数。如果这些参数中的任何一个自身是数组，则连接的是数组的元素，而非数组本身。但concat()不会修改调用的数组

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

Array.slice() -- 返回指定的数组的一个片段或子数组。它的两个参数分别指定了片段的开始和结束的位置。返回的数组包含第一个参数指定的位置和所有到但不包含第二参数指定的位置之间的所有数组元素。如果只指定一个参数，返回的数组将包含从开始位置到数组结尾的所有元素。如果参数中出现负数，表示相对于数组最后一个元素的位置。slice()不会修改调用的数组

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

Array.splice() -- 在数组中插入或者删除元素。并且会修改调用的数组。第一个参数指定了插入或删除的起始位置。第二个参数指定了应该从数组中删除的元素的个数。紧随其后的任意个数的参数指定了需要插入到数组中的元素，从第一个参数指定的位置开始插入。如果省略第二个参数，从起始点开始到数组结尾的所有元素都将被删除。splice()返回一个由删除元素组成的数组或者如果没有删除元素就返回一个空数组。

var h = [1,2,3,4,5,6,7,8];
h.splice(4);
console.log(h);  //[1, 2, 3, 4]
h.splice(1,2);
console.log(h);  //[1, 4]
h.splice(1,1);
console.log(h);  //[1]

var g = [1,2,3,4,5];
g.splice(2,0,'a','b');
console.log(g);  //[1, 2, "a", "b", 3, 4, 5]
g.splice(2,2,[1,2],3);
console.log(g);  //[1, 2, [1,2], 3, 3, 4, 5]

toString

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

forEach() -- 从头至尾遍历数组，为每个元素调用指定的函数。传递的函数作为第一个参数。然后forEach()使用三个参数调用该函数：数组元素，元素的索引和数组本身.如果只有一个参数，表示该数组元素的值

var a = [1,2,3,4,5];
var sum = 0;
a.forEach(function(value){sum +=value;});
console.log(sum);  //15
a.forEach(function(v,i,a){a[i] = v+1;})
console.log(a);  //[2, 3, 4, 5, 6]

map() -- 将调用的数组的每个元素传递给指定的函数，并返回一个数组.不修改调用的函数

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

fliter() -- 改方法返回的数组元素是调用的数组的一个子集。传递的函数是用来做逻辑判断的，该函数返回true 或者false。如果返回值为true，那么传递给判断函数的元素就是这个子集的成员

var a = [5,4,3,2,1];
small = a.filter(function(x) {
    return x<3;
});
console.log(small);  //[2, 1]
every = a.filter(function(x,i) {  //i是索引值
    return i%2 == 0;
});
console.log(every);  //[5, 3, 1]

every() -- 该方法是数组的逻辑判定，对数组元素应用指定的函数进行判定，当且仅当数组中的所有元素调用判定函数都返回true，它才返回true。第一次判定为false，就返回false

var a = [1,2,3,4,5];
sum = a.every(function(x){return x<10;});
sub = a.every(function(x){return x%2 === 0;});
console.log(sum);  //true
console.log(sub);  //false

some() -- 该方法是数组的逻辑判定，对数组元素应用指定的函数进行判定，当数组中至少有一个元素调用判定函数返回true，它就返回true；当数组中的所有元素调用判定函数都返回false，才返回false。第一次判定为true，就返回true

var a = [1,2,3,4,5];
sum = a.some(isNaN);  
sub = a.some(function(x){return x%2 === 0;});
console.log(sum);  //false
console.log(sub);  //true