String[]myStringArray={“Hello”,“World”}; for(字符串s:myStringArray){ //做点什么 }
-
8 好的,所以我有点困惑,在访问对象时可以使用增强的for循环吗? 然后用一个连续的来填充一个? 这是正确的吗? – 马克·西曼斯基 评论 2010年6月10日0:15 -
55 不,这很简单,数组对象有数字索引,所以您想 迭代 在这些按数字顺序排列的索引上,顺序循环确保 增强 放弃 环 枚举 对象属性,没有特定顺序,它还枚举继承的属性。。。 对于 迭代 始终建议使用阵列上的顺序循环。。。 – 克里斯蒂安·萨尔瓦多 评论 2010年6月10日0:38 -
7 相关的- stackoverflow.com/questions/5349425/… – 琼达维德约翰 评论 2011年11月1日17:53 -
9 jsben.ch/#/Q9oD5 <=这里是一系列阵列循环解决方案的基准 – EscapeNetscape公司 评论 2016年11月3日19:45 -
15 @CMS不,这并不简单。 其他语言都很简单。 这在JS中非常复杂 在里面 和 属于 既可以使用,也可以做不同的事情。 那么你也有 对于每个 以及丑陋而烦人的基于索引的循环。 其他每一种现代语言都使得在一个集合上循环变得简单明了,没有任何意外或混乱。 JS也可以,但它不能。 – jpmc26格式 评论 2018年10月5日15:59
46个答案
for(vari=0;i<xs.length;i++){console.log(xs[i]);} xs.forEach((x,i)=>控制台.log(x)); for(xs的常量x){console.log(x);}
1.顺序 对于
循环:
var myStringArray=[“Hello”,“World”]; var arrayLength=myStringArray.length; for(var i=0;i<arrayLength;i++){ console.log(myStringArray[i]); //做点什么 }
适用于各种环境 你可以使用 打破 和 持续 流量控制语句
太冗长了 迫切需要 容易拥有 非一次性错误 (有时也称为 围栏柱错误 )
2 数组原型.forEach
:
const array=[“一”、“二”、“三”] array.forEach(函数(项、索引){ console.log(项,索引); });
array.forEach(item=>console.log(item));
非常简短。 声明的
无法使用 打破 / 持续
array.filter(item=>item.condition<10) .forEach(项=>控制台.log(项))
常数=[1,2,3,4,5],加倍=[]; numbers.forEach((n,i)=>{加倍[i]=n*2});
常数=[1,2,3,4,5]; const doubled=numbers.map(n=>n*2); console.log(双倍);
常数=[1,2,3,4,5]; 常数和=0; numbers.forEach(num=>{sum+=num});
常数=[1,2,3,4,5]; 常数和=数字减少((total,n)=>总数+n,0); console.log(总和);
3、ES6 放弃
声明:
让颜色=['red','green','blue']; for(颜色的恒定颜色){ console.log(颜色); }
它可以遍历各种对象。 可以使用正常的流量控制语句( 打破 / 持续 ). 用于迭代串行异步值。
如果您以较旧的浏览器为目标 可能会让你大吃一惊 .
不要使用 用于。。。 在里面
迭代顺序不保证; 数组索引不能按数字顺序访问。 继承的属性也会被枚举。
Array.prototype.foo=“foo!”; var数组=['a','b','c']; for(数组中的var i){ console.log(数组[i]); }
var对象={ “a”:1, “b”:2, “c”:3 }; for(obj中的var属性){ if(obj.hasOwnProperty(prop)){ //或if(Object.prototype.hasOwnProperty.call(obj,prop))以确保安全。。。 console.log(“prop:”+prop+“value:”+obj[prop]) } }
-
13 我知道这个答案早于async和Promises,但我觉得在任何有关现代JavaScript的对话中都值得一提:“ 对于每个 不等待承诺。 在使用承诺(或异步函数)作为 对于每个 回调。 " ( developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… ) 评论 2021年6月15日11:41 -
9 -
1 -
4 -
2 对于那些看到这个答案并想知道是否应该选择For-of的每一个()的人,我建议使用For-of。 for-of是一种更新的循环语法,它完全取代了forEach的需要。 for-of提供的东西没有forEach提供的,但反过来却不是真的。 – 斯科蒂·贾米森 评论 2022年5月14日16:32
//要求ECMASCRIPT 2015+ var s,myStringArray=[“Hello”,“World”]; 用于myStringArray的{ // ... 用s做某事。。。 }
//要求ECMASCRIPT 2015+ const myStringArray=[“Hello”,“World”]; for(myStringArray的常量){ // ... 用s做某事。。。 } //此处不再定义s
>只有一个项的//数组,位于索引12 [<12个空项目>,1] >[0]//在索引0处似乎未定义 未定义 >a[0]=undefined//但如果我们在那里放置一个实际的undefined 未定义 >现在看起来像这样 [未定义,<11个空项>,1]
var myStringArray=[“Hello”,“World”]; myStringArray.forEach(函数){ // ... 用s做某事。。。 } );
myStringArray.forEach(s=>{ // ... 用s做某事。。。 } );
var i,s,myStringArray=[“Hello”,“World”],len=myStringArray.length; 对于(i=0;i<len;++i){ s=myStringArray[i]; // ... 用s做某事。。。 }
var i,s,myStringArray=[“Hello”,“World”],len=myStringArray.length; 对于(i=0;i<len;++i){ if(myStringArray中的i){ s=myStringArray[i]; // ... 用s做某事。。。 } }
var i,len,myStringArray=[“Hello”,“World”]; 对于(len=myStringArray.length,i=0;i<len;++i){
myStringArray.forEach(s,i)=>{ // ... 对s和我做点什么。。。 });
for(myStringArray.entries()的const[i,s]){ // ... 用s和i做点什么。。。 }
[1,2,3,4].map(功能(项){ 警报(项目); })
array.map(函数)
var x=[1,2,3,4].map(函数(项){返回项*10;});
var item_processor=函数(项){ //对一个项目做一些复杂的事情 } new_list=my_list.map(项目处理器);
for(mylist中的项){itemprocessor(项);}
-
105 -
21 @哈森 数组原型.map 方法是ECMAScript第五版标准的一部分,尚未在所有实现中可用(例如IE缺少它),也适用于 迭代 在一个数组上我认为 数组原型.forEach 方法更多 语义上 对的。。。 另外,请不要建议for-in语句,更多详细信息请参阅我的回答:) 评论 2010年6月10日0:30 -
for(myStringArray的常量){
//对于块范围,也可以使用“let”或“const”代替“var”。 for(var字母[“a”,“b”,“c”]){ console.log(字母); }
常数带=[ {firstName:“John”,lastName:“Lennon”}, {firstName:“Paul”,lastName:“McCartney”} ]; for(带的常量成员){ console.log(member.firstName+''+member.lastName); }
function*fibonacci(){//生成器函数 设[prev,curr]=[1,1]; while(真){ [上一个,当前]=[当前,上一个+当前]; 收益率; } } for(fibonacci()的常数n){ 控制台.log(n); //将序列截短为1000 如果(n>=1000){ 断裂; } }
}
对于(var i=0,len=myArray.length;i<len;i++){}
6种不同的方法在数组中循环
1.使用 JavaScript for循环
设数组=[1,2,3,4,5]; for(设i=0;i<array.length;i++){ console.log(数组[i]); }
2.使用forEach循环
设数组=[1,2,3,4,5]; array.forEach((元素)=>{ console.log(元素); });
3.用于。。。 属于
设数组=[1,2,3,4,5]; for(数组的let元素){ console.log(元素); }
4.用于。。。 在回路中
设数组=[1,2,3,4,5]; for(让索引进入数组){ console.log(数组[索引]); }
5.使用while循环
设数组=[1,2,3,4,5]; 让长度=array.length; while(长度>0){ console.log(数组[array.length-length]); 长度--; }
6.使用do…while循环
设数组=[1,2,3,4,5]; 让长度=array.length; 做{ console.log(数组[array.length-length]); 长度--; } while(长度>0)
(函数(){ var p,ap=阵列原型,p2={ 过滤器:函数(fun,scope){ var L=此长度,A=[],i=0,val; if(typeof fun==“函数”){ 而(i<L){ 如果(我在此){ val=此[i]; if(fun.call(scope,val,i,this)){ A[A.长度]=val; } } ++i; } } 返回A; }, 每个:功能(乐趣、范围){ var L=此长度,i=0; if(typeof fun==“函数”){ 而(i<L){ if(i在this&&!fun.call(scope,this[i],i,this)中) 返回false; ++i; } 返回true; } 返回null; }, forEach:功能(乐趣、范围){ var L=此长度,i=0; if(typeof fun==“函数”){ 而(i<L){ 如果(我在此){ 有趣的调用(scope,this[i],i,this); } ++i; } } 返回此; }, indexOf:函数(what,i){ i=i||0; var L=此长度; 而(i<L){ if(this[i]===什么) 返回i; ++i; } 返回-1; }, lastIndexOf:函数(what,i){ var L=此长度; i=i||L-1; 如果(isNaN(i)||i>=L) i=L-1; 其他的 如果(i<0)i+=L; 而(i>-1){ if(this[i]===什么) 返回i; --i; } 返回-1; }, 地图:功能(趣味、范围){ var L=this.length,A=数组(this.lendth),i=0,val; if(typeof fun==“函数”){ 而(i<L){ 如果(我在这个){ A[i]=fun.call(范围,this[i],i,this); } ++i; } 返回A; } }, some:功能(乐趣、范围){ var i=0,L=此长度; if(typeof fun==“函数”){ 而(i<L){ if(i在this&&fun.call(scope,this[i],i,this)中) 返回true; ++i; } 返回false; } } } for(p2中的p){ if(!ap[p]) ap[p]=p2[p]; } 返回true; })();
介绍
传统的 对于
-回路
初始化: 在第一次执行look块之前执行 条件: 每次在执行循环块之前检查一个条件,如果为false,则退出循环 事后思考: 每次执行循环块之后执行
用于(;;){ //做一些事情 }
对于(var i=0,长度=10;i<长度;i++){ 控制台.log(i); }
使用传统 对于
循环遍历数组
for(var i=0,length=myArray.length;i<length;i++){ console.log(myArray[i]); }
对于(var i=myArray.length-1;i>-1;i--){ console.log(myArray[i]); }
for(var key=0,value=myArray[key],length=myArray.length;key<length;value=myArray[++key]){ console.log(值); }
var i=0,长度=myArray.length; 对于(;i<长度;){ console.log(myArray[i]); i++; }
var键=0,值; for(;value=myArray[key++];){ console.log(值); }
A类 虽然
环
var键=0; while(value=myArray[key++]){ console.log(值); }
for(var key=0;value=myArray[key++];){ console.log(值); }
对于。。。 在里面
和 用于。。。 属于
for(myArray中的i){ console.log(myArray[i]); }
var myArray=[3,5,7]; myArray.foo=“你好”; for(myArray中的var i){ 控制台.log(i);// 日志0、1、2、“foo” } for(myArray的var i){ 控制台.log(i);// 日志3、5、7 }
数组.原型.forEach()
myArray.forEach(函数(value、key、myArray){ console.log(值); });
图书馆
$.each(myArray,函数(键,值){ console.log(值); });
_.each(myArray,函数(value,key,myArray){ console.log(值); });
_.forEach(myArray,函数(值,键){ console.log(值); });
var i=0,item,items=['one','two','three']; while(项目=项目[i++]){ console.log(项); }
var items=['one','two','three'],i=items.length; 同时(i--){ console.log(项目[i]); }
var项=['one','two','three'] 对于(var i=0,l=items.length;i<l;i++){ console.log(项目[i]); }
for(var i=myArray.length;i---;){ var项=myArray[i]; }
1.只需循环访问数组
constmyArray=[{x:100},{x:200},}x:300}]; myArray.forEach((元素、索引、数组)=>{ console.log(element.x);// 100, 200, 300 console.log(索引);// 0, 1, 2 console.log(数组);// 同一myArray对象3次 });
2.检查数组中的任何元素是否通过测试
const人员=[ {姓名:'约翰',年龄:23}, {姓名:'安德鲁',年龄:3}, {姓名:'彼得',年龄:8}, {姓名:“Hanna”,年龄:14}, {姓名:'亚当',年龄:37}]; const anyAdult=people.some(person=>person.age>=18); console.log(anyAdult);// 真实的
3.转换为新阵列
const-myArray=[{x:100},{x:200},{x:300}]; const newArray=myArray.map(element=>element.x); console.log(newArray);// [100, 200, 300]
4.总结一个特定属性,并计算其平均值
constmyArray=[{x:100},{x:200},}x:300}]; constsum=myArray.map(element=>element.x).reduce((a,b)=>a+b,0); console.log(总和);// 600 = 0 + 100 + 200 + 300 const平均值=总和/myArray.length; console.log(平均值);// 200
5.基于原始数组创建新数组,但不进行修改
constmyArray=[{x:100},{x:200},}x:300}]; const newArray=myArray.map(元素=>{ 返回{ …元件, x: 元素.x*2 }; }); console.log(myArray);// [100, 200, 300] console.log(newArray);// [200, 400, 600]
6.统计每个类别的数量
const人员=[ {name:'John',group:'A'}, {name:'Andrew',group:'C'}, {name:“Peter”,group:“A”}, {name:“James”,组:“B”}, {name:“Hanna”,组:“A”}, {名称:“Adam”,组:“B”}]; const groupInfo=people.reduce((groups,person)=>{ 常数{A=0,B=0,C=0}=群; if(person.group===“A”){ return{…groups,A:A+1}; }else if(person.group===“B”){ return{…groups,B:B+1}; }其他{ return{…groups,C:C+1}; } }, {}); console.log(groupInfo);// {A:3,C:1,B:2}
7.根据特定条件检索数组的子集
const-myArray=[{x:100},{x:200},{x:300}]; const newArray=myArray.filter(element=>element.x>250); console.log(newArray);// [{x:300}]
8.对数组排序
const人员=[ {name:“John”,年龄:21}, {name:“Peter”,年龄:31}, {name:“Andrew”,年龄:29}, {name:“Thomas”,年龄:25} ]; let sortByAge=people.sort(函数(p1,p2){ 返回p1.age-p2.age; }); console.log(sortByAge);
9.在数组中查找元素
const people=[{姓名:“john”,年龄:23}, {姓名:“john”,年龄:43岁}, {name:“jim”,年龄:101}, {姓名:“鲍勃”,年龄:67}]; const john=peoples.find(person=>person.name===“john”); console.log(john);
工具书类
var arr=[1,2,3,4,5];
对于(var i=0,l=arr.length;i<l;i++){ 控制台.log(arr[i]); }
设i=0; 而(arr.length>i){ 控制台.log(arr[i]); i++; }
设i=0; 做{ console.log(arr[i]); i++; } 而(arr.length>i);
函数式编程在 当今的发展世界。 有充分的理由:功能性 技术可以帮助您编写更容易实现的声明性代码 一目了然、重构和测试。
函数式编程的基石之一是它的特殊用途 列表和列表操作。 而这些正是 听起来像是:事物的数组,以及你对它们所做的事情。 但功能性思维方式对待他们的方式与你有点不同 可能会这样。
这篇文章将仔细研究我喜欢称之为“大 三”列表操作:映射、筛选和减少 围绕这三个功能是实现 编写干净的功能代码,并为 强大的函数式和反应式编程技术。
这也意味着您将不再需要编写for循环。
变量i=0, 项目; //请注意,这对于稀疏数组或假值来说很弱 for(;item=myStringArray[i++];){ 项目;// 这是索引处的字符串。 }
变量i=0, len=myStringArray.length;// 缓存长度 对于(;i<len;i++){ myStringArray[i];// 如果计划更改数组的长度,则不要使用此选项 }
-
三 -
-
1 @加布里埃尔:为什么? 请给出实际示例,说明不缓存长度实际上是性能瓶颈。 我遵循“过早优化是万恶之源”的方法。 一旦我遇到问题,我会修复这个循环。。。 – 施蒂恩·德维特 评论 2013年3月31日19:06 -
1 @StijndeWitt认为这只是一个风格问题。 坦白地说,我甚至不再使用for循环,而是使用下划线来完成这些事情,比如_.each、_.map等。 当我像这样写循环时,我主要缓存了长度,以便我的所有变量声明都位于函数顶部的一个位置。 在这方面,遵循我的建议对任何实际应用都无关紧要。 过早的优化是非常糟糕的,但如果优化碰巧是由风格决定引起的,我认为这实际上并不重要。 – 加布里埃尔 评论 2013年4月4日17:15 -
1
for(var i=0;i<things.length;i++){ var事物=事物[i]; console.log(thing); }
for(obj中的var属性){ var propValue=对象[prop]; console.log(propValue); }
结果:
设arr=[1,2,3,4,5]; for(设i=0,大小=arr.length;i<大小;i++){ //做点什么 }
-
-
2 -
-
1
jQuery.each(集合、回调(indexInArray、valueOfElement))
退货: 对象
描述: 泛型迭代器函数,可用于 无缝迭代对象和数组。 阵列和类似阵列 具有长度属性的对象(例如函数的arguments对象) 按数字索引从0到长度-1进行迭代。 其他对象包括 通过其命名属性进行迭代。
这个
$.each() 函数与
$(选择器).each() ,这是 用于以独占方式迭代jQuery对象。 这个
$.each() 函数可用于迭代任何集合,无论它是 map(JavaScript对象)或数组。 对于数组 回调被传递一个数组索引和相应的数组值 时间。 (也可以通过
这 关键字,但 Javascript将始终包装
这 值作为
对象 即使是这样 简单字符串或数值。) 该方法返回其第一个 参数,被迭代的对象。
var someArray=[“some”,“example”,“array”];
for(var i=0,item;item=someArray[i];i++){ //项是“some”,然后是“example”,最后是“array” //i是数组中项的索引 警报(“someArray[”+i+“]:”+item); }
写起来很短 无需访问(更不用说缓存)长度属性 要访问的项在循环中自动定义 你选的名字下的尸体。 与array.push和array.splice非常自然地结合使用列表/堆栈之类的数组
for(字符串项:someArray){ }
-
14 注意,使用这种方法,循环将在找到 假值 ,例如空字符串, 0 , 假 , NaN公司 , 无效的 或 未定义 ,甚至在之前 我 达到长度,例如: jsfiddle.net/prvzk/1 评论 2013年2月28日18:31 -
三
//1:用于 for(设i=0;i<arr.length;++i){ 控制台.log(arr[i]); } //2:每个 arr.forEach((v,i)=>控制台.log(v)); //3:中的 for(让我在arr中){ 控制台.log(arr[i]); } //4:第个,共个 for(arr的常数v){ console.log(v); }
-
2 -
2
神秘的
让a=[“Hello”,“World”]; while(a.length){console.log(a.shift());}
性能测试
结论
对于所有阵列,解决方案C和D在所有浏览器上都是快速或最快的。 对于所有阵列,解决方案A和B在所有浏览器上速度最慢
结果
细节
函数A(A){ 设r=0; 而(a.length)r+=a.shift().length; 返回r; } 功能B(a){ 设r=0; 对于(i in a)r+=a[i].长度; 返回r; } 函数C(a){ 设r=0; 对于(a的x)r+=x长度; 返回r; } 函数D(a){ 设r=0; 对于(i=0;i<a.length;++i)r+=a[i].length; 返回r; } 函数E(a){ 设r=0; a.forEach(x=>r+=x长度); 返回r; } let arr=[“Hello”,“World!”]; [A,B,C,D,E].forEach(f=>控制台.log(`${f.name}:${f([…arr])}`))
-
-
-
4 你说得很好。 我用1000个项目的数组运行了您的示例,并且 while(a.length){console.log(a.shift());} 速度大约是 for(var i=0;i<a.length;i++){console.log(a[i]);} 版本。 ¯\_(ツ)_/¯ – 蓝宝石_砖 评论 2020年8月4日20:51 -
三 即使你的母语中没有冠词,你也不应该漏掉英语中的冠词(不定冠词(“a”或“an”)和定冠词“the”)。 参见示例。 英语文章-修复常见语法错误的3条简单规则 和 A、 AN,THE-英文文章 . – 彼得·莫特森 评论 2020年10月30日8:35 -
2
for(数组中的var i)if(array.hasOwnProperty(i)){ //使用数组[i]执行操作 }
最优雅、最快捷的方式
var arr=[1,2,3,1023,1024]; for(var值;值=arr.pop();) { 值+1 }
编辑(因为我错了)
<script src=“//code.jquery.com/jquery-2.1.0.min.js”></script> <script src=“//cdnjs.cloudflare.com/ajax/libs/underline.js/1.6.0/nundercore-min.js”></script> <脚本> Benchmark.prototype.setup=函数(){ //对值具有最小操作的伪函数 var tmp=0; var过程=函数(值){ tmp=值;// 保持对变量的引用(阻止发动机优化?) }; //声明测试数组 var arr=[]; 对于(var i=0;i<100000;i++) arr[i]=i; }; </script>
<a href=“ http://jsperf.com/native-loop-performance/16 " title=“ http://jsperf.com/native-loop-performance/16 " ><img src=“ http://i.imgur.com/YTrO68E.png “title=”由imgur.com主持“/></a>
var myStringArray=[“hello”,“World”]; for(myStringArray中的var i){ 警报(myStringArray[i]); }
var myStringArray=[“hello”,“World”]; for(var i=0;i<myStringArray.length;i++){ 警报(myStringArray[i]); }
var myStringArray=[“hello”,“World”]; $.each(myStringArray,函数(索引,值){ 警报(值); })
<script src=“ https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js “></script>
var i,max,myStringArray=[“Hello”,“World”]; 对于(i=0,max=myStringArray.length;i<max;i++){ 警报(myStringArray[i]); //做点什么 }
var i,myStringArray=[“item1”,“item2”]; 对于(i=myStringArray.length;i--){ 警报(myStringArray[i]); }
var myStringArray=[“item1”,“item2”],i=myStringArray.length; 同时(i--){ //用水果做点什么 }
/**声明输入*/ const items=['Hello','World'] /**解决方案1。 简单适用于*/ console.log('解决方案1。 简单用于') for(设i=0;i<items.length;i++){ console.log(项目[i]) } 控制台.log() 控制台.log() /**解决方案2。 简单的同时*/ console.log('解决方案2。 简单时间') 设i=0 while(i<items.length){ console.log(项目[i++]) } 控制台.log() 控制台.log() /**解决方案3。 对于每个*/ console.log('解决方案3。 “每个”) 项。forEach(项=>{ console.log(项) }) 控制台.log() 控制台.log() /**解决方案4。 放弃*/ console.log('解决方案4。 for-of’) for(常量项){ console.log(项) } 控制台.log() 控制台.log()
var数=[1,11,22,33,44,55,66,77,88,99111]; var总和=0; numbers.forEach(函数(n)){ 总和+=n; });
var总和=0; var数=[1,11,22,33,44,55,66,77,88,99111]; 对于(var i=0;i<数字.长度;++i){ 总和+=数字[i]; } 警报(i);
[].forEach.call(document.getElementsByTagName('pre'),函数(e){ 控制台.log(e); })
document.querySelectorAll('pre').forEach((e)=>{ console.log(e.textContent); })
<pre>文本1 <pre>文本2 <pre>文本3