Я просматривал Google Code, когда я оценил этот проект под названием JSpeed - оптимизация для Javascript.
Я заметил, что одна из оптимизаций заключалась в изменении i++ на ++i для операторов цикла.
Перед оптимизацией
for (i=0;i<1;i++) {}
for (var i = 0, j = 0; i < 1000000; i++, j++) {
if (i == 4) {
var tmp = i / 2;
}
if ((i % 2) == 0) {
var tmp = i / 2;
i++;
}
}
var arr = new Array(1000000);
for (i = 0; i < arr.length; i++) {}
После оптимизации
for(var i=0;i<1;++i){}
for(var i=0,j=0;i<1000000;++i,++j){if(i==4){var tmp=i>>1;}
if((i&1)==0){var tmp=i>>1;i++;}}
var arr=new Array(1000000);for(var i=0,arr_len=arr.length;i<arr_len;++i){}
Я знаю, что делают pre и post increments, но любая идея, как это ускоряет код?
Это то, что я прочитал и могу ответить на ваш вопрос: "preincrement (++i) добавляет значение к значению i, а затем возвращает i; напротив, i++ возвращает i, затем добавляет один к нему, что теоретически приводит к созданию временной переменной, сохраняющей значение i до того, как была применена операция приращения".
Это искусственная оптимизация. Насколько я понимаю, вы сохраняете 1 op-код. Если вы хотите оптимизировать свой код с помощью этой техники, то вы пошли не так. Кроме того, большинство компиляторов/переводчиков в любом случае оптимизируют это для вас (ссылка 1). Короче, я бы не волновался. Но, если вы действительно волнуетесь, вы должны использовать i+=1.
Вот быстрый и грязный бенчмарк, который я только что сделал
var MAX = 1000000, t=0,i=0;
t = (new Date()).getTime();
for ( i=0; i<MAX;i++ ) {}
t = (new Date()).getTime() - t;
console.log(t);
t = (new Date()).getTime();
for ( i=0; i<MAX;++i ) {}
t = (new Date()).getTime() - t;
console.log(t);
t = (new Date()).getTime();
for ( i=0; i<MAX;i+=1 ) {}
t = (new Date()).getTime() - t;
console.log(t);
Исходные результаты
Post Pre +=
1071 1073 1060
1065 1048 1051
1070 1065 1060
1090 1070 1060
1070 1063 1068
1066 1060 1064
1053 1063 1054
Удалены самые низкие и самые высокие
Post Pre +=
1071 ---- 1060
1065 ---- ----
1070 1065 1060
---- 1070 1060
1070 1063 ----
1066 1060 1064
---- 1063 1054
Средние
1068.4 1064.2 1059.6
Обратите внимание, что это более миллион итераций, и результаты в среднем равны 9 миллисекундам. Не очень большая оптимизация, учитывая, что большая итеративная обработка в JavaScript выполняется на гораздо меньших наборах (например, контейнеры DOM).
Звучит как преждевременная оптимизация. Когда вы почти закончили свое приложение, проверьте, где находятся узкие места, и оптимизируйте их по мере необходимости. Но если вы хотите получить подробное руководство по производительности контура, проверьте это:
http://blogs.oracle.com/greimer/entry/best_way_to_code_a
Но вы никогда не знаете, когда это станет устаревшим из-за усовершенствований движка JS и изменений между браузерами. Лучший выбор - не беспокоиться об этом, пока это не проблема. Сделайте свой код понятным для чтения.
Изменить: согласно этот парень, pre-vs. post статистически незначителен. (возможно, даже хуже)
Оптимизация не является префиксом по сравнению с post increment. Это использование побитовых операторов "shift" и "and", а не разделение и мода.
Существует также оптимизация минимизации javascript для уменьшения общего размера (но это не оптимизация времени исполнения).
Тест Anatoliy включал пост-инкремент внутри тестовой функции pre-increment: (
Вот результаты без этого побочного эффекта...
function test_post() {
console.time('postIncrement');
var i = 1000000, x = 0;
do x++; while(i--);
console.timeEnd('postIncrement');
}
function test_pre() {
console.time('preIncrement');
var i = 1000000, x = 0;
do ++x; while(--i);
console.timeEnd('preIncrement');
}
test_post();
test_pre();
test_post();
test_pre();
test_post();
test_pre();
test_post();
test_pre();
Выход
postIncrement: 3.21ms
preIncrement: 2.4ms
postIncrement: 3.03ms
preIncrement: 2.3ms
postIncrement: 2.53ms
preIncrement: 1.93ms
postIncrement: 2.54ms
preIncrement: 1.9ms
Это большая разница.
Просто протестировал его в firebug и не нашел разницы между post- и preincrements. Может быть, эта оптимизация других платформ? Вот мой код для тестирования firebug:
function test_post() {
console.time('postIncrement');
var i = 1000000, x = 0;
do x++; while(i--);
console.timeEnd('postIncrement');
}
function test_pre() {
console.time('preIncrement');
var i = 1000000, x = 0;
do ++x; while(i--);
console.timeEnd('preIncrement');
}
test_post();
test_pre();
test_post();
test_pre();
test_post();
test_pre();
test_post();
test_pre();
Выход:
postIncrement: 140ms
preIncrement: 160ms
postIncrement: 136ms
preIncrement: 157ms
postIncrement: 148ms
preIncrement: 137ms
postIncrement: 136ms
preIncrement: 148ms
Это, вероятно, грузо-культовое программирование. Это не должно иметь значения, если вы используете достойные компиляторы/интерпретаторы для языков, которые не имеют произвольной перегрузки оператора.
Эта оптимизация имела смысл для С++, где
T x = ...;
++x
может изменить значение на месте, тогда как
T x = ...;
x++
необходимо создать копию, выполнив что-то под капотом, например
T x = ...;
T copy;
(copy = T(x), ++x, copy)
что может быть дорогостоящим для больших типов структур или для типов, которые выполняют множество вычислений в своем конструкторе `copy.