Js перебрать все элементы. Массивы: перебирающие методы. Преобразование в настоящий массив
- I. Перебор настоящих массивов
- Метод forEach и родственные методы
- Цикл for
- Правильное использование цикла for...in
- Цикл for...of (неявное использование итератора)
- Явное использование итератора
- II. Перебор массивоподобных объектов
- Использование способов перебора настоящих массивов
- Преобразование в настоящий массив
- Замечание по объектам среды исполнения
На данный момент есть три способа перебора элементов настоящего массива:
Кроме того, в скором времени, с появлением нового стандарта ECMAScript 6 (ES 6), ожидается еще два способа:
Если ваш проект рассчитан на поддержку возможностей стандарта ECMAScript 5 (ES5), вы можете использовать одно из его нововведений - метод forEach .
Пример использования:
Var a = ["a", "b", "c"]; a.forEach(function(entry) { console.log(entry); });
В общем случае использование forEach требует подключения библиотеки эмуляции es5-shim для браузеров, не имеющих нативной поддержки этого метода. К ним относятся IE 8 и более ранние версии, которые до сих пор кое-где еще используются.
К достоинствам forEach относится то, что здесь не нужно объявлять локальные переменные для хранения индекса и значения текущего элемента массива, поскольку они автоматически передаются в функцию обратного вызова (колбек) в качестве аргументов.
Если вас беспокоят возможные затраты на вызов колбека для каждого элемента, не волнуйтесь и прочитайте это .
forEach предназначен для перебора всех элементов массива, но кроме него ES5 предлагает еще несколько полезных методов для перебора всех или некоторых элементов плюс выполнения при этом каких-либо действий с ними:
- every - возвращает true , если для каждого элемента массива колбек возвращает значение приводимое к true .
- some - возвращает true , если хотя бы для одного элемента массива колбек возвращает значение приводимое к true .
- filter - создает новый массив, включающий те элементы исходного массива, для которых колбек возвращает true .
- map - создает новый массив, состоящий из значений возращаемых колбеком.
- reduce - сводит массив к единственному значению, применяя колбек по очереди к каждому элементу массива, начиная с первого (может быть полезен для вычисления суммы элементов массива и других итоговых функций).
- reduceRight - работает аналогично reduce, но перебирает элементы в обратном порядке.
Старый добрый for рулит :
Var a = ["a", "b", "c"]; var index; for (index = 0; index < a.length; ++index) { console.log(a); }
Если длина массива неизменна в течение всего цикла, а сам цикл принадлежит критическому в плане производительности участку кода (что маловероятно), то можно использовать «более оптимальную» версию for с хранением длины массива:
Var a = ["a", "b", "c"]; var index, len; for (index = 0, len = a.length; index < len; ++index) { console.log(a); }
Теоретически этот код должен выполняться чуть быстрее, чем предыдущий.
Если порядок перебора элементов не важен, то можно пойти еще дальше в плане оптимизации и избавиться от переменной для хранения длины массива, изменив порядок перебора на обратный:
Var a = ["a", "b", "c"]; var index; for (index = a.length - 1; index >= 0; --index) { console.log(a); }
Тем не менее, в современных движках JavaScript подобные игры с оптимизацией обычно ничего не значат.
3. Правильное использование цикла for...inЕсли вам посоветуют использовать цикл for...in , помните, что перебор массивов - не то, для чего он предназначен . Вопреки распространенному заблуждению цикл for...in перебирает не индексы массива, а перечислимые свойства объекта.
Тем не менее, в некоторых случаях, таких как перебор разреженных массивов , for...in может оказаться полезным, если только соблюдать при этом меры предосторожности, как показано в примере ниже:
// a - разреженный массив
var a = ;
a = "a";
a = "b";
a = "c";
for (var key in a) {
if (a.hasOwnProperty(key) &&
/^0$|^d*$/.test(key) &&
key < l; a++);
}]
, ["for-loop", () => {
for(var a = 0, l = arr.length; a < l; ++a)
var b = arr[a] + 1;
}]
, ["for-loop++", () => {
for(var a = 0, l = arr.length; a < l; a++)
var b = arr[a] + 1;
}]
, ["for-loop - arr.length", () => {
for(var a = 0; a < arr.length; ++a)
var b = arr[a] + 1;
}]
, ["reverse for-loop", () => {
for(var a = arr.length - 1; a >= 0; --a)
var b = arr[a] + 1;
}]
,["while-loop", () => {
var a = 0, l = arr.length;
while(a < l) {
var b = arr[a] + 1;
++a;
}
}]
, ["reverse-do-while-loop", () => {
var a = arr.length - 1; // CAREFUL
do {
var b = arr[a] + 1;
} while(a--);
}]
, ["forEach", () => {
arr.forEach(a => {
var b = a + 1;
});
}]
, ["for..in (only 3.3%)", () => {
var ar = arr.slice(0,arr.length/33);
for(const a in ar) {
var b = a + 1;
}
}]
, ["Duff device", () => {
var i = 0;
var r = arr.length % 8;
var n = (arr.length - r) / 8;
if (r > 0) do {
var b = arr + 1;
}
while (--r);
if (n > 0) do {
var b = arr[i] + 1;
var c = arr + 1;
var d = arr + 1;
var e = arr + 1;
var f = arr + 1;
var g = arr + 1;
var h = arr + 1;
var k = arr + 1;
i = --n >>> 3;
}
while (n);
}]
, ["Duff device negative", () => {
var r = arr.length % 8;
var n = (arr.length-r) / 8; ///Math.floor(arr.length / 8);
var i = arr.length ; // -1;
while(r){
var b = arr[--i] + 1;
--r;
}
while(n){
var b = arr[i] + 1;
var c = arr + 1;
var d = arr + 1;
var e = arr + 1;
var f = arr + 1;
var g = arr + 1;
var h = arr + 1;
var j = arr + 1;
i = --n >>> 3;
}
}]];
function bench(title, f) {
var t0 = performance.now();
var res = f();
return performance.now() - t0; // console.log("${title} took ${t1-t0} msec");
}
var globalVarTime = bench("for-loop without "var"", () => {
// Here if you forget to put "var" so variables"ll be global
for(a = 0, l = arr.length; a < l; ++a)
var b = arr[a] + 1;
});
var times = benches.map(function(a) {
arr = new Array(11111111).fill(255);
return
}).sort((a,b) => a-b);
var max = times;
times = times.map(a => {a = (a/max)*100; return a; });
var template = (title, time, n) =>
"" +
"${title} " +
" ${Number(time.toFixed(3))}msec" +
"";
var strRes = times.map(t => template(...t)).join("\n") +
"
for-loop without "var" ${globalVarTime} msec.";
var $container = document.getElementById("container");
$container.innerHTML = strRes;
body { color:#fff; background:#333; font-family:helvetica; }
body > div > div { clear:both }
body > div > div > span {
float:left;
width:43%;
margin:3px 0;
text-align:right;
}
body > div > div > span:nth-child(2) {
text-align:left;
background:darkorange;
animation:showup .37s .111s;
-webkit-animation:showup .37s .111s;
}
@keyframes showup { from { width:0; } }
@-webkit-keyframes showup { from { width:0; } }
2014 While назад
Подумайте логично.
Посмотрите на это
For(var index = 0 , length = array.length ; index < length ; index++) { //do stuff }
- Необходимо создать не менее 2 переменных (индекс, длина)
- Необходимо проверить, меньше ли указатель длины
- Необходимо увеличить индекс
- цикл for имеет 3 параметра
Теперь скажите мне, почему это должно быть быстрее, чем:
Var length = array.length; while(--length) { //or length-- //do stuff }
- Одна переменная
- Нет проверок
- индекс уменьшается (машины предпочитают это)
- While имеет только один параметр
Я был полностью сбит с толку, когда Chrome 28 показал, что цикл for работает быстрее, чем время. Это должно быть как-то вроде
"Ну, каждый использует цикл for, пусть фокусируется на этом, когда для хром ".
Но теперь, в 2014 году, цикл while возвращается на хром. он в 2 раза быстрее, в других/старых браузерах он всегда был быстрее.
В последнее время я сделал несколько новых тестов. Теперь в реальном мире envoirement эти короткие коды ничего не стоят, и jsperf не может фактически правильно выполнить цикл while, потому что ему нужно воссоздать array.length, что также требует времени.
НЕ МОЖЕТ получить фактическую скорость цикла while на jsperf.
вам нужно создать свою собственную функцию и проверить, что с помощью window.performance.now()
И да... нет никакого способа, чтобы цикл while был быстрее.
Реальная проблема - это фактическое манипулирование/время воспроизведения/ время рисования или, тем не менее, вы хотите называть его.
Например, у меня есть сцена canvas, где мне нужно вычислить координаты и коллизии... это делается между 10-200 MicroSeconds (не миллисекундами). он фактически принимает различные миллисекунды, чтобы сделать все. Так же, как в DOM.
В некоторых случаях существует еще один суперэффективный способ использования loop ... например, для копирования/клонирования массива
For(var i = array.length ; i > 0 ; arrayCopy[ --i ] = array[ i ] // doing stuff);
Обратите внимание на настройку параметров:
- То же, что и в цикле while. Я использую только одну переменную
- Необходимо проверить, больше ли индекс больше 0;
- Как вы можете видеть, этот подход отличается от обычного для цикла, который каждый использует, поскольку я делаю материал внутри 3-го параметра, а также уменьшаю непосредственно внутри массива.
Сказано, что это подтверждает, что машины, такие как
писал, что я думал, чтобы сделать его немного короче и удалить некоторые бесполезные вещи и написал этот, используя тот же стиль:
For(var i = array.length ; i-- ; arrayCopy[ i ] = array[ i ] // doing stuff);
Даже если это короче, похоже, что использование i еще раз замедляет все. Это на 1/5 медленнее предыдущего цикла for и While .
Примечание: ; очень важно после того, как для looo без {}
Даже если я только что сказал вам, что jsperf - это не лучший способ протестировать скрипты. Я добавил здесь 2 цикла.
И вот еще один ответ о производительности в javascript
Этот ответ должен показать исполнительные способы написания javascript. Поэтому, если вы не можете прочитать это, спросите, и вы получите ответ или прочитаете книгу о javascript http://www.ecma-international.org/ecma-262/5.1/
Последняя ревизия теста, которую я подготовил (путем повторного использования более старого), показывает одну вещь.
Длина кэширования не так важна, но это не вредит.
Каждый первый запуск теста, связанного выше (на недавно открывшейся вкладке), дает наилучшие результаты для последних 4 фрагментов (3-й, 5-й, 7-й и 10-й в диаграммах) в Chrome, Opera и Firefox на моем 64-битном Debian Squeeze (мое настольное оборудование). Последующие прогоны дают совсем другой результат.
Выводы по производительности просты:
- Перейдите в цикл for (вперед) и проверьте с помощью!== вместо < .
- Если вам не нужно повторно использовать массив позже, тогда также эффективен цикл с уменьшенной длиной и деструктивным массивом shift() -ing.
В настоящее время (2011.10) ниже шаблон выглядит как самый быстрый.
For (var i = 0, len = arr.length; i !== len; i++) { ... }
Помните, что кэширование arr.length здесь не имеет решающего значения, поэтому вы можете просто протестировать i !== arr.length , и производительность не снизится, но вы получите более короткий код.
PS: Я знаю, что в фрагменте с shift() его результат можно использовать вместо доступа к 0-му элементу, но я почему-то упускал из виду, что после повторного использования предыдущей ревизии (которая имела неправильное значение во время циклов), а позже я не хотел теряют уже полученные результаты.
"Лучший", как в чистом исполнении? или производительность И ?
Чистая производительность "наилучшая" - это то, что использует кеш и префиксный оператор ++ (мои данные: http://jsperf.com/caching-array-length/189)
For (var i = 0, len = myArray.length; i < len; ++i) { // blah blah }
Я бы сказал, что цикл без кэша - лучший баланс времени выполнения и времени чтения программиста. Каждый программист, начинающийся с C/С++/Java, не будет тратить мс, чтобы прочитать этот
For(var i=0; i < arr.length; i++){ // blah blah }
** кешируйте длину массива внутри цикла, некоторые секунды времени будут ускользать. Зависит от элементов в массиве, если в массиве есть больше элементов, существует большая разница относительно Ms времени *
SArr; //Array; for(var i = 0 ; i = 0) { doSomething(array[i]); }
Если приоритетный порядок важен, используйте этот подход.
Let ii = array.length; let i = 0; while (i < ii) { doSomething(array[i]); ++i; }
Я всегда пишу в первом стиле.
Даже если компилятор достаточно умен, чтобы оптимизировать его для массивов, но все же он умный, если мы используем DOMNodeList здесь или какой-то сложный объект с рассчитанной длиной?
Я знаю, что вопрос о массивах, но я считаю хорошей практикой писать все ваши петли в одном стиле.
Var arr = ; // The array var i = 0; while (i < arr.length) { // Do something with arr[i] i++; }
i ++ быстрее, чем ++ i, --i и я -
- Перевод
- I. Перебор настоящих массивов
- Метод forEach и родственные методы
- Цикл for
- Правильное использование цикла for...in
- Цикл for...of (неявное использование итератора)
- Явное использование итератора
- Использование способов перебора настоящих массивов
- Преобразование в настоящий массив
- Замечание по объектам среды исполнения
Пример использования:
var a = ["a", "b", "c"];
a.forEach(function(entry) {
console.log(entry);
});
В общем случае использование forEach требует подключения библиотеки эмуляции es5-shim для браузеров, не имеющих нативной поддержки этого метода. К ним относятся IE 8 и более ранние версии, которые до сих пор кое-где еще используются.
К достоинствам forEach относится то, что здесь не нужно объявлять локальные переменные для хранения индекса и значения текущего элемента массива, поскольку они автоматически передаются в функцию обратного вызова (колбек) в качестве аргументов.
Если вас беспокоят возможные затраты на вызов колбека для каждого элемента, не волнуйтесь и прочитайте это .
ForEach предназначен для перебора всех элементов массива, но кроме него ES5 предлагает еще несколько полезных методов для перебора всех или некоторых элементов плюс выполнения при этом каких-либо действий с ними:
- every - возвращает true , если для каждого элемента массива колбек возвращает значение приводимое к true .
- some - возвращает true , если хотя бы для одного элемента массива колбек возвращает значение приводимое к true .
- filter - создает новый массив, включающий те элементы исходного массива, для которых колбек возвращает true .
- map - создает новый массив, состоящий из значений возращаемых колбеком.
- reduce - сводит массив к единственному значению, применяя колбек по очереди к каждому элементу массива, начиная с первого (может быть полезен для вычисления суммы элементов массива и других итоговых функций).
- reduceRight - работает аналогично reduce, но перебирает элементы в обратном порядке.
Var a = ["a", "b", "c"];
var index;
for (index = 0; index < a.length; ++index) {
console.log(a);
}
Если длина массива неизменна в течение всего цикла, а сам цикл принадлежит критическому в плане производительности участку кода (что маловероятно), то можно использовать «более оптимальную» версию for с хранением длины массива:
Var a = ["a", "b", "c"];
var index, len;
for (index = 0, len = a.length; index < len; ++index) {
console.log(a);
}
Теоретически этот код должен выполняться чуть быстрее, чем предыдущий.
Если порядок перебора элементов не важен, то можно пойти еще дальше в плане оптимизации и избавиться от переменной для хранения длины массива, изменив порядок перебора на обратный:
Var a = ["a", "b", "c"];
var index;
for (index = a.length - 1; index >= 0; --index) {
console.log(a);
}
Тем не менее, в современных движках JavaScript подобные игры с оптимизацией обычно ничего не значат.
Тем не менее, в некоторых случаях, таких как перебор разреженных массивов , for...in может оказаться полезным, если только соблюдать при этом меры предосторожности, как показано в примере ниже:
// a - разреженный массив var a = ; a = "a"; a = "b"; a = "c"; for (var key in a) { if (a.hasOwnProperty(key) && /^0$|^\d*$/.test(key) && key
- HTML
- JavaScript
Рассмотрим способ, с помощью которого можно определить последний индекс (элемент) в методе jQuery each .
// выбираем элементы var myList = $("ul li"); // определяем количество элементом в выборке var total = myList.length; // осуществляем перебор выбранных элементов myList.each(function(index) { if (index === total - 1) { // это последний элемент в выборке } });
12 Мар 2016
В современном JavaScript существуют, так называемые «перебирающие методы», которые применяются для перебора массивов. В этом уроке мы рассмотрим следующие методы:
forEachМетод.forEach() используется для перебора массива. Он вызывает так называемую функцию callback, с помощью которой предаётся три параметра item, i, arr, где:
- item — элемент массива;
- i — порядковый номер массива;
- arr — сам массив который должен перебираться.
Чтобы проще было понять, как использовать данный метод рассмотрим пример:
Var user=["admin","pass",31]; user.forEach(function(item,i,user){ alert("Значение элемента под № " + i + " : " + item); });
Этот метод может использоваться вместо обычного цикла for.
filterМетод.filter() используется для фильтрации, он также использует функцию callback, но создаёт новый массив если элементы в массиве подходят под значение true:
Var arr=; var newArr=arr.filter(function(number){ return number < 0; }); alert(newArr); // выведет -34,-4
В данном примере проверяются числа на отрицательные значения, а на выходе выводится новый массив с этими значениями. Вы можете придумать свои условия, совсем необязательно это должны быть числа.
every/someЭти два метода схожи друг с другом и оба используются для проверки массива, только метод .every() возвращает значение true если все значения в массиве подходят под заданное условие, а метод .some() возвращает true если хотя бы одно значение подходит под условие:
Var arr=; alert(arr.every(function(number){ return number < 0; })); // выведет false
Надеюсь понятно, что если бы в примере выше использовался метод some то у нас бы вывелось значение true, вместо false.
mapМетод.map() трансформирует массив и получает из него новый. Всё делается посредством вызова callback-функции:
Var arr=; var newArr=arr.map(function(number){ return number*2; }); alert(newArr);
В данном примере мы получили новый массив с удвоенными значениями элементов.
reduce/reduceRightПоследние методы, которые мы с вами рассмотрим это reduce и reduceRight. Используются они для обработки каждого элемента массива с сохранением промежуточного результата. Метод перебирает каждый элемент слева на право, reduceRight наоборот. В отличие от других методов кроме функции callback здесь ещё указывается аргумент initialValue — «начальное значение». Плюс ко всему в функции callback указывается «промежуточный результат» — previousValue и currentItem — текущий элемент массива.
Давайте рассмотрим пример:
Function getSums(arr) { var result = ; if (!arr.length) return result; var totalSum = arr.reduceRight(function(sum, item) { result.push(sum); return sum + item; }); result.push(totalSum); return result; } alert(getSums()); // 1,3,6,10,15
Что произошло в данном примере? Мы создали функцию, которая позволяет получить новый массив с элементами, созданными из суммы предыдущих. Причем отчет элементов идет с конца. А вот более простой пример, в котором я создал функцию считающую сумму элементов в массиве:
Function getSum(arr) { var result = arr.reduce(function(sum, current) { return sum + current }); return result; }; alert(getSum()); Метки: