javascript - 탈출 - 자바스크립트 배열 출력




JavaScript로 배열 반복하기 (20)

for (myStringArray의 var s) {

(직접 질문에 대답하십시오 : 이제 할 수 있습니다!)

다른 대부분의 대답은 옳지 만 ECMA Script 6 2015 가 반복을위한 새로운 메커니즘 인 for..of 루프를 가져오고 있다고 언급하지 않았습니다.

이 새로운 구문은 반복 색인을 필요로하지 않는 한 자바 스크립트에서 배열을 반복하는 가장 우아한 방법이지만 브라우저에서는 아직 광범위하게 지원되지 않습니다.

현재 Firefox 13 이상, Chrome 37 이상에서 작동하며 다른 브라우저에서도 기본적으로 작동하지 않습니다 (아래 브라우저 호환성 참조). 다행히도 우리는 오늘날 JSF 컴파일러 (예 : Babel )를 사용하여 차세대 기능을 사용할 수 있습니다.

또한 노드에서 작동합니다 (버전 0.12.0에서 테스트했습니다).

배열 반복

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

발전기 반복 :

( https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of 에서 추출한 예제)

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

호환성 표 : http://kangax.github.io/es5-compat-table/es6/#For..of 루프

사양 : http://wiki.ecmascript.org/doku.php?id=harmony:iterators

}

Java에서는 다음과 같이 for 루프를 사용하여 배열의 객체를 트래버스 할 수 있습니다.

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

자바 스크립트에서 똑같이 할 수 있습니까?


가장 우아하고 빠른 방법

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

http://jsperf.com/native-loop-performance/8

편집 됨 (내가 잘못했기 때문에)

100000 개 항목의 배열을 반복하는 메서드를 비교하고 매번 새로운 값으로 최소 작업을 수행합니다.

예비:

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

JavaScript에서는 for-in 루프를 사용하여 Array를 반복하는 것은 좋지 않지만 다음과 같은 for 루프를 사용하는 것이 더 좋습니다.

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

최적화되어 있습니다 (배열 길이를 "캐싱"). 더 많은 것을 배우고 싶다면 주제에 관한 글을 읽어보십시오 .


while 루프를 사용하십시오 ...

var i=0, item, items = ['one','two','three'];
while(item = items[i++]){
    console.log(item);
}

로그 : 'one', 'two', 'three'

그리고 역순으로, 훨씬 더 효율적인 루프

var items = ['one','two','three'], i = items.length;
while(i--){
    console.log(items[i]);
}

로그 : '3', '2', '1'

또는 고전적인 for 루프

var items = ['one','two','three']
for(var i=0, l = items.length; i < l; i++){
    console.log(items[i]);
}

로그 : 'one', 'two', 'three'

참조 : http://www.sitepoint.com/google-closure-how-not-to-write-javascript/


루프를 사용하여 JavaScript에서 동일한 작업을 수행 할 수 있지만 이에 국한되지는 않습니다. JavaScrip에서 루프를 반복하는 여러 가지 방법이 있습니다. 아래 배열을 가지고 루프를 처리하고 싶다고 가정 해보십시오.

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

다음은 솔루션입니다.

1) For 루프

for 루프는 자바 스크립트에서 배열을 반복하는 일반적인 방법이지만 큰 배열에 대해서는 가장 빠른 솔루션으로 간주되지 않습니다.

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

2) While 루프

while 루프는 긴 배열을 루프하는 가장 빠른 방법으로 간주되지만 일반적으로 JavaScript에서는 사용되지 않습니다.

let i=0;

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

3) Do while while
do while while while 같은 일을하는 동안 문법적으로 차이가있다 :

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

이들은 자바 스크립트 루프를 수행하는 주요 방법이지만, 그렇게 할 수있는 방법은 많지 않습니다.

또한 우리 for in는 자바 스크립트에서 객체를 반복 하는 루프를 사용 합니다.

또한 map(), JavaScript에서 Array에 대한 filter(), reduce()등등의 함수를 살펴보십시오 . 그들은 사용하는 것보다 상황이 훨씬 빠르고 더 잘 할 수 whilefor.

자바 스크립트에서 배열을 통한 비동기 함수에 대해 더 자세히 알고 싶다면이 기사를 읽어 보시기 바랍니다.

기능적 프로그래밍은 요즘 개발 도상국에서 상당히 인기를 얻고 있습니다. 그리고 정당한 이유가 있습니다 : 기능적 기술은 한눈에 이해하기 쉬운 선언적 코드를 작성하고 리팩터링하고 테스트하는 데 도움이됩니다.

함수형 프로그래밍의 초석 중 하나는 목록 및 목록 연산을 특수하게 사용하는 것입니다. 그리고 그러한 것들은 마치 그들이 가지고있는 것과 같은 소리입니다 : 배열 된 것들, 그리고 당신이 그들에게하는 것들. 그러나 기능적 사고 방식은 예상보다 조금 다르게 처리합니다.

이 기사에서는 map, filter 및 reduce와 같은 "big three"목록 연산을 자세히 살펴볼 것입니다. 이 세 가지 기능을 중심으로 머리를 감싸는 것은 깨끗한 기능 코드를 작성하는 데있어 중요한 단계이며 기능적 및 반응성 프로그래밍의 강력한 기술에 대한 문호를 열어줍니다.

또한 for 루프를 다시 작성할 필요가 없다는 것을 의미합니다.

더 읽기 >> here :


루프에 암시 적 범위가 거의없고 여분의 변수를 사용하지 않는 방법이 있습니다.

var i = 0,
     item;

// note this is weak to sparse arrays or falsey values
for ( ; item = myStringArray[i++] ; ){ 
    item; // This is the string at the index.
}

또는 정말로 id를 얻고 정말로 고전적인 for 루프를 원한다면 :

var i = 0,
    len = myStringArray.length; // cache the length

for ( ; i < len ; i++ ){
    myStringArray[i]; // Don't use this if you plan on changing the length of the array
}

최신 브라우저는 모두 반복기 메소드 forEach , Array , reduce , filterArray 프로토 타입 에있는 다른 메소드의 호스트를 지원합니다.


순차 for 루프를 사용하십시오.

var myStringArray = ["Hello","World"];
var arrayLength = myStringArray.length;
for (var i = 0; i < arrayLength; i++) {
    alert(myStringArray[i]);
    //Do something
}

@zipcodeman은 for...in 문의 사용을 제안하지만 for-in 반복 배열 for-in 피하면 안됩니다.이 문은 객체 속성을 열거 하기위한 것입니다.

다음과 같은 이유로 배열과 같은 객체에 사용하면 안됩니다.

  • 반복의 순서는 보장되지 않지만 배열 인덱스는 숫자 순으로 방문하지 않을 수 있습니다.
  • 상속 된 속성도 열거됩니다.

두 번째 요점은 많은 문제를 일으킬 수 있다는 것입니다. 예를 들어, Array.prototype 객체를 확장하여 거기에 메서드를 포함하면 해당 속성도 열거됩니다.

예 :

Array.prototype.foo = "foo!";
var array = ['a', 'b', 'c'];

for (var i in array) {
  alert(array[i]);
}

위 코드는 "a", "b", "c"및 "foo!"를 경고합니다.

네이티브 프로토 타입 기능 향상 (예 : MooTools)에 많이 의존하는 라이브러리를 사용하면 특히 문제가됩니다.

앞에서 말한 for-in 문은 객체 속성을 열거 합니다. 예를 들면 다음과 같습니다.

var obj = {
  "a": 1,
  "b": 2,
  "c": 3
};

for (var prop in obj) {
  if (obj.hasOwnProperty(prop)) { 
  // or if (Object.prototype.hasOwnProperty.call(obj,prop)) for safety...
    alert("prop: " + prop + " value: " + obj[prop])
  }
}

위의 예제에서 hasOwnProperty 메서드를 사용하면 객체가 물리적으로 가진 속성 만 상속 된 속성이 아닌 자신의 속성 만 열거 할 수 있습니다.

다음 기사를 읽어 보시기 바랍니다.


예,하지만 구현에 ECMAScript 2015 ( "하모니"릴리스)에 소개 된 기능이 포함 된 경우에만 가능합니다.

그것은 다음과 같이 작동합니다 :

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

또는 ECMAScript 2015가 letconst 를 통해 블록 범위 변수를 제공하기 때문에 더 좋습니다.

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

많은 자바 스크립트 개발자는 아직 웹 브라우저에서 코드를 작성하여 사이트 개발자가 자신의 클라이언트가 사용할 브라우저 / 버전을 확신 할 수없는 환경에서 작업하고 있습니다.

자바 스크립트 인터프리터가 이전 버전의 ECMAScript 사양 (예 : Internet Explorer 9 이전 버전은 제외)을 준수한다고 가정 할 수 있다면 루프 대신 forEach 반복기 메서드를 사용할 수 있습니다. 이 경우 배열의 각 항목에 호출 할 함수를 전달합니다.

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

하지만 너무 많은 것을 가정하고 JavaScript의 모든 버전에서 작동하는 것을 원한다면 명시적인 계산 루프를 사용해야합니다. 스파 스 배열을 올바르게 처리하는 가장 안전한 버전은 다음과 같습니다.

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) {

다른 사람이 언급 한 for ... 구문은 객체의 속성을 반복하는 데 사용됩니다. JavaScript의 Array는 숫자 속성 이름 (자동으로 업데이트 된 length 속성)을 가진 객체이기 때문에 이론적으로는 Array를 사용하여 Array를 반복 할 수 있습니다. 하지만 문제는 숫자 속성 값으로 제한되지 않는다는 것입니다 (메서드는 실제로 값이 클로저 인 속성 일 뿐이며 숫자 순서대로 반복하지 않습니다). 따라서 for..in 구문을 Arrays를 통해 루핑하는 데 사용해서는 안됩니다 .


자바 스크립트에서 함수 프로그래밍 방식으로 배열을 반복하는 경우를 사용합니다.

1. 그냥 배열을 통해 루프

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

참고 : Array.prototype.forEach ()는 입력 매개 변수가 값을 반환하지 않아 순수한 함수로 간주 될 수 없으므로 엄밀히 말하면 기능적 방법이 아닙니다.

2. 배열의 요소 중 하나라도 테스트에 통과했는지 확인하십시오

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

3. 새로운 배열로 변환

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

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

참고 : map () 메서드는 호출 배열의 모든 요소에 제공된 함수를 호출 한 결과가 포함 된 새 배열을 만듭니다.

4. 특정 부동산을 합산하고 평균을 계산하십시오.

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

5. 원본을 기반으로하지만 수정하지 않고 새 배열을 만듭니다.

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]

6. 각 카테고리의 수를 센다.

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}

7. 특정 기준에 따라 배열의 하위 집합 검색

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

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

참고 : filter () 메서드는 제공된 함수로 구현 된 테스트를 통과 한 모든 요소로 새 배열을 만듭니다.

8. 배열 정렬

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

9. 배열에서 요소 찾기

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

Array.prototype.find () 메서드는 제공된 테스트 함수를 만족하는 배열의 첫 번째 요소 값을 반환합니다.

참고 문헌


자바 스크립트에서 배열을 통해 루프하는 다양한 방법이 있습니다.

일반 루프 :

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

ES5의 forEach :

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

jQuery.each :

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

자세한 정보를 보거나 for...in 에서 JavaScript의 배열을 반복하고 jQuery check jQuery.each() 사용하여 확인할 jQuery.each() .


underscore.js 라이브러리를 사용하는 것이 좋습니다. 배열 / 컬렉션을 반복하는 데 사용할 수있는 다양한 함수를 제공합니다.

예를 들면 :

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

PythonHaskell 과 같은 다른 언어에서도 사용할 수있는 함수 프로그래밍 기법 인 map 을 사용할 수 있습니다.

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

일반적인 구문은 다음과 같습니다.

array.map(func)

일반적으로 func 는 배열의 항목 인 하나의 매개 변수를 취합니다. 그러나 JavaScript의 경우 항목의 인덱스 인 두 번째 매개 변수와 배열 자체 인 세 번째 매개 변수를 사용할 수 있습니다.

array.map 의 반환 값은 다른 배열이므로 다음과 같이 사용할 수 있습니다.

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

그리고 이제 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);}

당신은 new_list 얻지 않는다는 것을 제외하고.


jQuery를 사용하고 싶다면 문서의 좋은 예가있다.

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

나는 개인적으로 내가 가장 좋아하는 변이를 아직 보지 못했다.

주어진 배열 :

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

JsFiddle의 다음 내용을보십시오 : http://jsfiddle.net/prvzk/

이것은 희소 하지 않은 배열에서만 작동합니다 . 실제로 배열의 각 인덱스에 값이 있음을 의미합니다. 그러나 실제로 Javascript에서는 희소 배열을 거의 사용하지 않는다는 것을 알았습니다 ... 그런 경우 일반적으로 객체를지도 / 해시 테이블로 사용하는 것이 훨씬 쉽습니다. 당신이 희소 배열을 가지고 있고 0 .. length-1 위로 반복하고 싶다면, for (var i = 0; i <someArray.length; ++ i) 구조가 필요하지만 여전히 if 루프를 사용하여 현재 색인의 요소가 실제로 정의되어 있는지 확인합니다.

또한 CMS는 아래의 주석에서 언급했듯이 위조 값을 포함하지 않는 배열에서만이 방법을 사용할 수 있습니다. 예제의 문자열 배열은 작동하지만 빈 문자열이나 숫자가 0 또는 NaN 인 경우 루프가 너무 일찍 중단됩니다. 다시 한번 말하지만 이것은 실제로 나에게 문제가되지는 않지만 마음에 두어야 할 사항이다. 사용하기 전에 이것에 대한 생각을하는 고리가된다. 그것은 어떤 사람들에게는 그것을 실격시킬 수있다. :)

이 루프에 대해 내가 좋아하는 것은 :

  • 쓰기가 짧다.
  • length 속성에 액세스 할 필요가 없습니다.
  • 액세스 할 항목은 사용자가 선택한 이름으로 루프 본문 내에서 자동으로 정의됩니다.
  • array.push 및 array.splice와 매우 자연스럽게 결합하여 목록 / 스택과 같은 배열을 사용합니다.

이 작동하는 이유는 배열 사양에서는 배열의 길이보다 큰 항목을 읽을 때 == undefined를 반환한다는 것입니다. 그러한 위치에 쓸 때 실제로 길이를 업데이트합니다.

나에게있어,이 구조는 내가 좋아하는 Java 5 구문을 가장 밀접하게 모방한다.

for (String item : someArray) {
}

... 루프 내부의 현재 인덱스에 대해서도 알고있는 이점이 있습니다.


배열 반복에 사용할 수있는 여러 메커니즘의 성능 측면에 관심이있는 사람이라면 다음 JSPerf 테스트를 준비했습니다.

https://jsperf.com/fastest-array-iterator

결과 :

전통적인 for()iterator는 캐시 된 배열 길이 와 함께 사용할 때 훨씬 빠른 방법 입니다.

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

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

Array.prototype.forEach()Array.prototype.map()메소드는 아마의 결과로서, 느린 근사치 함수 호출 오버 헤드


예를 들어, Firefox 콘솔에서 사용되었습니다.

[].forEach.call(document.getElementsByTagName('pre'), function(e){ 
   console.log(e);
})

프로토 타입의 객체 속성을 포함하지 않고 객체 속성 만 반복하는 메소드가 있습니다.

for (var i in array) if (array.hasOwnProperty(i)) {
    // do something with array[i]
}

하지만 여전히 사용자 정의 속성을 반복합니다.

자바 스크립트에서 모든 사용자 정의 속성은 배열을 포함한 모든 객체에 할당 될 수 있습니다.

하나는 sparsed 배열 이상 반복하고자하는 경우 for (var i = 0; i < array.length; i++) if (i in array)또는 array.forEach함께 es5shim사용되어야한다.


JavaScript로 할 수있는 몇 가지 방법이 있습니다. 처음 두 예제는 JavaScript 샘플입니다. 세 번째는 jQuery가 .each()함수 를 사용하는 JavaScript 라이브러리를 사용한다 .

var myStringArray = ["hello", "World"];
for(var i in myStringArray) {
  alert(myStringArray[i]);
}

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

var myStringArray = ["hello", "World"];
$.each(myStringArray, function(index, value){
  alert(value);
})
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>


내 생각에 가장 좋은 방법은 Array.forEach 함수를 사용하는 것입니다. MDN에서 polyfill을 사용하도록 제안 할 수 없다면 자바 스크립트에서 배열을 반복하는 것이 가장 안전한 방법입니다.

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach

그래서 다른 사람들이 제안했듯이, 이것은 거의 항상 당신이 원하는 것입니다 :

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

이렇게하면 배열을 처리하는 범위에서 필요한 모든 것이 해당 범위 내에 있으며 배열의 값만 처리되며 객체 속성 및 다른 멤버는 처리되지 않습니다. 이는 for...에 대한 것입니다.

대부분의 경우에 일반 C 스타일의 루프를 사용하면 루프 내의 모든 요소가 프로그램의 나머지 영역과 공유한다는 것을 기억하는 것이 중요합니다. {}은 새로운 범위를 만들지 않습니다.

금후:

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

"11"을 출력합니다 - 당신이 원하는 것일 수도 그렇지 않을 수도 있습니다.

jsFiddle 예제 작업 : https://jsfiddle.net/workingClassHacker/pxpv2dh5/7/


짧은 대답 : 예. 당신은 이것을 할 수 있습니다 :

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

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

브라우저 콘솔에서 "element1", "element2"등과 같은 것을 볼 수 있습니다.





for-loop