javascript 数组

创建数组

var empty=[];//创建一个空数组

var primes=[2,,3,5,7,11,];//一个有5个值的数组

var undefs=[,,];//数组中省略的2元素将被赋值为undefined,数组直接量语法允许有可选的结尾逗号，所以[, ,]是两个元素

var a=new Array(); //创建一个没有任何元素的空数组

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

a=new Array(5);//数组中没有元素，但是长度为5

a[1000]=0;//赋值添加一个元素，但是设置length为1001

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

当省略数组直接量中的值时，这时得到的数组也是稀疏的，省略掉的值是不存在的

var a1=[,];//此时数组没有元素，长度是1
var a2=[undefined];//数组包含一个值为undefined的元素
0 in a1  //false a1在索引0处没有元素
0 in a2  //true  a2在索引0处有一个值为undefined的元素

3.数组长度

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

4.数组元素的添加和删除

a=[];

a[0]=”zero”;//向数组中添加元素

a=[];
a.push("zero") //在末尾添加一个元素a=["zero"]
a.push("one","two")//再添加两个元素 a=["zero","one","two"]

使用delete，从数组中删除一个元素

//使用delete删除数组元素
a=[1,2,3];
delete a[1];//a在索引1的位置不再有元素
1 in a  //false 数组索引1并未在数组中定义
a.length   //3  delete操作不影响数组长度

pop 数组长度减少1并返回删除元素的值

shift() 从数组头部删除一个元素，将所有元素下移到比当前索引低的地方

5. 数组的遍历

var keys=Object.keys(0);//获取o对象属性名组成的数组
var values=[];
for (var i=0;i<keys.length;i++){
var key=keys[i];//获得索引处的键值
values[i]=o[key];//在values数组中保存属性值
}
//跳过null undefined 和不存在的元素
for (var i=0;i<a.length;i++){
if (! a[i])  continue;
//循环体
}

//跳过undefined和不存在的元素
for (var i=0;i<a.length;i++){
if(a[i]===undefiend)  continue;
//循环体
}

//只跳过不存在的元素
for (var i=0;i<a.length;i++){
if (!(i in a))  continue;//跳过不存在的元素
//循环体
}

// for/in 循环处理稀疏数组，循环每次将一个可枚举的属性名赋值给循环变量，不存在的索引将不会遍历到
for (var index in a){
var value=a[index];
//要执行的语句
}

for/in能枚举继承的属性名，因此不应该使用for/in循环，除非使用额外的检测方法过滤不想要的属性。

for (var i in a){
if (!a.hasOwnProperty(i))  continue;//跳过继承的属性
//循环体
}
for (var i in a){
//跳过不是非负整数的i
if (String(Math.floor(Math.abs(Number(i)))))!==i   continue;
}

forEach 遍历数组

//forEach 遍历数组
var data=[1,2,3,4,5];
var sumofSquares=0;
data.forEach(function (x){
sumofSquares+=x*x;
});
sumofSquares //55

6.二维数组实现九九乘法表

//数组实现九九乘法表
var table=new Array(10);    //表格有10行
for(var i=0;i<table.length;i++){
table[i]=new Array(10);  //每行有10列
}
for (var row=0;row<table.length;row++){
for(col=0;col<table[row].length;col++){
table[row][col]=row*col;
}
}
var product=table[5][7];//35

7.数组的方法

Array.join() 方法是将数组中所有元素转化为字符串并连接在一起，返回最后生成的字符串，默认分隔符是逗号。

//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.reverse()方法将数组中的元素颠倒顺序，返回逆序的数组

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

Array.sort()方法将数组中的元素排序并返回排序后的数组。没有参数值，数组元素以字母表顺序排序。如果数组包含undefined元素，它们会被排到数组的尾部。

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

//用数值大小而非字母表顺序进行数组排序
var a=[33,4,111,222];
a.sort();//字母表顺序  111,222,33,4
a.sort(function (a,b){
return a-b;//数值顺序 4,33,222,111
});
a.sort(function (a,b){return b-a});//数值大小相反的顺序

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

Array.concat()创建并返回一个新数组，它的元素包括调用conact()的原始数组元素和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]]

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]

Array.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,2]
//从第三个参数开始指定插入的元素
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,3,4,5]

push 在数组尾部添加一个或者多个元素，并返回数组新的长度

pop删除数组最后一个元素，减少数组长度并返回它删除的值

unshift() 在数组的头部添加一个或者多个元素，移动其他的元素，返回数组的新长度

shift() 删除数组第一个元素并将其返回

8. 数组的新方法

数组方法第一个参数接收一个函数，并对数组每个元素调用一次该函数。如果是稀疏数组，对不存在的元素不调用传递的函数。多书情况下，调用提供的函数使用三个参数：数组元素，元素的索引和数组本身。第二个参数是可选的。

forEach()方法从头至尾遍历数组，为每个元素调用指定的函数传递的函数作为forEach()的第一个参数。然后forEach()使用三个参数调用该函数：数组元素。元素的索引和数组本身。

var data=[1,2,3,4,5];
var sum=0;
data.forEach(function (value){sum+=value;});//元素累加
sum
//为每个元素值自加1
data.forEach(function(v,i,a) {a[i]=v+1;}) //v是数组元素  i是索引值  a是数组本身
data  //[2,3,4,5,6]

//forEach无法在所有元素都传递给调用函数之前终止遍历，提前终止可以使用抛出异常
function forEach（a,f,t）{
try {a.forEach(f,t);}
catch(e){
if (e===foreach.break)  return;
else throw e;
}
}
foreach.break=new Error("StopIteratiom");

map()调用数组每个元素传递给指定的函数，并返回一个新数组。它不修改调用的数组。如果是稀疏数组，返回的是相同方式的稀疏数组。

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

filter() 返回调用数组的一个子集。会跳过稀疏数组中缺少的元素，它返回的数组总是稠密的。

a=[5,4,3,2,1];
smallvalues=a.filter(function (x) {return x<3});//[2,1]
everyother=a.filter(function(x,i) {return i%2==0});//[5,3,1]
//压缩稀疏数组的空缺
var dense=sparse.filter(function(){return true;});

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

every() 和some()方法是数组的逻辑判定。every每一个。some是存在。空数组调用时，every()返回true, some() 返回false

reduce()指定函数将数组元素组合。第一个参数是化简操作的函数，第二是初始值。没有指定初始值时，数组的第一个元素作为初始值。

//reduce
var a=[1,2,3,4,5];
var sum=a.reduce(function (x,y) {return x+y},0);//数组求和 第一次参数是0和1，返回和1，再次调用参数
//是1和2，返回值是3
var max=a.reduce(function(x,y){return (x>y)?x:y;});//求最大值

reduceRight()原理同reduce,只是按照数组索引从高到低

indexOf()和lastindexOf() 搜索指定的元素，返回找到的第一个元素的索引值，或者没有找到返回-1.indexOf()从头开始搜索。lastindexOf()从末尾开始搜索。

//查找数组中所有的x，并返回一个包含匹配索引的数组
function findall(a,x){

var results=[];
len=a.length;
pos=0;
while(pos<len){
pos=a.indexOf(x,pos);
if (pos===-1)  break;//没有找到 完成搜索
results.push(pos);//数组存储
pos=pos+1;//从下一个位置开始搜索
}
return results;
}

9 数组的类型

Array.isArray([])  //true
Array.isArray({})  //false

//ECMAScript 3 中isArray()函数
var isArray=Function.isArray||function(o){
return typeof o==="object"&&
Object.prototype.toString.call(o)==="[object Array]";
}

10 字符串数组 字符串是不可变得，所以把它当做数组看待时，它们是只读的。

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