Какой самый быстрый способ итерации массива в JS?

Question

[NonameMeTrue]

Вопрос в сабже. Тестировал множество вариантов, такие как префиксы, постфиксы, предварительное кэширование длины, Array.prototype.forEach, for..of, for, do, while.

Вроде бы понятно, что префиксы(--i, ++i) быстрее постфиксов(i--, i++), так как не создают темповые переменные, дабы вернуть i без изменений на строке вызова, однако иногда, вне зависимости от кэширования длины и for/while, собственно, последние доказывали обратное.

Когда-то и где-то читал, что лучший пробег - это с конца до начала, используя конструкцию:

for(let i = array.length - 1; i >= 0; --i)

Так ли это на самом деле в нынешние дни и лучше стараться использовать итерацию массива с конца, а если такой возможности нету, то использовать конструкцию:

for(let i = 0; i < array.length; ++i)

Хотелось бы получить надёжно-быстро-стабильный вариант для будущих пробегов по массивам, вне зависимости от уже заранее оптимизированных моментов движком, вроде автоматического изменения i++ на ++i.

Comments

[Alex]

Так а что мешает взять все варианты, тестовый набор данных и провести тесты?

[NonameMeTrue]

Alex, "Тестировал множество вариантов" - сразу же во втором предложении. Логично, что тесты уже проводились, но постоянно показывались различные результаты, о которых говорится дальше. Собственно, отсюда и вопрос - какой вариант самый "надёжно-быстро-стабильный"?

[Alex]

NonameMeTrue, А, извините. Невнимательность

[Дмитрий]

NonameMeTrue, Вы в курсе что js это просто язык, и что его реализация различна в каждом браузере и одинаковый код будет выдавать в разных браузерах разное время в зависимости от реализации? И что браузеры усовершенствуются и разница между методами нивелируется? Если вы спрашиваете ради любопытства - это одно, а если вы всерьез намерены итерировать с конца, то это просто глупо - снизит читабельность кода ради мизерной выгоды в 99 и 9 в периоде случаев.

[Lynn «Кофеман»]

Любой из них в зависимости от того что вы будетк делать в цикле

Answer 1

[Дмитрий]

Вроде бы понятно, что префиксы(--i, ++i) быстрее постфиксов(i--, i++)

В циклах никакой сколь либо ощутимой разницы, если вы проводили действительно тесты, они не могли этого не показать.

Когда-то и где-то читал, что лучший пробег - это с конца до начала, используя конструкцию:

for(let i = array.length - 1; i >= 0; --i)

И что, ваши тесты это подтвердили? Похоже на полную чушь. Какая разница языку отнимать единицу или складывать?

По факту самый быстрый конечно

for(let i = 0; i < array.length; ++i) let value = array[i]

for... of медленнее процентов на 30

forEach медленнее в разы

Точные цифры зависят от реализации в конкретных браузерах и меняются в процессе их развития.

И это совершенно не значит, что везде нужно использовать самый быстрый вариант. Только на суперогромных массивах разница будет реально ощутима.

И есть выражение: "Преждевременная оптимизация - зло". Сначала напишите код, а потом если какие-то его части работают заметно медленно, тогда приступайте к оптимизации. То чем вы занимаетесь - это забивание головы второстепенными вещами.

Comments

[NonameMeTrue]

И что, ваши тесты это подтвердили?

Мои тесты показали абсолютно различные результаты с каждым запуском на ноде. Сперва они показывали превосходство i++ и ++i с/без кэшированием(я) при нескольких параллельно запущенных процессах. После их остановки и максимальном приоритете на задаче с итерацией массива, собственно, были даны более лояльные к i-- и --i результаты, причём именно к тем, в которых отсутствовало кэширование длины. Спустя ещё некоторое время - 10 раз подряд была выдана победа кэшированного i-- .

Похоже на полную чушь. Какая разница языку отнимать единицу или складывать?

Суть в том, чтобы изначально задать i, как длину массива, после чего проверять эту переменную статическим условием. В случае с инкрементом - условие всегда проверяется динамически.

Касательно того, что код будет плохо читаться - всегда можно привыкнуть к этому, ибо никто не запрещал новые нормы

По поводу разницы в скорости - можно генерировать на сервере в зависимости от браузера клиента уже готовый собранный тем же вебпаком код, который будет оптимизирован под каждого так сказать.

Но вообще, хотелось бы выиграть в производительности конкретно в nodejs, что аннулирует другие движки и нацеливается на контекст V8.

[Дмитрий]

NonameMeTrue, "Спустя ещё некоторое время - 10 раз подряд была выдана победа кэшированного i-- ."

Какая победа? Сколько реально выигрыш в милисекундах на итерации 100 000 элементов?

[NonameMeTrue]

Дмитрий, протестировал 2 случая с помощью benchmark.js, а именно итерацию 100к элементов:

const array = new Array(100000).fill().map((_, i) => i);

И реальную задачу с глубоким копированием объектов, где также используется пробег по аргументам с такой конструкцией:

const deepCloneObject = function(mainObject, ...objects) {
    const result = isEmptyObject(mainObject) ? {} : deepCloneObject({}, mainObject);
    cycle {
        const thisObject = objects[i];
        if(!isObject(thisObject)) continue;
        mainFunctional(thisObject, result);
    }
    return result;
}

В 1 случае - победа была явно за for++, причём вне зависимости от кэширования и постфикса/префикса с результатом в 15,500 операций за секунду. for-- же имел отставание приблизительно в 5 тысяч ops/sec. Самые низкие же показатели были у while-- и у модифицированного ответа:

const l = array.length - 1;
for(let i = array.length; i--;) {
const el = array[i];
}

~ 7.5 тысяч, нежели:

const l = array.length - 1;
for(let i = array.length; i > 0;) {
i--;
const el = array[l - i];
}

~ 10 тысяч ops/sec.

Во 2-ом случае же снова победила такая конструкция:

const l = array.length - 1;

for(let i = array.length; i > 0;) {

i--;
const element = array[l - i];
//...

}

Причём, здесь использовался постфикс i--, кэшированная длина, а также предварительный расчёт, дабы использовать указатели по нарастанию, а не убыванию.

Результат - ~ 890к ops/sec, у остальных - ~ 800к.

Если что, версия nodejs, на которой проводились тесты - 12.16.1.

[Дмитрий]

NonameMeTrue, У меня эта конструкция
for(let i = arr.length; i > 0;) sum += arr[--i]
работает на 5-7% медленнее обычного цикла
for (let i = 0; i < arr.length; ++i) sum += arr[i]

проверьте у себя сравнив первую и третью по ссылке, на вторую внимания не обращайте, она дает тот же результат что и первая.
https://jsbench.me/tfkefwjuw2/2

Answer 2

[alexalexes]

Если заостряться в оптимизации скорости циклов, то я js/php придерживаюсь двух правил:
1) Если количество элементов в массиве на протяжении всего цикла не предполагает изменения, то количество элементов лучше посчитать заранее. Так мы избежим обращения к length при каждой итерации, если интерпретатор совсем туп.
2) Если к i-му элементу идет много обращений в течении одного хода цикла, то этот элемент лучше вытащить отдельным указателем на него.
Все остальное - экономия на спичках.

var item_count = array.length; // считаем заранее кол-во
for(var i = 0; i < item_count; i++)
{
  var item = array[i]; // вытаскиваем ссылку на элемент для простоты доступа
  ...
}