js数组遍历.docx
《js数组遍历.docx》由会员分享，可在线阅读，更多相关《js数组遍历.docx（23页珍藏版）》请在冰豆网上搜索。
js数组遍历
1数组基本属性
DOCTYPEhtml>
//数组直接量形式创建数组
vararr=[];//空数组
vararr1=[1,2,3,4,5,6];
vararr2=[1,2.3,true,false,null,undefined,[1,2,3],{x:
1,y:
2}];
varx=1;
vararr3=[x,x*3,x+2,x+3];
console.log（arr3）;
vararr4=[1,,3];//[1,undefined,3]
//alert（arr4）;
console.log（arr4.length）;
vararr5=[,,];
console.log（arr5.length）;
//通过构造函数Array（）创建数组
vara=newArray（）;//[]
vara=newArray（5）;
console.log（a.length）;
vara=newArray（1,2,'king',false,2.3,null）;//[1,2,'king',false,2.3,null]
console.log（a）;
vararr=[1,2,3,4];
console.log（arr[0]）;//1
console.log（arr[3]）;//4
arr[0]='king';
console.log（arr）;
arr[5]='hellomaizi';
console.log（arr）;
varx=2;
console.log（arr[x]）;
arr[arr[x]]=333;
console.log（arr）;
varobj={};
obj[0]='a';
obj[1]='b';
console.log（obj）;
//console.log（obj.length）;
vararr=[];
arr[0]='a';
arr[1]='b';
arr[-123]='c';
arr[2.3]='d';
arr[null]='e';
arr[false]='f';
arr[undefined]='g';
arr['name']='h';
console.log（arr）;
console.log（arr.length）;
vararr=newArray（10）;
arr=[];
arr[100]='abc';
console.log（arr.length）;
vararr=[1,2,3,4,5,6,7,8];
arr.length=3;
console.log（arr）;
arr.length=0;
console.log（arr）;
arr.length=5;
console.log（arr）;
vararr=[1,2,3];
Object.defineProperty（arr,'length',{
writable:
false
}）;
console.log（arr.length）;
arr.length=10;
console.log（arr.length）;
2数组定义
DOCTYPEhtml>
vararr=[];
arr[0]='a';
arr[1]='b';
arr.push（'c'）;
arr.push（'d','e','f',12,34）;
console.log（arr）;
varres=arr.pop（）;
console.log（res）;
console.log（arr）;
arr.unshift（1,2,3,4,5）;
console.log（arr）;
res=arr.shift（）;
console.log（res）;
console.log（arr）;
vararr=['a','b','c','d'];
deletearr[0];
console.log（arr）;
console.log（arr.length）;
3运算符
DOCTYPEhtml>
vararr=['a','b','c','d','e'];
for（vari=0,len=arr.length;iconsole.log（arr[i]）;
}
vararr1=[];
arr1[12]='x';
arr1[23]='y';
arr1[55]='z';
for（variinarr1）{
console.log（arr1[i]）;
}
for（variinarr1）{
if（arr.hasOwnProperty（i））{
console.log（arr1[i]）;
}
}
vararr2=[1,2,3,4,5,6];
arr2.forEach（function（x）{
console.log（x）;
}）;
functionTest（element,index,array）{
console.log（'要处理的数组为：
'+array）;
console.log（'索引：
'+index+"--值为：
"+element）;
}
arr2.forEach（Test）;
4数组中常用的方法
DOCTYPEhtml>
//数组中常用方法
vararr=['a','b','c','d'];
varres=arr.join（）;
res=arr.join（','）;
res=arr.join（''）;
console.log（res）;
res=arr.reverse（）;
console.log（res）;
vararr=['a','b','c','A','B','C'];
arr.sort（）;
console.log（arr）;
vararr=[1,2,11,20,3,15];
arr.sort（）;
console.log（arr）;
arr.sort（function（a,b）{
returna-b;
}）;
arr.sort（function（a,b）{
returnb-a;
}）;
console.log（arr）;
varusers=[
{name:
'king',age:
12},
{name:
'queen',age:
32},
{name:
'zhangsan',age:
54},
{name:
'rose',age:
66},
];
users.sort（function（a,b）{
if（a.name>b.name）return1;
if（a.namereturn0;
}）;
//console.log（users）;
for（variinusers）{
console.log（users[i]['name']）;
}
vararr=[1,2,3];
res=arr.concat（4,5,6）;
res=arr.concat（[4,5,6]）;
res=arr.concat（[4,5,6],[7,8,9]）;
res=arr.concat（[11,[12,[33]]]）;
console.log（res）;
vararr=['a','b','c','d','e','f','g','h'];
res=arr.slice（0,3）;
res=arr.slice（2,-3）;
res=arr.slice（4）;
res=arr.slice（-5,-2）;
console.log（res）;
vararr=['a','b','c','d','e','f','g','h'];
res=arr.splice（0,1）;//['a'];
res=arr.splice（5）;
res=arr.splice（0,2,'!
','?
','%'）;
console.log（res）;
console.log（arr）;
vararr=[1,2,3,4,5,6];
res=arr.map（function（x）{
returnx*x;
}）;
console.log（res）;
vararr=['a!
','b!
','c','d!
','e'];
res=arr.map（Trans）;
functionTrans（x）{
returnx.replace（/!
/g,'?
'）.toUpperCase（）;
}
console.log（res）;
vararr=[1,3,4,5,5,623,4,345,4367,null,undefined,false,true,''];
res=arr.filter（function（x）{
returnx<=10;
}）;
res=arr.filter（function（x）{
returnx%2==0;
}）;
res=arr.filter（function（x）{
returnx!
==undefined&&x!
=null;
}）;
console.log（res）;
vararr=[1,2,3,4,5];
res=arr.reduce（function（a,b）{
returna+b;
}）;
res=arr.reduce（function（a,b）{
returna+b;
},10）;
console.log（res）;
varage=[12,34,55,66,28,19];
res=age.every（function（x）{
returnx>=18;
}）;
res=age.some（function（x）{
returnx>=19;
}）;
console.log（res）;
vararr=['a','b','c','d','e','a','bv','a'];
res=arr.indexOf（'a'）;//0
res=arr.indexOf（'A'）;//-1
res=arr.indexOf（'a',2）;
res=arr.lastIndexOf（'a'）;
console.log（res）;
console.log（Array.isArray（arr））;
console.log（Array.isArray（[]））;
console.log（Array.isArray（{}））;
vararr=['a','b','c','d','e','a','bv','a'];
console.log（arr.toString（））;
console.log（arr.join（））;
5数组遍历
DOCTYPEhtml>
functionforeach（a,f,t）{
try{
a.forEach（f,t）;
}catch（e）{
if（e===foreach.break）{
return;
}else{
throwe;
}
}
}
foreach.break=newError（'stopIteration'）;
vararr=['a','b','c','d'];
alert（foreach（arr,foreach.break））;
6两个函数传递给目标函数
DOCTYPEhtml>
functionsum（a,b）{
returna（）+b（）;
}
functiontest1（）{
return1;
}
functiontest2（）{
return2;
}
//将两个函数传递给目标函数
//alert（sum（test1,test2））;
//也可以胜利test1和test2函数，使用匿名函数的形式
//alert（sum（function（）{return1;},function（）{return2;}））;
//我们将函数A传递给函数B，由函数B来执行A时，A就成了一个回调函数callback
//functions；如果此时A还是一个匿名函数，我们就称它为匿名回调函数。
7setup
DOCTYPEhtml>
//（function（name）{
//alert（'hello'+name+'!
'）;
//}）（'king'）;
//functiona（param）{
//functionb（theinput）{
//returntheinput*2;
//}
//return'theresultis'+b（param）;
//}
//alert（b
（2））;
//functiona（）{
//alert（'A!
'）;
//returnfunction（）{
//alert（'B'）;
//};
//}
//a（）（）;
//varnewFunc=a（）;
//newFunc（）;
//functiona（）{
//alert（"aaaa"）;
//returna=function（）{
//alert（'BBBB'）;
//};
//}
//a=a（）;
//a（）;
//vara=（function（）{
//functionsomeSetup（）{
//varsetup='done';
//}
//functionactualWork（）{
//alert（'worky-king'）;
//}
//someSetup（）;
//returnactualWork;
//}）（）;
//functiona（）{
//alert（'A'）;
//a=function（）{
//alert（'B'）;
//};
//}
//a（）;
//a（）;
vara=function（）{
functionsomeSetup（）{
varsetup='done';
}
functionactualWord（）{
alert（'workwork'）;
}
someSetup（）;
returnactualWord;
}（）;
a（）;
8closures
DOCTYPEhtml>
/*
1.闭包就是能够读取其他函数内部变量的函数。
由于在Javascript语言中，只有函数内部的子函数才能读取局部变量，
因此可以把闭包简单理解成“定义在一个函数内部的函数”。
所以，在本质上，闭包就是将函数内部和函数外部连接起来的一座桥梁。
2.闭包的用途：
一个是前面提到的可以读取函数内部的变量，另一个就是让这些变量的值始终保持在内存中。
functionf1（）{
varn=999;
nAdd=function（）{n+=1}
functionf2（）{
alert（n）;
}
returnf2;
}
varresult=f1（）;
result（）;//999
nAdd（）;
result（）;//1000
在这段代码中，result实际上就是闭包f2函数。
它一共运行了两次，第一次的值是999，第二次的值是1000。
这证明了，函数f1中的局部变量n一直保存在内存中，并没有在f1调用后被自动清除。
为什么会这样呢？
原因就在于f1是f2的父函数，而f2被赋给了一个全局变量，这导致f2始终在内存中，
而f2的存在依赖于f1，因此f1也始终在内存中，不会在调用结束后，
被垃圾回收机制（garbagecollection）回收。
这段代码中另一个值得注意的地方，就是“nAdd=function（）{n+=1}”这一行，
首先在nAdd前面没有使用var关键字，因此nAdd是一个全局变量，而不是局部变量。
其次，nAdd的值是一个匿名函数（anonymousfunction），
而这个匿名函数本身也是一个闭包，所以nAdd相当于是一个setter，
可以在函数外部对函数内部的局部变量进行操作。
--------------------------------------------------------------------------------------------------------
五、使用闭包的注意点
1）由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包，
否则会造成网页的性能问题，在IE中可能导致内存泄露。
解决方法是，在退出函数之前，将不使用的局部变量全部删除。
2）闭包会在父函数外部，改变父函数内部变量的值。
所以，如果你把父函数当作对象（object）使用，
把闭包当作它的公用方法（PublicMethod），
把内部变量当作它的私有属性（privatevalue），这时一定要小心，不要随便
改变父函数内部变量的值。
*/
//vara=1;
//functiontest（）{
//varb=2;
//returna;
//}
//alert（test（））;
//alert（b）;
//vara=1;
//functiontest（）{
//varb=2;
//functiontest1（）{
//varc=3;
//alert（b）;
//alert（a）;
//}
//test1（）;
//}
//alert（test（））;
//functionf1（）{
//vara=1;
//returnf2（）;
//}
//functionf2（）{
//returna;
//}
//alert（f1（））;
//vara=5;
//alert（f1（））;
//a=213;
//alert（f1（））;
//deletea;
//alert（f1（））;
//functionf（）{
//varb='b';
//returnfunction（）{
//returnb;
//}
//}
////alert（b）;
//varn=f（）;
//alert（n（））;
//varn;
//functionf（）{
//varb='b';
//n=function（）{
//returnb;
//};
//}
//alert（f（））;
//alert（n（））;
//functionf（arg）{
//varn=function（）{
//returnarg;
//};
//arg++;
//returnn;
//}
//varm=f（123）;
//alert（m（））;
//functionf（）{
//vara=[];
升级会员 