Как я могу перебрать все записи в массиве с помощью JavaScript?
Я думал, что это что-то вроде этого:
forEach(instance in theArray)
где theArray
- мой массив, но это, похоже, неверно.
TL;DR
Не используйте for-in
, если вы не используете его с мерами предосторожности или хотя бы не знаете, почему он может вас укусить.
Обычно вашими лучшими вариантами являются.
цикл for-of
(только ES2015+),
Array#forEach
([spec
][1] | [MDN
][2]) (или его родственники some
и подобные) (только ES5+),
простой старомодный цикл for
,
или for-in
с мерами предосторожности.
Но есть еще много интересного, читайте дальше...
JavaScript имеет мощную семантику для циклов по массивам и массивоподобным объектам. Я разделил ответ на две части: Варианты для настоящих массивов, и варианты для вещей, которые просто похожи на массивы*, такие как объект arguments
, другие итерируемые объекты (ES2015+), коллекции DOM и так далее.
Я быстро отмечу, что вы можете использовать опции ES2015 сейчас, даже на движках ES5, путем транспиляции ES2015 в ES5. Поищите "ES2015 transpiling" / "ES6 transpiling", чтобы узнать больше...
Итак, давайте посмотрим на наши возможности:
У вас есть три варианта в [ECMAScript 5][3] ("ES5"), наиболее широко поддерживаемой на данный момент версии, и еще два, добавленные в [ECMAScript 2015][4] ("ES2015", "ES6"):
forEach
и связанные с ним (ES5+)for
.for-in
корректно.for-of
(неявное использование итератора) (ES2015+)Подробности:
forEach
и связанные с нимВ любой смутно современной среде (не IE8), где у вас есть доступ к функциям Array
, добавленным в ES5 (напрямую или с помощью полифиллов), вы можете использовать forEach
([spec
][1] | [MDN
][2]):
var a = ["a", "b", "c"];
a.forEach(function(entry) {
console.log(entry);
});
forEach
принимает функцию обратного вызова и, опционально, значение для использования в качестве this
при вызове этого обратного вызова (выше не использовалось). Обратный вызов вызывается для каждой записи в массиве по порядку, пропуская несуществующие записи в разреженных массивах. Хотя выше я использовал только один аргумент, обратный вызов вызывается с тремя: Значение каждой записи, индекс этой записи и ссылка на массив, над которым вы выполняете итерацию (на случай, если ваша функция еще не имеет его под рукой).
Если вы не поддерживаете устаревшие браузеры вроде IE8 (доля рынка которого, по данным NetApps, составляет чуть более 4% на момент написания этой статьи в сентябре 2016), вы можете смело использовать forEach
в веб-странице общего назначения без shim. Если вам необходимо поддерживать устаревшие браузеры, то шимминг/полифиллинг forEach
легко сделать (найдите несколько вариантов по запросу "es5 shim").
Преимущество forEach
в том, что вам не нужно объявлять переменные индексации и значения в содержащей области видимости, так как они предоставляются в качестве аргументов функции итерации, и, таким образом, их можно отнести только к этой итерации.
Если вас беспокоят затраты времени выполнения на вызов функции для каждого элемента массива, не беспокойтесь; details.
Кроме того, forEach
- это функция "перебрать их все", но в ES5 определено несколько других полезных функций "пройтись по массиву и сделать что-то", включая:
every
][5] (останавливает цикл в первый раз, когда обратный вызов возвращает false
или что-то ложное)some
][6] (останавливает цикл, когда обратный вызов возвращает true
или что-то правдивое)filter
][7] (создает новый массив, включая элементы, для которых функция фильтрации возвращает true
и опуская те, для которых она возвращает false
)map
][8] (создает новый массив из значений, возвращенных обратным вызовом)reduce
][9] (создает значение путем многократного вызова обратного вызова, передавая предыдущие значения; подробности см. в спецификации; полезно для суммирования содержимого массива и многих других вещей)reduceRight
][10] (подобно reduce
, но работает по убыванию, а не по возрастанию)for
.Иногда старые способы оказываются лучшими:
var index;
var a = ["a", "b", "c"];
for (index = 0; index < a.length; ++index) {
console.log(a[index]);
}
Если длина массива не будет меняться во время цикла, и он находится в чувствительном к производительности коде (маловероятно), то немного более сложный вариант с захватом длины заранее может быть маленьким немного быстрее:
var index, len;
var a = ["a", "b", "c"];
for (index = 0, len = a.length; index < len; ++index) {
console.log(a[index]);
}
И/или отсчитывая назад:
var index;
var a = ["a", "b", "c"];
for (index = a.length - 1; index >= 0; --index) {
console.log(a[index]);
}
Но в современных движках JavaScript редко возникает необходимость выжимать последний кусочек сока.
В ES2015 и выше вы можете сделать переменные index и value локальными для цикла for
:
let a = ["a", "b", "c"];
for (let index = 0; index < a.length; ++index) {
let value = a[index];
console.log(index, value);
}
//console.log(index); // would cause "ReferenceError: index is not defined"
//console.log(value); // would cause "ReferenceError: value is not defined"
let a = ["a", "b", "c"];
for (let index = 0; index < a.length; ++index) {
let value = a[index];
console.log(index, value);
}
try {
console.log(index);
} catch (e) {
console.error(e); // "ReferenceError: index is not defined"
}
try {
console.log(value);
} catch (e) {
console.error(e); // "ReferenceError: value is not defined"
}
И когда вы это делаете, не только value
, но и index
создается заново для каждой итерации цикла, то есть закрытия, созданные в теле цикла, хранят ссылку на index
(и value
), созданные для этой конкретной итерации:
let divs = document.querySelectorAll("div");
for (let index = 0; index < divs.length; ++index) {
divs[index].addEventListener('click', e => {
console.log("Index is: " + index);
});
}
let divs = document.querySelectorAll("div");
for (let index = 0; index < divs.length; ++index) {
divs[index].addEventListener('click', e => {
console.log("Index is: " + index);
});
}
<div>zero</div>
<div>one</div>
<div>two</div>
<div>three</div>
<div>four</div>
Если бы у вас было пять div'ов, вы бы получили "Index is: 0", если бы вы щелкнули на первом, и "Index is: 4", если вы нажмете на последний. Это **не работает, если вы используете var
вместо let
.
for-in
корректно.Вам будут говорить, что нужно использовать for-in
, но [это не то, для чего нужен for-in
][11]. for-in
перебирает перечисляемые свойства объекта, а не индексы массива. Порядок не гарантирован, даже в ES2015 (ES6). ES2015+ определяет порядок для свойств объекта (через [`[
Примечание: Этот ответ безнадежно устарел. Для более современного подхода посмотрите методы, доступные для массива. Интерес могут представлять следующие методы:
Стандартный способ итерации массива в JavaScript - это обычный цикл for
:
var length = arr.length,
element = null;
for (var i = 0; i < length; i++) {
element = arr[i];
// Do something with element
}
Обратите внимание, однако, что этот подход хорош только в том случае, если у вас плотный массив, и каждый индекс занят элементом. Если массив разреженный, то при таком подходе могут возникнуть проблемы с производительностью, так как вы будете перебирать множество индексов, которые не действительно существуют в массиве. В этом случае лучше использовать цикл for ... in
. Однако, вы должны использовать соответствующие меры предосторожности, чтобы гарантировать, что будут обработаны только нужные свойства массива (то есть элементы массива), поскольку цикл for...in
будет также перечисляться в устаревших браузерах, или если дополнительные свойства определены как перечислимые
.
В ECMAScript 5 появится метод forEach для прототипа массива, но он не поддерживается в устаревших браузерах. Поэтому, чтобы иметь возможность использовать его последовательно, вы должны либо иметь среду, которая поддерживает его (например, Node.js для серверной части JavaScript), либо использовать "Polyfill". Полифилл для этой функциональности, однако, тривиален, и поскольку он делает код более легким для чтения, это хороший полифилл для включения.
Если вы используете библиотеку jQuery, вы можете использовать jQuery.each:
$.each(yourArray, function(index, value) {
// do your stuff here
});
EDIT :
Согласно вопросу, пользователь хочет получить код на javascript, а не на jquery, поэтому редактирование будет следующим
var length = yourArray.length;
for (var i = 0; i < length; i++) {
// Do something with yourArray[i].
}
Я думаю, что реверс петля заслуживает упоминания здесь:
for (var i = array.length; i--; ) {
// process array[i]
}
Преимущества##:
лен
переменная, или сравнить с `массива.длина на каждой итерации, каждая из которых может быть минуту оптимизации. Для ... из
. Некоторые разработчики используют обратный цикл по умолчанию, если есть хорошая причина, чтобы петли вперед. Хотя прирост производительности, как правило, незначительна, он как бы кричит:
"просто сделать это для каждого элемента в списке, я не'т заботиться о порядке!&и" Однако на практике это не на самом деле надежным свидетельством о намерениях, так как он ничем не отличается от тех случаев, когда вы ли забота о порядке, и действительно нужно чтобы петли в обратном порядке. Так ведь еще построить бы точно выразить, что "Дон'т волнует, что" намерения, то в настоящее время недоступны в большинстве языков, в том числе в ECMAScript, но который можно было бы назвать, например,
forEachUnordered()
. Если заказ не'т материи, и эффективность забота (в самый внутренний цикл игры или анимации двигателя), то это может быть приемлемо использовать обратный цикл for, как ваш шаблон. Просто помните, что наблюдаем обратный цикл в существующий код не означает, что порядок не имеет значения!Лучше использовать foreach()
В целом на более высокий уровень код где чистота и безопасность больше проблем, я ранее рекомендовал использовать
Array::forEach
по умолчанию шаблон для циклов (хотя в эти дни я предпочитаю использовать для..О). Причины предпочитать
объекту` за обратной петли:
за
и время
петель). Существует спор о том, `ПО.. " или " еогеасп () являются предпочтительными:
ждут
не работает внутри оператора foreach(). Используя для..ООО
- это ярчайший шаблон в этом случае.
Лично я предпочитаю использовать все, что может быть легче читать, если производительность или минификации стало серьезной проблемой. Поэтому в эти дни я предпочитаю использовать для..В "вместо" оператора foreach(), но я всегда буду использовать "карта" или "фильтр" или [
поиск](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) или [
некоторые](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some) когда это применимо. (Ради моих коллег, я редко пользуюсь [
reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce).) for (var i = 0; i < array.length; i++) { ... } // Forwards
for (var i = array.length; i--; ) { ... } // Reverse
Вы заметите, что я ...
- средняя пункт (где мы обычно видим сравнение) и последний пункт пустым (там где мы обычно видим я++
). Это означает, что я -
также используется в качестве состояние для продолжения. Самое главное, он будет выполнен и проверен до на каждой итерации.
я -
работает до на каждой итерации, на первой итерации у нас будет доступа к элементу в массиве.длина - 1, который позволяет избежать проблем с <удар>массив-в ауте</удара>
неопределенные` элементов. я -
вычисляет значение falsey (когда он дает 0).
Фишка в том, что в отличие от - я
в конце я -
декремента оператор "я", но дает значение до декремент. Ваша консоль может продемонстрировать это:
в > ВАР я = 5; [я, я, я];
[5, 5, 4]
Так на последней итерации, я был ранее 1 и я -
выражение изменения его 0 но на самом деле дает 1 (истина), и поэтому состояние проходит. На следующей итерации я -
изменения I к -1 но дает 0 (falsey), в результате выполнения сразу выпадет из нижней части петли.
В традиционном вперед на петлю, - я++ " и " ++явзаимозаменяемы (как Дуглас Крокфорд указывает). Однако в обратном цикле for, потому что наши декремента тоже наше выражение условие, мы должны придерживаться
я - ` если мы хотим обрабатывать элемент по индексу 0. Некоторые люди любят, чтобы нарисовать небольшую стрелку в обратном для
петли, и в конце с подмигиванием:
for (var i = array.length; i --> 0 ;) {
Кредиты перейти к Вейль показал мне преимущества и ужасов обратного цикла.
Некоторые с-в стиле языков использование оператора foreach для перебора перечисления. В JavaScript это делается с помощью Для..в структуре цикл:
var index,
value;
for (index in obj) {
value = obj[index];
}
Есть одна загвоздка. на..В` будет цикл через каждый из объектов'членов перечисли, и членов его прототип. Чтобы избежать чтения ценности, которые наследуются через объект'ы прототипа, просто проверить, если имущество принадлежит объект:
for (i in obj) {
if (obj.hasOwnProperty(i)) {
//do stuff
}
}
Кроме того, в ECMAScript 5 добавил объекту
метод в `массиве.прототип, который может быть использован для перечисления массив, используя calback (полифилл-это в Docs, так вы все еще можете использовать его для старых браузеров):
arr.forEach(function (val, index, theArray) {
//do stuff
});
Это's важно отметить, что массива.прототип.команда foreach
не'т сломать, когда обратного вызова возвращает false. в jQuery и Underscore.js представить свои вариации на каждый
, чтобы обеспечить петли, что может быть короткое замыкание.
Если вы хотите, чтобы цикл через массив, используйте стандартный трех частей для
петли.
for (var i = 0; i < myArray.length; i++) {
var arrayItem = myArray[i];
}
Вы можете получить некоторую оптимизацию производительности за счет кэширования `с myarray.длина или перебором его назад.
Я знаю, это старый пост, а тут столько уже ответов. Для немного больше полноты я решил, что я'd и еще один через Автор. Конечно, это относится только если вы're, используя угловые, очевидно, тем не менее, я'd, как, чтобы так или иначе поставить.
угловые.оператора foreach
принимает 2 аргументов и третий необязательный аргумент. Первым аргументом является объект (массив), чтобы выполнить итерации, второй аргумент функции итератора, и необязательный третий аргумент-это контекст объекта (в основном, ссылался на внутри цикла, Как 'Это'.
Существуют различные способы, чтобы использовать цикл foreach углового. Самый простой и, вероятно, наиболее часто используемый
var temp = [1, 2, 3];
angular.forEach(temp, function(item) {
//item will be each element in the array
//do something
});
Еще один способ, который пригодится для копирования элементов из одного массива в другой
var temp = [1, 2, 3];
var temp2 = [];
angular.forEach(temp, function(item) {
this.push(item); //"this" refers to the array passed into the optional third parameter so, in this case, temp2.
}, temp2);
Хотя, вы не'т придется сделать это, вы можете просто выполните следующие действия, и это'ы эквивалентен предыдущему примеру:
angular.forEach(temp, function(item) {
temp2.push(item);
});
Сейчас есть плюсы и минусы использования угловой.функцию foreachв отличие от встроенной ванильное
для` петли.
Плюсы
Рассмотрим следующие 2 вложенные циклы, которые поступают точно так же. Позвольте'ы сказать, что у нас есть 2 массивы объектов, и каждый объект содержит массив результатов, каждый из которых имеет свойство value, которое's в строку (или как там). И пусть'ы сказать, что мы должны перебрать все результаты и если они'вновь равны, то выполнить какое-либо действие:
angular.forEach(obj1.results, function(result1) {
angular.forEach(obj2.results, function(result2) {
if (result1.Value === result2.Value) {
//do something
}
});
});
//exact same with a for loop
for (var i = 0; i < obj1.results.length; i++) {
for (var j = 0; j < obj2.results.length; j++) {
if (obj1.results[i].Value === obj2.results[j].Value) {
//do something
}
}
}
Конечно это очень простой гипотетический пример, но я'вэ написано тройные встроенные в петли, используя второй подход, и это было очень трудно читать, и писать по этому вопросу.
Минусы
угловой.по каждому элементу, а родной
объекту, как, впрочем, и *столько* медленнее, чем обычный цикл
for....о [90% медленнее][2]. Поэтому для больших наборов данных, лучше придерживаться родной
для` петли.продолжить
на самом деле поддерживается на "Аварии" и продолжать в себя угловые.по каждому элементувы просто положить
возвращение;заявление в функцию как
угловой.оператор foreach(массив, функция(элемент) { если (someConditionIsTrue) Возвращение; });что будет способствовать ее продолжения функции на данной итерации. Это также связано с тем, что родной
объекту` не поддерживает break или continue либо.Я'м уверен, что там's различные другие плюсы и минусы, а также, и, пожалуйста, не стесняйтесь добавлять любые, которые вы считаете нужным. Я чувствую, что, в итоге, если вам нужна эффективность, придерживаться только родной для
петли для вашего цикла должен. Но, если данные меньше, и какое КПД это нормально, чтобы сдаться в обмен на возможность чтения и записи, то все средства бросить для себя угловой.по каждому элементу в этом плохого мальчика.
А цикл foreach реализация ([видеть в jsFiddle][1]):
function forEach(list,callback) {
var length = list.length;
for (var n = 0; n < length; n++) {
callback.call(list[n]);
}
}
var myArray = ['hello','world'];
forEach(
myArray,
function(){
alert(this); // do something
}
);
Если вы Don'т ум опорожнения массива:
var x;
while(x = y.pop()){
alert(x); //do something
}
х
будет содержать последнее значение Y
и он будет удален из массива. Вы также можете использовать сдвиг ()
, который даст и удалить первый элемент из г
.
Теперь простым решением будет использовать библиотека underscore.js . Это'ы, предоставляя множество полезных инструментов, таких как друг
и автоматически делегировать работу в родной объекту
, если он доступен.
А сайт CodePen Пример как это работает:
var arr = ["elemA", "elemB", "elemC"];
_.each(arr, function(elem, index, ar)
{
...
});
.прототип.по каждому элементу()
.Существует три реализации объекту
в в jQuery следующим образом.
var a = [3,2];
$(a).each(function(){console.log(this.valueOf())}); //Method 1
$.each(a, function(){console.log(this.valueOf())}); //Method 2
$.each($(a), function(){console.log(this.valueOf())}); //Method 3
Начиная с версии ECMAScript&ампер;усилитель; nbsp;6:
в
list = [0, 1, 2, 3]
for (let obj of list) {
console.log(obj)
}
в
Где в
избегает странности, связанные с " В " и заставляет его работать как в для
петли любого другого языка, и да
связывает я
внутри цикла в отличие от внутри функции.
Фигурные скобки ({}
) может быть опущен, когда есть только одна команда (например, в приведенном выше примере).
Наверное, для(Я = 0; Я &л; массив.длина; я++)` цикл-это не лучший выбор. Почему? Если у вас есть это:
var array = new Array();
array[1] = "Hello";
array[7] = "World";
array[11] = "!";
Метод вызова из массива[0]в
массив[2]`. Во-первых, это первая ссылка переменных, которые вы не'т даже, во-вторых вы бы не переменные в массив, и третий это сделает смелее код. Посмотрите здесь, это's я использую:
for(var i in array){
var el = array[i];
//If you want 'i' to be INT just put parseInt(i)
//Do something with el
}
И если вы хотите его функция, вы можете сделать это:
function foreach(array, call){
for(var i in array){
call(array[i]);
}
}
Если вы хотите, чтобы сломать, немного больше логики:
function foreach(array, call){
for(var i in array){
if(call(array[i]) == false){
break;
}
}
}
Пример:
foreach(array, function(el){
if(el != "!"){
console.log(el);
} else {
console.log(el+"!!");
}
});
Он возвращает:
//Hello
//World
//!!!
Там isn'т для каждого
петля в родной на JavaScript. Вы можете либо использовать библиотеки, чтобы получить эту функциональность (я рекомендую Underscore.js), использовать простой Для
в петле.
for (var instance in objects) {
...
}
Однако, обратите внимание, что могут быть причины, чтобы использовать еще проще для
петли (см. переполнение стека вопрос Почему через “Для...в” с блоком итерации такая плохая идея?)
var instance;
for (var i=0; i < objects.length; i++) {
var instance = objects[i];
...
}
Это итератор для неразреженный список, где индекс начинается с 0, который обычно используется при работе с документом.метод getelementsbytagname или документ.querySelectorAll)
function each( fn, data ) {
if(typeof fn == 'string')
eval('fn = function(data, i){' + fn + '}');
for(var i=0, L=this.length; i < L; i++)
fn.call( this[i], data, i );
return this;
}
Array.prototype.each = each;
Примеры использования:
Пример #1
var arr = [];
[1, 2, 3].each( function(a){ a.push( this * this}, arr);
arr = [1, 4, 9]
Пример № 2
each.call(document.getElementsByTagName('p'), "this.className = data;",'blue');
Каждый тег p получает значение Class=на"синий"
в
Пример #3
each.call(document.getElementsByTagName('p'),
"if( i % 2 == 0) this.className = data;",
'red'
);
Любой другой тег p получает значение class="красным"
в>
Пример #4
each.call(document.querySelectorAll('p.blue'),
function(newClass, i) {
if( i < 20 )
this.className = newClass;
}, 'green'
);
И, наконец, первые 20 Теги синий P меняется на зеленый
Осторожность при использовании string в качестве функции: функция создается вне контекста и должны быть использованы только там, где вы определенной области видимости переменной. В противном случае, лучше передать функции, где аналитическом исследовании является более интуитивным.
Есть несколькими способами для перебора массива в JavaScript, как показано ниже:
для - это'ы наиболее распространенным. Полный блок кода для зацикливания <БР/>
в
var languages = ["Java", "JavaScript", "C#", "Python"];
var i, len, text;
for (i = 0, len = languages.length, text = ""; i < len; i++) {
text += languages[i] + "<br>";
}
document.getElementById("example").innerHTML = text;
<p id="example"></p>
в
при - цикл, пока условие до конца. Это, кажется, самый быстрый цикл <БР/>
в
var text = "";
var i = 0;
while (i < 10) {
text += i + ") something<br>";
i++;
}
document.getElementById("example").innerHTML = text;
<p id="example"></p>
в
С/а - тоже петля через блок кода, пока условие имеет значение true, будет выполняться как минимум один раз <БР/>
в
var text = ""
var i = 0;
do {
text += i + ") something <br>";
i++;
}
while (i < 10);
document.getElementById("example").innerHTML = text;
<p id="example"></p>
в
Функциональные петли - объекту
, карта
, фильтр
, и уменьшить
(они петли через функции, но они используются, если нужно что-то делать с массивом и т. д.
в
// For example, in this case we loop through the number and double them up using the map function
var numbers = [65, 44, 12, 4];
document.getElementById("example").innerHTML = numbers.map(function(num){return num * 2});
<p id="example"></p>
в
Для получения дополнительной информации и примеров о функциональном программировании на массивах, смотрите на блоге [функциональное программирование в JavaScript: карта, фильтра и уменьшить][1].
[1]: http://cryto.net/~joepie91/блог/2015/05/04/функционального программирования в JavaScript на карте-фильтр-уменьшить/
В ECMAScript&ампер;усилитель; nbsp;5 (версия на JavaScript) для работы с массивами:
цикл foreach - перебирает каждый элемент в массиве и делать все, что вам нужно с каждым элементом.
['C', 'D', 'E'].forEach(function(element, index) {
console.log(element + " is #" + (index+1) + " in the musical scale");
});
// Output
// C is the #1 in musical scale
// D is the #2 in musical scale
// E is the #3 in musical scale
В случае более заинтересованы о работе на массив, используя некоторые встроенные функции.
карта - он создает новый массив с результатом функции обратного вызова. Этот способ хорош, чтобы использоваться, когда вам нужно отформатировать элементы массива.
// Let's upper case the items in the array
['bob', 'joe', 'jen'].map(function(elem) {
return elem.toUpperCase();
});
// Output: ['BOB', 'JOE', 'JEN']
сокращения - как говорит название, это уменьшает массива в одно значение путем вызова данной функции пропускания в текущий элемент и результат предыдущего выполнения.
[1,2,3,4].reduce(function(previous, current) {
return previous + current;
});
// Output: 10
// 1st iteration: previous=1, current=2 => result=3
// 2nd iteration: previous=3, current=3 => result=6
// 3rd iteration: previous=6, current=4 => result=10
каждый - возвращает true или false, если все элементы в массиве пройти тест в функции обратного вызова.
// Check if everybody has 18 years old of more.
var ages = [30, 43, 18, 5];
ages.every(function(elem) {
return elem >= 18;
});
// Output: false
фильтр - очень похож на каждого за исключением того, что фильтр возвращает массив с элементами, которые возвращают true для данной функции.
// Finding the even numbers
[1,2,3,4,5,6].filter(function(elem){
return (elem % 2 == 0)
});
// Output: [2,4,6]
Там's нет встроенный возможность прорваться в объекту
. Чтобы прервать выполнение использовать массив#некоторые`, как показано ниже:
[1,2,3].some(function(number) {
return number === 1;
});
Это работает, потому что некоторые
возвращает true, как только любая из этих обратных вызовов, выполненных с целью выбора, возвращает true, короткого замыкания исполнением остальных.
Оригинальный Ответ
увидеть прототип массива для некоторых
Я также хотел бы добавить в состав обратной петли и ответ выше для тех, у кого тоже такой синтаксис.
var foo = [object,object,object];
for (var i = foo.length, item; item = foo[--i];) {
console.log(item);
}
Плюсы:
Благо для этого: у Вас ссылка уже в первом нравится, что выиграл'т должны быть объявлены позже с другой линии. Это удобно, когда цикл через массив объектов.
Минусы:
Это будет перерыв, когда ссылка является ложной - falsey (неопределенных и т. д.). Это может быть использовано как преимущество. Однако, это сделало бы его немного тяжелее, чтобы читать. А также в зависимости от браузера он может быть "не то" оптимизирован, чтобы работать быстрее, чем оригинал.