在JavaScript中循环遍历数组

在Java中，可以使用

for

循环遍历数组中的对象，如下所示：

String[] myStringArray = {"Hello", "World"};
for (String s : myStringArray)
{
    // Do something
}

在JavaScript中也可以这样做吗？

有三个主要选项：

for（var i=0；i

xs.forEach（（x，i）=>console.log（x））

for（const x of xs）{console.log（x）；}

下面是详细的例子

---

1.循环的顺序

：

var myStringArray=[“你好”，“世界”]；
var arrayLength=myStringArray.length；
对于（变量i=0；i
三个主要选项：

for（var i=0；i

xs.forEach（（x，i）=>console.log（x））

for（const x of xs）{console.log（x）；}
下面是详细的例子


1.循环的顺序
：

var myStringArray=[“你好”，“世界”]；
var arrayLength=myStringArray.length；
对于（变量i=0；i}
您可以使用
map
，这是一种函数式编程技术，在和等其他语言中也可以使用

一般语法为：

array.map(func)

通常，
func
将采用一个参数，该参数是数组的一项。但是对于JavaScript，它可以接受第二个参数，即项的索引，第三个参数是数组本身

array.map
的返回值是另一个数组，因此可以这样使用它：

var x = [1,2,3,4].map( function(item) {return item * 10;});

// REQUIRES ECMASCRIPT 2015+
var s, myStringArray = ["Hello", "World"];
for (s of myStringArray) {
  // ... do something with s ...
}

var i, s, myStringArray = [ "Hello", "World" ], len = myStringArray.length;
for (i=0; i<len; ++i) {
  s = myStringArray[i];
  // ... do something with s ...
}

var i, len, myStringArray = [ "Hello", "World" ];
for (len = myStringArray.length, i=0; i<len; ++i) {

现在x是
[10,20,30,40]

您不必内联编写函数。它可以是一个单独的函数

var item_processor = function(item) {
      // Do something complicated to an item
}

new_list = my_list.map(item_processor);

这相当于：

 for (item in my_list) {item_processor(item);}

除非您没有获得
新列表
，否则您可以使用
映射
，这是一种函数式编程技术，在和等其他语言中也可用

一般语法为：

array.map(func)

通常，
func
将采用一个参数，该参数是数组的一项。但是对于JavaScript，它可以接受第二个参数，即项的索引，第三个参数是数组本身

array.map
的返回值是另一个数组，因此可以这样使用它：

var x = [1,2,3,4].map( function(item) {return item * 10;});

// REQUIRES ECMASCRIPT 2015+
var s, myStringArray = ["Hello", "World"];
for (s of myStringArray) {
  // ... do something with s ...
}

var i, s, myStringArray = [ "Hello", "World" ], len = myStringArray.length;
for (i=0; i<len; ++i) {
  s = myStringArray[i];
  // ... do something with s ...
}

var i, len, myStringArray = [ "Hello", "World" ];
for (len = myStringArray.length, i=0; i<len; ++i) {

现在x是
[10,20,30,40]

您不必内联编写函数。它可以是一个单独的函数

var item_processor = function(item) {
      // Do something complicated to an item
}

new_list = my_list.map(item_processor);

这相当于：

 for (item in my_list) {item_processor(item);}

除了你没有得到新的列表之外，Opera、Safari、Firefox和Chrome现在都有一套增强的数组方法来优化许多常见的循环

您可能不需要所有这些功能，但它们可能非常有用，如果每个浏览器都支持它们，它们也会非常有用

Mozilla实验室发布了他们和他们都使用的算法，以便您可以自己添加它们

过滤器返回满足某些条件或测试的项目数组

every如果每个数组成员都通过了测试，则返回true

some如果通过测试，则返回true

forEach对每个数组成员运行一个函数，不返回任何内容

map类似于forEach，但它返回每个元素的操作结果数组

这些方法都将函数作为第一个参数，并具有可选的第二个参数，这是一个对象，当数组成员循环通过函数时，您希望将其作用域施加到数组成员上

var item_processor = function(item) {
      // Do something complicated to an item
}

new_list = my_list.map(item_processor);

忽略它，直到你需要它

indexOf和lastIndexOf找到与参数完全匹配的第一个或最后一个元素的适当位置

(function(){
    var p, ap= Array.prototype, p2={
        filter: function(fun, scope){
            var L= this.length, A= [], i= 0, val;
            if(typeof fun== 'function'){
                while(i< L){
                    if(i in this){
                        val= this[i];
                        if(fun.call(scope, val, i, this)){
                            A[A.length]= val;
                        }
                    }
                    ++i;
                }
            }
            return A;
        },
        every: function(fun, scope){
            var L= this.length, i= 0;
            if(typeof fun== 'function'){
                while(i<L){
                    if(i in this && !fun.call(scope, this[i], i, this))
                        return false;
                    ++i;
                }
                return true;
            }
            return null;
        },
        forEach: function(fun, scope){
            var L= this.length, i= 0;
            if(typeof fun== 'function'){
                while(i< L){
                    if(i in this){
                        fun.call(scope, this[i], i, this);
                    }
                    ++i;
                }
            }
            return this;
        },
        indexOf: function(what, i){
            i= i || 0;
            var L= this.length;
            while(i< L){
                if(this[i]=== what)
                    return i;
                ++i;
            }
            return -1;
        },
        lastIndexOf: function(what, i){
            var L= this.length;
            i= i || L-1;
            if(isNaN(i) || i>= L)
                i= L-1;
            else
                if(i< 0) i += L;
            while(i> -1){
                if(this[i]=== what)
                    return i;
                --i;
            }
            return -1;
        },
        map: function(fun, scope){
            var L= this.length, A= Array(this.length), i= 0, val;
            if(typeof fun== 'function'){
                while(i< L){
                    if(i in this){
                        A[i]= fun.call(scope, this[i], i, this);
                    }
                    ++i;
                }
                return A;
            }
        },
        some: function(fun, scope){
            var i= 0, L= this.length;
            if(typeof fun== 'function'){
                while(i<L){
                    if(i in this && fun.call(scope, this[i], i, this))
                        return true;
                    ++i;
                }
                return false;
            }
        }
    }
    for(p in p2){
        if(!ap[p])
            ap[p]= p2[p];
    }
    return true;
})();

（函数（）{
var p，ap=Array.prototype，p2={
过滤器：功能（乐趣、范围）{
var L=this.length，A=[]，i=0，val；
if（typeof fun=='function'）{
而（i-1）{
如果（这个[i]==什么）
返回i；
--一,；
}
返回-1；
},
地图：功能（乐趣、范围）{
var L=this.length，A=Array（this.length），i=0，val；
if（typeof fun=='function'）{
而（i而（iOpera、Safari、Firefox和Chrome现在都共享一组增强的数组方法，用于优化许多常见循环

您可能不需要所有这些功能，但它们可能非常有用，如果每个浏览器都支持它们，它们也会非常有用

Mozilla实验室发布了他们和他们都使用的算法，以便您可以自己添加它们

过滤器返回满足某些条件或测试的项目数组

every如果每个数组成员都通过了测试，则返回true

some如果通过测试，则返回true

forEach对每个数组成员运行一个函数，不返回任何内容

map类似于forEach，但它返回一个结果数组
var i, s, myStringArray = [ "Hello", "World" ], len = myStringArray.length;
for (i=0; i<len; ++i) {
  s = myStringArray[i];
  // ... do something with s ...
}

var i, s, myStringArray = [ "Hello", "World" ], len = myStringArray.length;
for (i=0; i<len; ++i) {
  if (i in myStringArray) {
    s = myStringArray[i];
    // ... do something with s ...
  }
}

var i, len, myStringArray = [ "Hello", "World" ];
for (len = myStringArray.length, i=0; i<len; ++i) {

myStringArray.forEach( function(s, i) {
   // ... do something with s and i ...
});

for (const [i, s] of myStringArray.entries()) {
  // ... do something with s and i ...
}

_.each([1, 2, 3], function(num){ alert(num); });
=> alerts each number in turn...

for (var i=myArray.length;i--;){
  var item=myArray[i];
}

var someArray = ["some", "example", "array"];

for (var i=0, item; item=someArray[i]; i++) {
  // item is "some", then "example", then "array"
  // i is the index of item in the array
  alert("someArray[" + i + "]: " + item);
}

for (String item : someArray) {
}

var x = [4, 5, 6];
for (i = 0, j = x[i]; i < x.length; j = x[++i]) {
    console.log(i,j);
}

// You could also use "let" or "const" instead of "var" for block scope.
for (var letter of ["a", "b", "c"]) {
   console.log(letter);
}

const band = [
  {firstName : 'John', lastName: 'Lennon'},
  {firstName : 'Paul', lastName: 'McCartney'}
];

for(const member of band){
  console.log(member.firstName + ' ' + member.lastName);
}

function* fibonacci() { // A generator function
  let [prev, curr] = [1, 1];
  while (true) {
    [prev, curr] = [curr, prev + curr];
    yield curr;
  }
}

for (const n of fibonacci()) {
  console.log(n);
  // Truncate the sequence at 1000
  if (n >= 1000) {
    break;
  }
}

var i, max, myStringArray = ["Hello", "World"];
for (i = 0, max = myStringArray.length; i < max; i++) {
    alert(myStringArray[i]);

    // Do something
}

var i,myStringArray = ["item1","item2"];
for (i =  myStringArray.length; i--) {
    alert(myStringArray[i]);
}

var myStringArray = ["item1","item2"],i = myStringArray.length;
while(i--) {
   // Do something with fruits[i]
}

var arr = [1, 2, 3, 1023, 1024];
for (var value; value = arr.pop();) {
    value + 1
}

<script src="//code.jquery.com/jquery-2.1.0.min.js"></script>
<script src="//cdnjs.cloudflare.com/ajax/libs/underscore.js/1.6.0/underscore-min.js"></script>
<script>
    Benchmark.prototype.setup = function() {
        // Fake function with minimal action on the value
        var tmp = 0;
        var process = function(value) {
            tmp = value; // Hold a reference to the variable (prevent engine optimisation?)
        };
        
        // Declare the test Array
        var arr = [];
        for (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="Hosted by imgur.com" /></a>

var i;
for (i = 0; i < substr.length; ++i) {
    // Do something with `substr[i]`
}

substr.forEach(function(item) {
    // Do something with `item`
});

jQuery.each(substr, function(index, item) {
    // Do something with `item` (or `this` is also `item` if you like)
});

for (;;) {
    // Do stuff
}

for (var i = 0, length = 10; i < length; i++) {
    console.log(i);
}

for (var i = 0, length = myArray.length; i < length; i++) {
    console.log(myArray[i]);
}

for (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(value);
}

var i = 0, length = myArray.length;
for (; i < length;) {
    console.log(myArray[i]);
    i++;
}

var key = 0, value;
for (; value = myArray[key++];){
    console.log(value);
}

var key = 0;
while(value = myArray[key++]){
    console.log(value);
}

for(var key = 0; value = myArray[key++];){
    console.log(value);
}

for (i in myArray) {
    console.log(myArray[i]);
}

var myArray = [3, 5, 7];
myArray.foo = "hello";

for (var i in myArray) {
  console.log(i); // logs 0, 1, 2, "foo"
}

for (var i of myArray) {
  console.log(i); // logs 3, 5, 7
}

myArray.forEach(function(value, key, myArray) {
    console.log(value);
});

$.each(myArray, function(key, value) {
    console.log(value);
});

_.each(myArray, function(value, key, myArray) {
    console.log(value);
});

_.forEach(myArray, function(value, key) {
    console.log(value);
});

var myArray = ["element1", "element2", "element3", "element4"];

for (i = 0; i < myArray.length; i++) {
  console.log(myArray[i]);
}

 $.each([ 52, 97 ], function( index, value ) {
      alert( index + ": " + value );
 });

for(var i = 0; i < things.length; i++){
    var thing = things[i];
    console.log(thing);
}

for(var prop in obj){
    var propValue = obj[prop];
    console.log(propValue);
}

var numbers = [1,11,22,33,44,55,66,77,88,99,111];
var sum = 0;
numbers.forEach(function(n){
  sum += n;
});

var sum = 0;
var numbers = [1,11,22,33,44,55,66,77,88,99,111];

for(var i = 0; i<numbers.length; ++i){
  sum += numbers[i];
}

alert(i);

var arr = [1, 2, 3, 4, 5];

for (var i=0, l=arr.length; i<l; i++) {
  console.log(arr[i]);
}

let i=0;

while (arr.length>i) {
    console.log(arr[i]);
    i++;
}

let i=0;
do {
  console.log(arr[i]);
  i++;
}
while (arr.length>i);

const myArray = [{x:100}, {x:200}, {x:300}];

myArray.forEach((element, index, array) => {
    console.log(element.x); // 100, 200, 300
    console.log(index); // 0, 1, 2
    console.log(array); // same myArray object 3 times
});

const people = [
    {name: 'John', age: 23}, 
    {name: 'Andrew', age: 3}, 
    {name: 'Peter', age: 8}, 
    {name: 'Hanna', age: 14}, 
    {name: 'Adam', age: 37}];

const anyAdult = people.some(person => person.age >= 18);
console.log(anyAdult); // true

const myArray = [{x:100}, {x:200}, {x:300}];

const newArray= myArray.map(element => element.x);
console.log(newArray); // [100, 200, 300]

const myArray = [{x:100}, {x:200}, {x:300}];

const sum = myArray.map(element => element.x).reduce((a, b) => a + b, 0);
console.log(sum); // 600 = 0 + 100 + 200 + 300

const average = sum / myArray.length;
console.log(average); // 200

const myArray = [{x:100}, {x:200}, {x:300}];

const newArray= myArray.map(element => {
    return {
        ...element,
        x: element.x * 2
    };
});

console.log(myArray); // [100, 200, 300]
console.log(newArray); // [200, 400, 600]

const people = [
    {name: 'John', group: 'A'}, 
    {name: 'Andrew', group: 'C'}, 
    {name: 'Peter', group: 'A'}, 
    {name: 'James', group: 'B'}, 
    {name: 'Hanna', group: 'A'}, 
    {name: 'Adam', group: 'B'}];

const groupInfo = people.reduce((groups, person) => {
    const {A = 0, B = 0, C = 0} = groups;
    if (person.group === 'A') {
        return {...groups, A: A + 1};
    } else if (person.group === 'B') {
        return {...groups, B: B + 1};
    } else {
        return {...groups, C: C + 1};
    }
}, {});

console.log(groupInfo); // {A: 3, C: 1, B: 2}

const myArray = [{x:100}, {x:200}, {x:300}];

const newArray = myArray.filter(element => element.x > 250);
console.log(newArray); // [{x:300}] 

const people = [
  { name: "John", age: 21 },
  { name: "Peter", age: 31 },
  { name: "Andrew", age: 29 },
  { name: "Thomas", age: 25 }
];

let sortByAge = people.sort(function (p1, p2) {
  return p1.age - p2.age;
});

console.log(sortByAge);

const people = [ {name: "john", age:23},
                {name: "john", age:43},
                {name: "jim", age:101},
                {name: "bob", age:67} ];

const john = people.find(person => person.name === 'john');
console.log(john);

let arr = [1,2,3,4,5];

for(let i=0, size=arr.length; i<size; i++){
    // Do something
}

var arr = ["apple", "banana", "cherry", "mango"];
arr.forEach(function(item, index, _) {
   console.log("[" + index + "] = '" + item + "'");
});