Three main options:

1. for (var i = 0; i < xs.length; i++) { console.log(xs[i]); }
2. xs.forEach((x, i) => console.log(x));
3. for (const x of xs) { console.log(x); }

Detailed examples are below.

1. Sequentialfor loop:

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

Pros

• Works on every environment
• You can usebreak andcontinue flow control statements

Cons

• Too verbose
• Imperative
• Easy to haveoff-by-one errors (sometimes also called afence post error)

2.Array.prototype.forEach:

TheES5 specification introduced a lot of beneficial array methods. One of them, theArray.prototype.forEach, gave us a concise way to iterate over an array:

const array = ["one", "two", "three"]array.forEach(function (item, index) {  console.log(item, index);});

Being almost ten years as the time of writing that the ES5 specification was released (Dec. 2009), it has been implemented by nearly all modern engines in the desktop, server, and mobile environments, so it's safe to use them.

And with the ES6 arrow function syntax, it's even more succinct:

array.forEach(item => console.log(item));

Arrow functions are also widely implemented unless you plan to support ancient platforms (e.g.,Internet Explorer 11); you are also safe to go.

Pros

• Very short and succinct.
• Declarative

Cons

• Cannot usebreak /continue

Normally, you can replace the need tobreak out of imperative loops by filtering the array elements before iterating them, for example:

array.filter(item => item.condition < 10)     .forEach(item => console.log(item))

Keep in mind if you are iterating an arrayto build another array from it, you should usemap. I've seen this anti-pattern so many times.

Anti-pattern:

const numbers = [1,2,3,4,5], doubled = [];numbers.forEach((n, i) => { doubled[i] = n * 2 });

Proper use case ofmap:

const numbers = [1,2,3,4,5];const doubled = numbers.map(n => n * 2);console.log(doubled);

Also, if you are trying toreduce the array to a value, for example, you want to sum an array of numbers, you should use thereduce method.

Anti-pattern:

const numbers = [1,2,3,4,5];const sum = 0;numbers.forEach(num => { sum += num });

Proper use ofreduce:

const numbers = [1,2,3,4,5];const sum = numbers.reduce((total, n) => total + n, 0);console.log(sum);

3. ES6for-of statement:

TheES6 standard introduces the concept of iterable objects and defines a new construct for traversing data, thefor...of statement.

This statement works for any kind of iterable object and also for generators (any object that has a\[Symbol.iterator\] property).

Array objects are by definition built-in iterables in ES6, so you can use this statement on them:

let colors = ['red', 'green', 'blue'];for (const color of colors){    console.log(color);}

Pros

• It can iterate over a large variety of objects.
• Can use normal flow control statements (break /continue).
• Useful to iterate serially asynchronous values.

Cons

• If you are targeting older browsers, the transpiled outputmight surprise you.

Do not usefor...in

@zipcodeman suggests the use of thefor...in statement, but for iterating arraysfor-in should be avoided, that statement is meant toenumerate object properties.

It shouldn't be used for array-like objects because:

• The order of iteration is not guaranteed; the array indexes may not be visited in numeric order.
• Inherited properties are also enumerated.

The second point is that it can give you a lot of problems, for example, if you extend theArray.prototype object to include a method there, that property will also be enumerated.

For example:

Array.prototype.foo = "foo!";var array = ['a', 'b', 'c'];for (var i in array) {    console.log(array[i]);}

The above code will console log "a", "b", "c", and "foo!".

That can be particularly a problem if you use some library that relies heavily on native prototypes augmentation (such asMooTools).

Thefor-in statement, as I said before, is there toenumerate object properties, for example:

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...        console.log("prop: " + prop + " value: " + obj[prop])    }}

In the above example, thehasOwnProperty method allows you to enumerate onlyown properties. That's it, only the properties that the object physically has, no inherited properties.

I would recommend you to read the following article:

• Enumeration VS Iteration

Yes, assuming your implementation includes thefor...of feature introduced inECMAScript 2015 (the "Harmony" release)... which is a pretty safe assumption these days.

It works like this:

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

Or better yet, since ECMAScript 2015 also provides block-scoped variables:

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

(The variables is different on each iteration, but can still be declaredconst inside the loop body as long as it isn't modified there.)

A note on sparse arrays: an array in JavaScript may not actually store as many items as reported by itslength; that number is simply one greater than the highest index at which a value is stored. If the array holds fewer elements than indicated by its length, its said to besparse. For example, it's perfectly legitimate to have an array with items only at indexes 3, 12, and 247; thelength of such an array is 248, though it is only actually storing 3 values. If you try to access an item at any other index, the array will appear to have theundefined value there, but the array is nonetheless is distinct from one that actually hasundefined values stored. You can see this difference in a number of ways, for example in the way the Node REPL displays arrays:

> a              // array with only one item, at index 12[ <12 empty items>, 1 ]> a[0]           // appears to have undefined at index 0undefined> a[0]=undefined // but if we put an actual undefined thereundefined> a              // it now looks like this[ undefined, <11 empty items>, 1 ]

So when you want to "loop through" an array, you have a question to answer: do you want to loop over the full range indicated by its length and processundefineds for any missing elements, or do you only want to process the elements actually present? There are plenty of applications for both approaches; it just depends on what you're using the array for.

If you iterate over an array withfor..of, the body of the loop is executedlength times, and the loop control variable is set toundefined for any items not actually present in the array. Depending on the details of your "do something with" code, that behavior may be what you want, but if not, you should use a different approach.

Of course, some developers have no choice but to use a different approach anyway, because for whatever reason they're targeting a version of JavaScript that doesn't yet supportfor...of.

As long as your JavaScript implementation is compliant with theprevious edition of the ECMAScript specification (which rules out, for example, versions of Internet Explorer before 9), then you can use theArray#forEach iterator method instead of a loop. In that case, you pass a function to be called on each item in the array:

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

You can of course use an arrow function if your implementation supports ES6+:

myStringArray.forEach( s => {      // ... do something with s ...} );

Unlikefor...of,.forEach only calls the function for elements that are actually present in the array. If passed our hypothetical array with three elements and a length of 248, it will only call the function three times, not 248 times. If this is how you want to handle sparse arrays,.forEach may be the way to go even if your interpreter supportsfor...of.

The final option, which works inall versions of JavaScript, isan explicit counting loop. You simply count from 0 up to one less than the length and use the counter as an index. The basic loop looks like this:

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

One advantage of this approach is that you can choose how to handle sparse arrays. The above code will run the body of the loop the fulllength times, withs set toundefined for any missing elements, just likefor..of; if you instead want to handle only the actually-present elements of a sparse array, like.forEach, you can add a simplein test on the index:

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

Depending on your implementation's optimizations, assigning the length value to the local variable (as opposed to including the fullmyStringArray.length expression in the loop condition) can make a significant difference in performance since it skips a property lookup each time through. You may see the length caching done in the loop initialization clause, like this:

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

The explicit counting loop also means you have access to the index of each value, should you want it. The index is also passed as an extra parameter to the function you pass toforEach, so you can access it that way as well:

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

for...of doesn't give you the index associated with each object, but as long as the object you're iterating over is actually an instance ofArray (and not one of the other iterable typesfor..of works on), you can use theArray#entries method to change it to an array of [index, item] pairs, and then iterate over that:

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

Thefor...in syntax mentioned by others is for looping over an object's properties; since an Array in JavaScript is just an object with numeric property names (and an automatically-updatedlength property), you can theoretically loop over an Array with it. But the problem is that it doesn't restrict itself to the numeric property values (remember that even methods are actually just properties whose value is a closure), nor is it guaranteed to iterate over those in numeric order. Therefore, thefor...in syntax shouldnot be used for looping through Arrays.

You can usemap, which is a functional programming technique that's also available in other languages likePython andHaskell.

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

The general syntax is:

array.map(func)

In generalfunc would take one parameter, which is an item of the array. But in the case of JavaScript, it can take a second parameter which is the item's index, and a third parameter which is the array itself.

The return value ofarray.map is another array, so you can use it like this:

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

And now x is[10,20,30,40].

You don't have to write the function inline. It could be a separate function.

var item_processor = function(item) {      // Do something complicated to an item}new_list = my_list.map(item_processor);

which would be sort-of equivalent to:

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

Except you don't get thenew_list.

for (const s of myStringArray) {

(Directly answering your question: now you can!)

Most other answers are right, but they do not mention (as of this writing) thatECMAScript 6  2015 is bringing a new mechanism for doing iteration, thefor..of loop.

This new syntax is the most elegant way to iterate an array in JavaScript (as long you don't need the iteration index).

It currently works with Firefox 13+, Chrome 37+ and it does not natively work with other browsers (see browser compatibility below). Luckily we have JavaScript compilers (such asBabel) that allow us to use next-generation features today.

It also works on Node.js (I tested it on version 0.12.0).

Iterating an array

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

Iterating an array of objects

const band = [  {firstName : 'John', lastName: 'Lennon'},  {firstName : 'Paul', lastName: 'McCartney'}];for(const member of band){  console.log(member.firstName + ' ' + member.lastName);}

Iterating a generator:

(example extracted fromhttps://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 (const n of fibonacci()) {  console.log(n);  // Truncate the sequence at 1000  if (n >= 1000) {    break;  }}

Compatibility table:http://kangax.github.io/compat-table/es6/#test-for..of_loops

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

}

In JavaScript it's not advisable to loop through an Array with a for-in loop, but it's better to use afor loop such as:

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

It's optimized as well ("caching" the array length). If you'd like to learn more,read my post on the subject.

6 different methods to loop through the array

You can loop through an array by many different methods. I have sorted my 6 favorite methods from top to bottom.

1. UsingJavaScript for loop

When it's to simply loop through an array, thefor loop is my first choice.

let array = [1, 2, 3, 4, 5];for (let i = 0; i < array.length; i++) {  console.log(array[i]);}

2. Using forEach loop

forEach loop is a modern way to loop through the array. Also, it gives more flexibility and control over the array and elements.

let array = [1, 2, 3, 4, 5];array.forEach((element) => {  console.log(element);});

3. Using for...of

for...of loop gives you direct access to the array elements.

let array = [1, 2, 3, 4, 5];for (let element of array) {  console.log(element);}

4. Using for...in loop

for...in gives you a key using which you can access array elements.

let array = [1, 2, 3, 4, 5];for(let index in array){  console.log(array[index]);}

5. Using while loop

while loop is can be used to loop through the array as well.

let array = [1, 2, 3, 4, 5];let length = array.length;while(length > 0){  console.log(array[array.length - length]);  length--;}

6. Using do...while loop

Likewise, I usedo...while loop

let array = [1, 2, 3, 4, 5];let length = array.length;do {  console.log(array[array.length - length]);  length--;}while (length > 0)

Opera, Safari, Firefox and Chrome now all share a set of enhanced Array methods for optimizing many common loops.

You may not need all of them, but they can be very useful, or would be if every browser supported them.

Mozilla Labs published the algorithms they andWebKit both use, so that you can add them yourself.

filter returns an array of items that satisfy some condition or test.

every returns true if every array member passes the test.

some returns true if any pass the test.

forEach runs a function on each array member and doesn't return anything.

map is like forEach, but it returns an array of the results of the operation for each element.

These methods all take a function for their first argument and have an optional second argument, which is an object whose scope you want to impose on the array members as they loop through the function.

Ignore it until you need it.

indexOf andlastIndexOf find the appropriate position of the first or last element that matches its argument exactly.

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

Introduction

Since my time in college, I've programmed in Java, JavaScript, Pascal,ABAP, PHP,Progress 4GL, C/C++ and possibly a few other languages I can't think of right now.

While they all have their own linguistic idiosyncrasies, each of these languages share many of the same basic concepts. Such concepts include procedures / functions,IF-statements,FOR-loops, andWHILE-loops.

A traditionalfor-loop

A traditionalfor loop has three components:

1. The initialization: executed before the look block is executed the first time
2. The condition: checks a condition every time before the loop block is executed, and quits the loop if false
3. The afterthought: performed every time after the loop block is executed

These three components are separated from each other by a; symbol. Content for each of these three components is optional, which means that the following is the most minimalfor loop possible:

for (;;) {    // Do stuff}

Of course, you will need to include anif(condition === true) { break; } or anif(condition === true) { return; } somewhere inside thatfor-loop to get it to stop running.

Usually, though, the initialization is used to declare an index, the condition is used to compare that index with a minimum or maximum value, and the afterthought is used to increment the index:

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

Using a traditionalfor loop to loop through an array

The traditional way to loop through an array, is this:

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

Or, if you prefer to loop backwards, you do this:

for (var i = myArray.length - 1; i > -1; i--) {    console.log(myArray[i]);}

There are, however, many variations possible, like for example this one:

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

...or this one...

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

...or this one:

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

Whichever works best is largely a matter of both personal taste and the specific use case you're implementing.

Note that each of these variations is supported by all browsers, including very very old ones!

Awhile loop

One alternative to afor loop is awhile loop. To loop through an array, you could do this:

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

Like traditionalfor loops,while loops are supported by even the oldest of browsers.

Also, note that every while loop can be rewritten as afor loop. For example, thewhile loop hereabove behaves the exact same way as thisfor-loop:

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

For...in andfor...of

In JavaScript, you can also do this:

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

This should be used with care, however, as it doesn't behave the same as a traditionalfor loop in all cases, and there are potential side-effects that need to be considered. SeeWhy is using "for...in" for array iteration a bad idea? for more details.

As an alternative tofor...in, there's now also forfor...of. The following example shows the difference between afor...of loop and afor...in loop:

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}

Additionally, you need to consider that no version of Internet Explorer supportsfor...of (Edge 12+ does) and thatfor...in requires at least Internet Explorer 10.

Array.prototype.forEach()

An alternative tofor-loops isArray.prototype.forEach(), which uses the following syntax:

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

Array.prototype.forEach() is supported by all modern browsers, as well as Internet Explorer 9 and later.

Libraries

Finally, many utility libraries also have their ownforeach variation. AFAIK, the three most popular ones are these:

jQuery.each(), injQuery:

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

_.each(), inUnderscore.js:

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

_.forEach(), inLodash:

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

Use thewhile loop...

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

It logs: 'one', 'two', and 'three'

And for the reverse order, an even more efficient loop:

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

It logs: 'three', 'two', and 'one'

Or the classicalfor loop:

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

It logs: 'one','two','three'

Reference:Google Closure: How not to write JavaScript

If you want a terse way to write a fast loopand you can iterate in reverse:

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

This has the benefit of caching the length (similar tofor (var i=0, len=myArray.length; i<len; ++i) and unlikefor (var i=0; i<myArray.length; ++i)) while being fewer characters to type.

There are even some times when you ought to iterate in reverse, such as when iterating over alive NodeList where you plan on removing items from the DOM during iteration.

Some use cases of looping through an array inthe functional programming way in #"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. Find an element in an array

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

The Array.prototype.find() method returns the value of the first element in the array that satisfies the provided testing function.

References

• Array.prototype.some()
• Array.prototype.forEach()
• Array.prototype.map()
• Array.prototype.filter()
• Array.prototype.sort()
• Spread syntax
• Array.prototype.find()

Yes, you can do the same in JavaScript using a loop, butnot limited to that. There are many ways to do a loop over arrays in JavaScript. Imagine you have this array below, and you'd like to do a loop over it:

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

These are the solutions:

1) For loop

Afor loop is a common way looping through arrays in JavaScript, but it is no considered as the fastest solutions for large arrays:

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

2) While loop

A while loop is considered as the fastest way to loop through long arrays, but it is usually less used in the JavaScript code:

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

3) Do while
Ado while is doing the same thing aswhile with some syntax difference as below:

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

These are the main ways to do JavaScript loops, but there are a few more ways to do that.

Also we use afor in loop for looping over objects in JavaScript.

Also look at themap(),filter(),reduce(), etc. functions on an Array in JavaScript. They may do things much faster and better than usingwhile andfor.

This is a good article if you like to learn more about the asynchronous functions over arrays in JavaScript.

Functional programming has been making quite a splash in thedevelopment world these days. And for good reason: Functionaltechniques can help you write more declarative code that is easier tounderstand at a glance, refactor, and test.

One of the cornerstones of functional programming is its special useof lists and list operations. And those things are exactly what thesound like they are: arrays of things, and the stuff you do to them.But the functional mindset treats them a bit differently than youmight expect.

This article will take a close look at what I like to call the "bigthree" list operations: map, filter, and reduce. Wrapping your headaround these three functions is an important step towards being ableto write clean functional code, and opens the doors to the vastlypowerful techniques of functional and reactive programming.

It also means you'll never have to write a for loop again.

Read more>>here:

There is a way to do it where you have very little implicit scope in your loop and do away with extra variables.

var i = 0,     item;// Note this is weak to sparse arrays or falsey valuesfor ( ; item = myStringArray[i++] ; ){    item; // This is the string at the index.}

Or if you really want to get the id and have a really classicalfor loop:

var i = 0,    len = myStringArray.length; // Cache the lengthfor ( ; i < len ; i++ ){    myStringArray[i]; // Don't use this if you plan on changing the length of the array}

Modern browsers all support iterator methodsforEach,map,reduce,filter and a host of other methods on theArray prototype.

There are various way to loop through array in JavaScript.

Generic loop:

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

ES5's 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)});

Have a lookthis for detailed information or you can also checkMDN for looping through an array in JavaScript & using jQuery checkjQuery for each.

Array loop:

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

Object loop:

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

I would thoroughly recommend making use of theUnderscore.js library. It provides you with various functions that you can use to iterate over arrays/collections.

For instance:

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

If anybody is interested in the performance side of the multiple mechanisms available for Array iterations, I've prepared the following JSPerf tests:

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

Results:

The traditionalfor() iterator, is by far the fastest method, especially when used with thearray length cached.

let arr = [1,2,3,4,5];for(let i=0, size=arr.length; i<size; i++){    // Do something}

TheArray.prototype.forEach() and theArray.prototype.map() methods are the slowest approximations, probably as a consequence of thefunction call overhead.

If you're using the jQuery library, consider usinghttp://api.jquery.com/jQuery.each/

From the documentation:

jQuery.each( collection, callback(indexInArray, valueOfElement) )

Returns:Object

Description:A generic iterator function, which can be used to seamlessly iterate over both objects and arrays. Arrays and array-like objects with a length property (such as a function's arguments object) are iterated by numeric index, from 0 to length-1. Other objects are iterated via their named properties.

The$.each() function is not the same as$(selector).each(), which is used to iterate, exclusively, over a jQuery object. The$.each() function can be used to iterate over any collection, whether it is a map (JavaScript object) or an array. In the case of an array, the callback is passed an array index and a corresponding array value each time. (The value can also be accessed through thethis keyword, but Javascript will always wrap thethis value as anObject even if it is a simple string or number value.) The method returns its first argument, the object that was iterated.

I did not yet see this variation, which I personally like the best:

Given an array:

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

You can loop over it without ever accessing the length property:

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

See this JsFiddle demonstrating that:http://jsfiddle.net/prvzk/

This only works for arrays that arenot sparse. Meaning that there actually is a value at each index in the array. However, I found that in practice I hardly ever use sparse arrays in JavaScript... In such cases it's usually a lot easier to use an object as a map/hashtable. If you do have a sparse array, and want to loop over 0 .. length-1, you need the for (var i=0; i<someArray.length; ++i) construct, but you still need anif inside the loop to check whether the element at the current index is actually defined.

Also, as CMS mentions in a comment below, you can only use this on arrays that don't contain any falsish values. The array of strings from the example works, but if you have empty strings, or numbers that are 0 or NaN, etc. the loop will break off prematurely. Again in practice this is hardly ever a problem for me, but it is something to keep in mind, which makes this a loop to think about before you use it... That may disqualify it for some people :)

What I like about this loop is:

• It's short to write
• No need to access (let alone cache) the length property
• The item to access is automatically defined within the loopbody under the name you pick.
• Combines very naturally with array.push and array.splice to use arrays like lists/stacks

The reason this works is that the array specification mandates that when you read an item from an index >= the array's length, it will return undefined. When you write to such a location it will actually update the length.

For me, this construct most closely emulates the Java 5 syntax that I love:

for (String item : someArray) {}

... with the added benefit of also knowing about the current index inside the loop

There are 4 ways of array iteration:

// 1: forfor (let i = 0; i < arr.length; ++i) {  console.log(arr[i]);}// 2: forEacharr.forEach((v, i) => console.log(v));// 3: for infor (let i in arr) {  console.log(arr[i]);}// 4: for offor (const v of arr) {  console.log(v);}

Summary: 1 and 3 solutions create extra variable, 2 - create extra function context.The best way is 4th - "for of".

Esoteric

let a= ["Hello", "World"];while(a.length) { console.log( a.shift() ); }

Performance test

Today (2022-11-13) I perform a test on Chrome 107, Safari 15.2 and Firefox 106 on chosen solutions.

Conclusions

• solutions C and D are fast or fastest on all browsers for all arrays.
• solution A and B are slowest on all browsers for all arrays

Results

Details

I perform 3 tests:

• small - for 2 elements array (like OP) - you can run ithere
• medium - for 10K elements array and - you can run ithere
• big - for 100K elements array - you can run ithere

The below snippet presents code used in the test.

function A(a) {  let r=0;  while(a.length) r+= a.shift().length;  return r;}function B(a) {  let r=0;  for(i in a) r+= a[i].length;  return r;}function C(a) {  let r=0;  for(x of a) r+= x.length;  return r;}function D(a) {  let r=0;  for (i=0; i<a.length; ++i) r+= a[i].length;  return r;}function E(a) {  let r=0;  a.forEach(x=> r+= x.length);  return r;}let arr= ["Hello", "World!"];[A,B,C,D,E].forEach(f => console.log(`${f.name}: ${f([...arr])}`))

Here are example results for Chrome for a medium array:

There's a method to iterate over only own object properties, not including prototype's ones:

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

but it still will iterate over custom-defined properties.

In JavaScript any custom property could be assigned to any object, including an array.

If one wants to iterate over sparsed array,for (var i = 0; i < array.length; i++) if (i in array) orarray.forEach withes5shim should be used.

The most elegant and fast way

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

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

Edited (because I was wrong)

Comparing methods for looping through an array of 100000 items and do a minimal operation with the new value each time.

• http://jsben.ch/#/BQhED

Preparation:

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

Tests:

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

There are a couple of ways to do it in JavaScript. The first two examples are JavaScript samples. The third one makes use of a JavaScript library, that is, jQuery making use of the.each() function.

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>

The optimized approach is to cache the length of array and using the single variable pattern, initializing all variables with a singlevar keyword.

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

If the order of iteration does not matter then you should try reversed loop. It is the fastest as it reduces overhead condition testing and decrement is in one statement:

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

Or better and cleaner to use awhile loop:

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

In JavaScript, there are so many solutions to loop an array.

The code below are popular ones

/** Declare inputs */const items = ['Hello', 'World']/** Solution 1. Simple for */console.log('solution 1. simple for')for (let i = 0; i < items.length; i++) {  console.log(items[i])}console.log()console.log()/** Solution 2. Simple while */console.log('solution 2. simple while')let i = 0while (i < items.length) {  console.log(items[i++])}console.log()console.log()/** Solution 3. forEach*/console.log('solution 3. forEach')items.forEach(item => {  console.log(item)})console.log()console.log()/** Solution 4. for-of*/console.log('solution 4. for-of')for (const item of items) {  console.log(item)}console.log()console.log()

The best way in my opinion is to use the Array.forEach function. If you cannot use that I would suggest to get the polyfill from MDN. To make it available, it is certainly the safest way to iterate over an array in JavaScript.

Array.prototype.forEach()

So as others has suggested, this is almost always what you want:

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

This ensures that anything you need in the scope of processing the array stays within that scope, and that you are only processing the values of the array, not the object properties and other members, which is whatfor .. in does.

Using a regular C-stylefor loop works in most cases. It is just important to remember that everything within the loop shares its scope with the rest of your program, the { } does not create a new scope.

Hence:

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

will output "11" - which may or may not be what you want.

A working jsFiddle example:https://jsfiddle.net/workingClassHacker/pxpv2dh5/7/

If you want to use jQuery, it has a nice example in its documentation:

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

It's not 100% identical, but similar:

   var myStringArray = ['Hello', 'World']; // The array uses [] not {}    for (var i in myStringArray) {        console.log(i + ' -> ' + myStringArray[i]); // i is the index/key, not the item    }

For example, I used in a Firefox console:

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

You can use querySelectorAll to get same result

document.querySelectorAll('pre').forEach( (e) => {    console.log(e.textContent);})

<pre>text 1</pre><pre>text 2</pre><pre>text 3</pre>

• javascript
• arrays
• loops
• for-loop