예, 구현 에 ECMAScript 2015에 도입 된 for…of 기능 ( “하모니”릴리스)이 포함되어 있다고 가정하면 요즘 꽤 안전한 가정입니다.

다음과 같이 작동합니다.

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

ECMAScript 2015는 블록 범위 변수도 제공하므로 더 좋습니다.

// REQUIRES ECMASCRIPT 2015+
const myStringArray = ["Hello", "World"];
for (const s of myStringArray) {
  // ... do something with s ...
}
// s is no longer defined here

( s반복마다 변수 가 다르지만 const루프 본문 내에서 수정되지 않는 한 선언 할 수 있습니다 .)

희소 배열에 대한 참고 사항 : JavaScript의 배열은 실제로보고 된만큼 많은 항목을 저장할 수 없습니다 length. 그보고 된 숫자는 단순히 값이 저장되는 가장 높은 인덱스보다 하나 더 큽니다. 배열이 길이로 표시된 것보다 적은 수의 요소를 보유하면 희소 하다고합니다 . 예를 들어 인덱스 3, 12 및 247에만 항목이있는 배열을 갖는 것이 합법적입니다. 누락 된 요소들, 또는 당신은 실제로 존재하는 요소를 처리 할 수 있습니까? 두 가지 접근 방식에 대한 많은 응용 프로그램이 있습니다. 배열을 사용하는 대상에 따라 다릅니다.length이 실제로 3 개 값을 저장하고 있지만 이러한 배열은, (248)로보고된다. 다른 인덱스에서 항목에 액세스하려고하면 배열에 undefined값이 있는 것으로 나타납니다 . 따라서 배열을 “루프 스루”하려는 경우 대답해야 할 질문이 있습니다. 길이와 프로세스로 표시되는 전체 범위를 루핑 하시겠습니까?undefined

for.. 을 사용하여 배열을 반복 of하면 루프의 본문이 실행되고 배열에 실제로 존재하지 않는 항목 length에 undefined대해 루프 제어 변수가 설정됩니다 . “함께하는 것”코드의 세부 사항에 따라 해당 동작이 원하는 것일 수 있지만 그렇지 않은 경우 다른 방법을 사용해야합니다.

물론, 일부 개발자들은 선택의 여지가 있지만, 때문에 그들은 아직 지원하지 않는 자바 스크립트의 버전을 타겟팅하고 어떤 이유로, 어쨌든 다른 접근 방법을 사용하는 것이 for… of.

JavaScript 구현이 ECMAScript 사양 의 이전 버전 (예 : 9 이전의 Internet Explorer 버전을 배제)을 준수 Array#forEach하는 경우 루프 대신 반복자 메서드를 사용할 수 있습니다 . 이 경우 배열의 각 항목에서 호출 할 함수를 전달합니다.

var myStringArray = [ "Hello", "World" ];
myStringArray.forEach( function(s) {
     // ... do something with s ...
} );

달리 for… of, .forEach실제로 어레이에 존재하는 요소의 함수를 호출한다. 세 개의 요소와 길이가 248 인 가상 배열을 전달하면 248 번이 아니라 함수를 세 번만 호출합니다. 또한 누락 된 요소와 실제로 설정된 요소를 구분합니다 undefined. 후자의 경우 여전히 함수를 호출 undefined하여 인수로 전달 합니다. 이것이 희소 배열을 처리 .forEach하는 방법이라면 통역사가 for…을 지원하더라도 갈 수있는 방법 일 수 있습니다 of.

모든 버전의 JavaScript 에서 작동하는 마지막 옵션 은 명시적인 계산 루프 입니다. 단순히 0에서 길이보다 1을 작게 세어 카운터를 인덱스로 사용하십시오. 기본 루프는 다음과 같습니다.

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

이 방법의 장점 중 하나는 희소 배열을 처리하는 방법을 선택할 수 있다는 것입니다. 위의 코드는 루프 본문을 전체 length시간 동안 실행하며 누락 된 요소는 .. 과 같이 s설정됩니다 . 대신에 희소 배열의 실제로 존재하는 요소 만 처리하려는 경우 인덱스에 간단한 테스트를 추가 할 수 있습니다 .undefinedforof.forEachin

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 ...
  }
}

myStringArray.length루프 값에 전체 표현식 을 포함하는 것과 달리 로컬 변수에 길이 값을 지정하면 매번 특성 검색을 건너 뛰기 때문에 성능이 크게 달라질 수 있습니다. 내 컴퓨터에서 Rhino를 사용하면 속도가 43 % 향상됩니다.

다음과 같이 루프 초기화 절에서 수행 된 길이 캐싱을 볼 수 있습니다.

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

명시 적 카운팅 루프는 원하는 경우 각 값의 인덱스에 액세스 할 수 있음을 의미합니다. 인덱스는 전달한 함수에 추가 매개 변수로 전달 forEach되므로 다음과 같이 액세스 할 수도 있습니다.

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

for… of각 객체와 관련된 색인을 제공하지는 않지만 반복하는 객체가 실제로 Array( for.. of이 방법이 없을 수있는 다른 반복 가능한 유형에 작동하는 경우) Array를 사용할 수 있습니다 #entries 메소드를 사용하여 [index, item] 쌍의 배열로 변경 한 다음 반복합니다.

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

for… in다른 사람에 의해 언급 구문은 객체의 속성에 걸쳐 반복입니다; JavaScript의 Array는 숫자 속성 이름 (및 자동으로 업데이트 된 length속성)을 가진 객체이기 때문에 이론적으로 Array를 반복 할 수 있습니다. 그러나 문제는 그 자체가 숫자 속성 값으로 제한되지 않는다는 것입니다 (메소드조차도 실제로 값이 클로저 인 속성 일뿐입니다). 따라서 배열을 반복하는 데 for… in구문을 사용해서는 안됩니다 .

답변

[1,2,3,4].map( function(item) {
     alert(item);
})

array.map(func)

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

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);}

for(var i=0, len=myArray.length; i < len; i++){}

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

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

for(var 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 (let n of fibonacci()) {
  console.log(n);
  // truncate the sequence at 1000
  if (n >= 1000) {
    break;
  }
}

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

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);
});