JavaScript-数组-CFANZ编程社区

数组是值的有序集合。

每个值叫做一个元素，而每个元素在数组中有一个位置，以数字表示，称为索引。

JavaScript数组是无类型的：数组元素可以是任意类型，并且同一个数组中的不同元素也可能有不同的类型。

创建数组

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

值不一定要是常量；它们可以是任意的表达式：

var a = 1;
var b = [a,a+1,a+2,a+3];

如果省略数组直接量中的某个值，省略的元素将被赋予undefined值：

var a = [1,,3];
//中间元素为undefined
var b = [,,];
//数组直接量的语法允许有可选的结尾的逗号，故[,,]只有两个元素而非三个。
//2个元素为undefined

Array（）创建数组

var a = new Array();
//空数组
var b = new Array(10);
//创建一个长度为10的数组
var c = new Array(1,2,3,4,5,"a");
//创建一个元素为括号中元素的数组

数组元素的读和写

var a = ["abc"];
var b = a[0]; //读第0个元素
数组索引从0开始
a[1] = 3 //写第一个元素
i = 2;
a[i] = 3; //写第2个元素
a[i+1] = "qqq"; //写第3个元素

注意，可以使用负数或非整数来索引数组。这种情况下，数值转换为字符串，字符串作为属性名来用。既然名字不是非负整数，它就只能当做常规的对象属性，而非数组的索引。同样，如果凑巧使用了是非负整数的字符串，它就当做数组索引，而非对象属性。当使用的一个浮点数和一个整数相等时情况也是一样的：

a[-1.23] = true;
//创建一个名为"-1.23"的属性
a["1000"] = 0;
//写数组的第1000个元素
a[1.00] 
//和a[1]相等

事实上数组索引仅仅是对象属性名的一种特殊类型，这意味着JavaScript数组没有“越界”错误的概念。当试图查询任何对象中不存在的属性时，不会报错，只会得到undefined值。类似于对象，对于对象同样存在这种情况。

稀疏数组

稀疏数组就是包含从0开始的不连续索引的数组。通常，数组的length属性值代表数组中元素的个数。如果数组是稀疏的，length属性值大于元素的个数。

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

注意，当在数组直接量中省略值时不会创建稀疏数组。省略的元素在数组中是存在的，其值为undefined。

var a1 = [,,,]
//数组是[undefined,undefined,undefined]
var a2 = new Array(3);
//该数组没有元素
0 in a1
//true a1在索引0处有一个元素
0 in a1
//false a2在索引0处有一个元素

数组长度

length属性值代表数组中元素的个数。

[].length //length为0 数组没有元素
['a','b','c'].length // length为3

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

a = [1,2,3,4,5];
a.length = 3; //现在a为[1,2,3]
a.length = 0; //删除所有的元素。a为[]
a.length = 5; //长度为5，但是没有元素 与new Array 相同

数组元素的添加和删除

a = [] //空数组
a[0] = "a" //为新索引赋值

使用push（）方法在数组末尾增加一个或多个元素

a = [];
a.push("a") //a=["a"]
a.push("b","c") //a=["a","b","c"]

使用delete运算符来删除数组元素

a = [1,2,3];
delete a[1];
1 in a //false
a.length //3 delete操作并不影响数组长度

数组遍历

a=[1,2,3,4,5,6];
b=[];
for (var i=0,len=a.length; i<len; i++)
{
  b[i] = a[i];
}

多维数组

JavaScript不支持真正的多维数组，但可以用数组的数组来近似。访问数组的数组中的元素，只要简单地使用两次 [ ] 操作符即可。

例如，假设变量matrix是一个数组的数组，它的基本元素是数值，那么matrix[x]的每个元素是包含一个数值数组，访问数组中特定数值的代码为matrix[x][y]。

数组方法

join（）

将数组中所有元素都转化为字符串并连接在一起，返回最后生成的字符串。

var a = [1,2,3];
a.join(); //"1,2,3"
a.join(" "); //"1 2 3"
a.join(""); //"123"

reverse（）

将数组中的元素颠倒顺序，返回逆序的数组。

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

sort（）

将数组中的元素排序并返回排序后的数组。

var a = new Array("b","c","a");
a.sort(); //a=["a","b","c"]

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

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]
//参数-1指定了最后一个元素

splice（）

在数组中插入或删除元素的通用方法。不同于slice（）和concat（），splice（）会修改调用的数组。

splice（）的第一个参数指定了插入和（或）删除的起始位置。第二个参数指定了应该从数组中删除的元素的个数。

var a = [1,2,3,4,5,6,7,8];
s.splice(4); //返回[5,6,7,8]; a是[1,2,3,4]
//如果省略第二个参数，从起始点开始到数组结尾的所有元素都将被删除。
s.splice(1,2); //返回[2,3]; a是[1,4]
s.splice(1,1); //返回[4]; a是[1]

splice（）的前两个参数指定了需要删除的数组元素。紧随其后的任意个数的参数指定了需要插入到数组中的元素，从第一个参数指定的位置开始插入。

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

push（）和pop（）

push（）方法在数组的尾部添加一个或多个元素，并返回数组新的长度。

pop（）方法则相反：它删除数组的最后一个元素，减小数组长度并返回它删除的值。

两个方法都修改并替换原始数组而非生成一个修改版的新数组。

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

unshift（）和shift（）

unshift（）在数组的头部添加一个或多个元素，并将已存在的元素移动到更高索引的位置来获得足够的空间，最后返回数组新的长度。

shift（）删除数组的第一个元素并将其返回，然后把所有随后的元素下移一个位置来填补数组头部的空缺。

var a = [];
a.inshift(1); //a:[1] 返回1
a.inshift(2); //a:[2,1] 返回2
a.shift(); //a:[1] 返回 2

toString（）

数组和其他JavaScript对象一样拥有toString（）方法。针对数组，该方法将其每个元素转化为字符串，并且输出用逗号分隔的字符串列表。

[1,2,3].toString() //生成'1,2,3'
[1,"b",3].toString() //生成'1,b,3'
[1,[2,3]].toString() //生成'1,2,3'

ECMAScript5中的数组方法

forEach（）

forEach（）方法从头至尾遍历数组，为每个元素调用指定的函数。

var data = [1,2,3,4,5];
var sum = 0;
data.forEach(
function (value){
  sum += value;
}
);
//sum: 15

map（）

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

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

filter（）

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

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

every（）和some（）

every（）和some（）方法是数组的逻辑判定：它们对数组元素应用指定的函数进行判定，返回true或false。

every（）方法就像数学中的“针对所有”的量词：当且仅当针对数组中的所有元素调用判定函数都返回true，它才返回true：

a = [1,2,3,4,5];
a.every(function(x){
  return x<10;
}) // true
a.every(function(x){
  return x>10;
}) // false

some（）方法就像数学中的“存在”的量词：当数组中至少有一个元素调用判定函数返回true，它就返回true；并且当且仅当数值中的所有元素调用判定函数都返回false，它才返回false：

a = [1,2,3,4,5];
a.some(function(x){
  return x<2;
}) //true
a.some(function(x){
  return x>5;
}) //false

indexOf（）和lastIndexOf（）

indexOf（）和lastIndexOf（）搜索整个数组中具有给定值的元素，返回找到的第一个元素的索引或者如果没有找到就返回-1。

indexOf（）从头至尾搜索，而lastIndexOf（）则反向搜索。

a = [0,1,2,1,0];
a.indexOf(1) //1: a[1]是1
a.lastIndexOf(1) // 3: a[3]是1
a.indexOf(3) //-1 没有值为3的元素

作为数组的字符串

除了用charAt（）方法来访问单个的字符以外，还可以使用方括号：

var a = test;
s.charAt(0) // "t"
s[1] // "e"

参考资料：《JavaScript权威指南》