Правильно ли проведено тестирование работы функции реверса массива на JavaScript?

Question

[thsiganenko]

Доброго времени суток, уважаемые участники сообщества!

В книге Марейна Хавербека "Выразительный JavaScript" в качестве упражнения предложено написать функцию реверса массива, то есть нужно взять массив и перевернуть его, чтобы элементы, которые были в начале оказались в конце. Есть стандартный метод у массивов .reverse(), который выполняет эту функцию.
Данная задачу уже упоминалась среди вопросов, и был предложен ряд интересных решений.

Для тренировки решил задачу несколькими способами и решил проверить, сколько времени занимает каждый вариант.
Мной было реализовано 4 функции.

Первый вариант с помощью цикла While:

function reversInPlaceWhile(arr) {
    var len = arr.length - 1;
    var i = 0, temp;
    while (i < len - i) {
        temp = arr[i];
        arr[i] = arr[len - i];
        arr[len - i] = temp;
        i++;
    }
    return arr;
}

Второй вариант с помощью цикла For

function reversInPlaceFor(arr) {
    var len = arr.length - 1;
    var temp;
    for (var i = 0, iter = Math.floor(len / 2); i < iter; i++) {
        temp = arr[i];
        arr[i] = arr[len - i];
        arr[len - i] = temp;
    }
    return arr;
}

Вариант третий, с использование стандартного метода:

function reversInPlaceStandart(arr) {
    arr.reverse();
    return arr;
}

Вариант четвертый, с помощью метода splice()
(этот вариант был предложен одним из участников сообщества)

function reversInPlaceSplice(arr) {
    var len = arr.length - 1;
    for (var i = 0; i < len; i++) {
        arr.splice(i, 0, arr.pop());
    }
    return arr;
}

Для целей тестирования создал функцию, генерирующую простой массив нужного размера:

function newArrayLine(count) {
    var arr = [];
    for (var i = 0; i < count; i++) {
        arr[i] = i;
    }
    return arr;
}

И наконец, для целей тестирования, я использовал функцию:

function test(arr, iter, callback) {
    var start = Date.now();
    for (var i = 0; i < iter; i++) {
        callback(arr);
    }
    var end = Date.now();
    return end - start;
}

где arr - это массив, который будет переворачивать
iter - количество раз, которые нужно переворачивать
callback - функция, с помощью которой будем переворачивать массив
Результат я ожидал получить в миллисекундах.

Запуская данную функцию на массиве 10 000 элементов, 100 раз, в браузере Mozilla Firefox, получил следующие результаты:
для функции с циклом while: 1 мс;
для функции с циклом for: 1 мс;
для функции с стандартным методом reverse(): 12 мс;
для функции с методом splice(): 6562 мс;

Запуская данную функцию на массиве 100 000 элементов, 100 раз, в браузере Chome, получил следующие результаты:
для функции с циклом while: 7 мс;
для функции с циклом for: 6 мс;
для функции с стандартным методом reverse(): 25 мс;
для функции с методом splice(): 485163 мс;

Запускал функции несколько раз, результаты примерно одинаковы.
Удивительно то, что встроенный метод работает медленнее, чем реализованные с циклами.

А теперь собственно основной вопрос: правильно ли проведено тестирование, и можно ли считать данные репрезентативными?

И еще один вопрос, нет ли в моем коде, каких-либо ошибок или недочетов, на которые мне следовало бы обратить внимание?

Заранее благодарен тем, кто решил уделить время моему вопросу!

Comments

[copal]

Для нативного реверса не нужно вызывать функцию...

[thsiganenko]

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

[copal]

thsiganenko: Вы не поняли. Нативный медод вызывается так [].reverse(). А когда Вы запихнули его в ещё один метод, то замедлили его работу. Для правильного сравнения, Вам нужно поместить вызов своих методов в ещё одну функцию.
Вы не будите писать вот этот код всякий раз когда Вам потребуется реверс.

var len = arr.length - 1;
    var temp;
    for (var i = 0, iter = Math.floor(len / 2); i < iter; i++) {
        temp = arr[i];
        arr[i] = arr[len - i];
        arr[len - i] = temp;
    }
    return arr;

Для многократного применения Вы поместите код в функцию -

function reversInPlaceWhile(arr) {
    var len = arr.length - 1;
    var i = 0, temp;
    while (i < len - i) {
        temp = arr[i];
        arr[i] = arr[len - i];
        arr[len - i] = temp;
        i++;
    }
    return arr;
}

И теперь чтобы сделать правильное сравнение Вам нужно сделать так -

function noNative(arr) {
    return reversInPlaceWhile(arr);
}

Вот теперь будет честно. А то что есть сейчас это не честно.

[thsiganenko]

copal: Спасибо огромное! Теперь понятно, где была моя ошибка, которая привела к неправильной интерпретации полученных результатов.
В принципе можно создать объект, например reversArrya, и объявить предложенные функции методами, после чего вызывать и их и стандартный метод в цикле. Так по Вашему мнению будет правильнее?
Я честно только начинаю заниматься разработкой и программированием, по этому многие вещи мне не совсем понятны, тем более такие вещи как тестирование скорости работы алгоритмов.
Спасибо еще раз за то, что уделили время и внимание моему вопросу!

[copal]

thsiganenko: честно будет тогда, когда Вы будите вызывать нативный метод правильно.

Answer 1

[Алексей Уколов]

Похоже на правду.

Comments

[thsiganenko]

Спасибо за интересный сервис для тестирования кода!
Пока не владею английским, но если я правильно понимаю, то реверс с использование циклов все же оказывается быстрее встроенного метода.
И верно ли я понял, чтобы запустить тест в разных браузерах, нужно просто зайти по ссылке через различные браузеры и запустить тестирование?

[Алексей Уколов]

thsiganenko: во-первых, я с copal согласен, у вас не совсем честное сравнение.
Во-вторых, да, для тестирования в разных браузерах нужно запустить тест в них (соответственно, чем больше разных людей его запустить, тем надежнее результаты).
В-третьих, jsperf сейчас скорее умирает, чем живет, к сожалению, так что успевайте пользоваться, пока есть возможность.

[thsiganenko]

Спасибо еще раз за то, что уделили время и внимание моему вопросу!
Жаль, что сервис в таком состоянии, а есть еще какие-то инструменты для тестирования кода на JavaScript?

[Алексей Уколов]

Сам jsperf использует benchmarkjs.com
P.S. Не стоит путать тестирование и профилирование.

[thsiganenko]

То есть, то что я сейчас делаю - это профилирование? То есть измерение времени работы алгоритма. А тестирование, это проверка правильности работы алгоритма?

[Алексей Уколов]

thsiganenko: да, верно.

Answer 2

[thsiganenko]

copal А если таким образом. Хотя меня что-то сильно смущает такой подход, но все же спрошу.

Создаем объект reversArray и у него три метода с различными реализациями реверса массива.
Далее вызываем с помощью кода:

function testOne() {
    var start = Date.now();
    reversArray.reversInPlaceWhile(newArrayLine(100000));
    var end = Date.now();
    return end - start;
}

А для нативной функции используем следующий код:

function testTwo() {
    var start = Date.now();
    newArrayLine(100000).reverse();
    var end = Date.now();
    return end - start;
}

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

Comments

[copal]

вот так должно быть и не иначе -

function reversInPlaceWhile(arr) {
    var len = arr.length - 1;
    var i = 0, temp;
    while (i < len - i) {
        temp = arr[i];
        arr[i] = arr[len - i];
        arr[len - i] = temp;
        i++;
    }
    return arr;
}

function testA(arr) {
    var start = Date.now();
    for (var i = 0; i < 1000000; i++) {
        reversInPlaceWhile(arr);
    }
    var end = Date.now();
    return end - start;


function testB(arr) {
    var start = Date.now();
    for (var i = 0; i < 1000000; i++) {
        arr.recerce();
    }
    var end = Date.now();
    return end - start;
}

[thsiganenko]

copal: Спасибо! Попробовал предложенный код для тестирования. Все равно нативный метод проигрывает по скорости, только непонятно почему... Я ожидал, что нативные методы быстрее.