Який найефективніший спосіб створити масив довільної довжини, заповненої нулем у JavaScript?

ES6 вводить Array.prototype.fill. Його можна використовувати так:

new Array(len).fill(0);

Не впевнений, чи швидко це, але мені це подобається, оскільки він короткий і самоописується.

Це все ще не в IE ( перевірити сумісність ), але є поліфіл .

Хоча це стара тема, я хотів додати до неї свої 2 центи. Не впевнений, наскільки це повільно / швидко, але це швидкий один лайнер. Ось що я роблю:

Якщо я хочу заздалегідь заповнити номер:

Array.apply(null, Array(5)).map(Number.prototype.valueOf,0);
// [0, 0, 0, 0, 0]

Якщо я хочу попередньо заповнити рядок:

Array.apply(null, Array(3)).map(String.prototype.valueOf,"hi")
// ["hi", "hi", "hi"]

Інші відповіді пропонують:

new Array(5+1).join('0').split('')
// ["0", "0", "0", "0", "0"]

але якщо ви хочете 0 (число), а не "0" (нуль всередині рядка), ви можете зробити:

new Array(5+1).join('0').split('').map(parseFloat)
// [0, 0, 0, 0, 0]

Елегантний спосіб заповнити масив заздалегідь обчисленими значеннями

Ось ще один спосіб зробити це за допомогою ES6, про який поки ніхто не згадував:

> Array.from(Array(3), () => 0)
< [0, 0, 0]

Він працює, передаючи функцію карти як другий параметр Array.from.

У наведеному вище прикладі перший параметр виділяє масив із 3-х позицій, заповнених значенням, undefinedа потім функція лямбда присвоює кожне з них значення 0.

Хоча Array(len).fill(0)це і коротше, він не працює, якщо вам потрібно заповнити масив, зробивши спочатку деякі обчислення (я знаю, що питання цього не задавав, але багато людей в кінцевому підсумку шукають цього) .

Наприклад, якщо вам потрібен масив з 10 випадковими числами:

> Array.from(Array(10), () => Math.floor(10 * Math.random()))
< [3, 6, 8, 1, 9, 3, 0, 6, 7, 1]

Це більш стисло (і елегантно), ніж еквівалент:

const numbers = Array(10);
for (let i = 0; i < numbers.length; i++) {
    numbers[i] = Math.round(10 * Math.random());
}

Цей метод також може бути використаний для генерації послідовностей чисел, скориставшись параметром індексу, наданим у зворотному дзвінку

> Array.from(Array(10), (d, i) => i)
< [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Бонусна відповідь: заповніть масив за допомогою String repeat()

Оскільки ця відповідь привертає багато уваги, я також хотів показати цей крутий трюк. Хоча не настільки корисний, як моя головна відповідь, введе досі не дуже відомий, але дуже корисний repeat()метод String . Ось хитрість:

> "?".repeat(10).split("").map(() => Math.floor(10 * Math.random()))
< [5, 6, 3, 5, 0, 8, 2, 7, 4, 1]

Класно, так? repeat()є дуже корисним методом створення рядка, який є повторенням оригінальної рядки певну кількість разів. Після цього split()створює для нас масив, який потім відповідає map()значущим нам значенням. Розбивши його по кроках:

> "?".repeat(10)
< "??????????"

> "?".repeat(10).split("")
< ["?", "?", "?", "?", "?", "?", "?", "?", "?", "?"]

> "?".repeat(10).split("").map(() => Math.floor(10 * Math.random()))
< [5, 6, 3, 5, 0, 8, 2, 7, 4, 1]

Коротко

Найшвидше рішення

let a = new Array(n); for (let i=0; i<n; ++i) a[i] = 0;

Найкоротше (зручне) рішення (у 3 рази повільніше для малих масивів, трохи повільніше для великих (повільніше на Firefox))

Array(n).fill(0)

Деталі

Сьогодні 2020.06.09 я виконую тести на macOS High Sierra 10.13.6 на браузерах Chrome 83.0, Firefox 77.0 та Safari 13.1. Я тестую вибрані рішення для двох тестових випадків

• невеликий масив - з 10 елементами - ви можете виконати тест ТУТ
• великі масиви - з елементами 1М - ви можете виконати тест ТУТ

Висновки

• рішення на основі new Array(n)+for(N) - це найшвидше рішення для малих масивів і великих масивів (крім Chrome, але все ще дуже швидких), і рекомендується як швидке рішення для перехресних браузерів
• рішення на основі new Float32Array(n)(I) повертає нетиповий масив (наприклад, ви не можете його зателефонувати push(..)), тому я не порівнюю його результати з іншими рішеннями - однак це рішення приблизно в 10-20 разів швидше, ніж інші рішення для великих масивів у всіх браузерах
• рішення на основі for(L, M, N, O) швидкі для малих масивів
• рішення на базі fill(B, C) швидкі на Chrome і Safari, але дивно повільніші на Firefox для великих масивів. Вони є середньо швидкими для малих масивів
• рішення на основі Array.apply(P) кидає помилку для великих масивів

  Показати фрагмент коду

  function P(n) {
    return Array.apply(null, Array(n)).map(Number.prototype.valueOf,0);
  }
  
  
  try {
    P(1000000);
  } catch(e) { 
    console.error(e.message);
  }

  Виконати фрагмент кодуСховати результати

  Розгорніть фрагмент

Код та приклад

Нижче коду представлені рішення, що використовуються при вимірюванні

function A(n) {
  return [...new Array(n)].fill(0);
}

function B(n) {
  return new Array(n).fill(0);
}

function C(n) {
  return Array(n).fill(0);
}

function D(n) {
  return Array.from({length: n}, () => 0);
}

function E(n) {
  return [...new Array(n)].map(x => 0);
}

// arrays with type

function F(n) {
  return Array.from(new Int32Array(n));
}

function G(n) {
  return Array.from(new Float32Array(n));
}

function H(n) {
  return Array.from(new Float64Array(n)); // needs 2x more memory than float32
}

function I(n) {
  return new Float32Array(n); // this is not typical array
}

function J(n) {
  return [].slice.apply(new Float32Array(n));
}

// Based on for

function K(n) {
  let a = [];
  a.length = n;
  let i = 0;
  while (i < n) {
    a[i] = 0;
    i++;
  }
  return a;
}

function L(n) {
  let a=[]; for(let i=0; i<n; i++) a[i]=0;
  return a;
}

function M(n) {
  let a=[]; for(let i=0; i<n; i++) a.push(0);
  return a;
}

function N(n) {
  let a = new Array(n); for (let i=0; i<n; ++i) a[i] = 0;
  return a;
}

function O(n) {
  let a = new Array(n); for (let i=n; i--;) a[i] = 0;
  return a;
}

// other

function P(n) {
  return Array.apply(null, Array(n)).map(Number.prototype.valueOf,0);
}

function Q(n) {
  return "0".repeat( n ).split("").map( parseFloat );
}

function R(n) {
  return new Array(n+1).join('0').split('').map(parseFloat)
}


// ---------
// TEST
// ---------

log = f=> { let a=f(10); console.log(`${f.name} length=${a.length}, arr[0]=${a[0]}, arr[9]=${a[9]}`) }

[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R].forEach(f => log(f));

This snippets only present used codes

Приклад результатів для Chrome

Уже згаданий метод заповнення ES 6 добре допомагає про це. Більшість сучасних настільних браузерів вже підтримують необхідні методи прототипу Array на сьогодні (Chromium, FF, Edge та Safari) [ 1 ]. Ви можете переглянути деталі на MDN . Простий приклад використання

a = new Array(10).fill(0);

З огляду на поточну підтримку веб-переглядача, ви повинні з обережністю використовувати це, якщо ви не впевнені, що ваша аудиторія використовує сучасні настільні браузери.

Примітка додано в серпні 2013 року, оновлено лютий 2015 року: Відповідь нижче від 2009 року стосується загального Arrayтипу JavaScript . Це не стосується новіших набраних масивів, визначених у ES2015 [та доступних зараз у багатьох браузерах], таких як тощо Int32Array. Також зауважте, що ES2015 додає fillметод як для масивів, так і для набраних масивів , що, ймовірно, буде найефективнішим способом їх заповнення ...

Крім того, це може мати велике значення для деяких реалізацій того, як ви створюєте масив. Зокрема, двигун V8 Chrome намагається використовувати високоефективний масив пам’яті безперервної пам’яті, якщо він вважає, що може, переходячи на об’єктний масив лише за необхідності.

Для більшості мов було б попередньо виділити, а потім заповнити нуль, як це:

function newFilledArray(len, val) {
    var rv = new Array(len);
    while (--len >= 0) {
        rv[len] = val;
    }
    return rv;
}

Але JavaScript масиви насправді не є масивами , вони є ключовими / цінними картами, як і всі інші об’єкти JavaScript, тому не потрібно робити «попереднього розподілу» (якщо довжина не виділяє стільки слотів для заповнення), ні чи є підстави вважати, що вигода від зворотного відліку до нуля (що полягає лише в тому, щоб зробити порівняння в циклі) швидко не переважає, додаючи ключі в зворотному порядку, коли реалізація цілком оптимізувала їх роботу з ключами пов'язані з масивами теорії, ти зазвичай робиш їх у порядку.

Насправді Меттью Крамлі зазначав, що підрахунок на Firefox помітно повільніше, ніж підрахунок, результат, який я можу підтвердити, - це частина масиву (циклічне зменшення до нуля все ж швидше, ніж циклічне відновлення до вару). Очевидно додавання елементів до масиву у зворотному порядку - це повільна опція для Firefox. Насправді, результати відрізняються від реалізації JavaScript (що не все дивно). Ось швидка та брудна тестова сторінка (внизу) для реалізацій браузера (дуже брудна, не піддається під час тестів, тому забезпечує мінімальний зворотній зв'язок і буде досягати часових обмежень сценарію). Я рекомендую поновитись між тестами; FF (принаймні) сповільнюється при повторних тестах, якщо ви цього не зробите.

Досить складна версія, яка використовує Array # concat, швидша, ніж прямий init на FF, приблизно десь між 1000 та 2000 масивами елементів. На двигуні V8 Chrome, однак, прямо-таки init виграє щоразу ...

Ось тестова сторінка (в реальному часі ):

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Zero Init Test Page</title>
<style type='text/css'>
body {
    font-family:    sans-serif;
}
#log p {
    margin:     0;
    padding:    0;
}
.error {
    color:      red;
}
.winner {
    color:      green;
    font-weight:    bold;
}
</style>
<script type='text/javascript' src='prototype-1.6.0.3.js'></script>
<script type='text/javascript'>
var testdefs = {
    'downpre':  {
        total:  0,
        desc:   "Count down, pre-decrement",
        func:   makeWithCountDownPre
    },
    'downpost': {
        total:  0,
        desc:   "Count down, post-decrement",
        func:   makeWithCountDownPost
    },
    'up':       {
        total:  0,
        desc:   "Count up (normal)",
        func:   makeWithCountUp
    },
    'downandup':  {
        total:  0,
        desc:   "Count down (for loop) and up (for filling)",
        func:   makeWithCountDownArrayUp
    },
    'concat':   {
        total:  0,
        desc:   "Concat",
        func:   makeWithConcat
    }
};

document.observe('dom:loaded', function() {
    var markup, defname;

    markup = "";
    for (defname in testdefs) {
        markup +=
            "<div><input type='checkbox' id='chk_" + defname + "' checked>" +
            "<label for='chk_" + defname + "'>" + testdefs[defname].desc + "</label></div>";
    }
    $('checkboxes').update(markup);
    $('btnTest').observe('click', btnTestClick);
});

function epoch() {
    return (new Date()).getTime();
}

function btnTestClick() {

    // Clear log
    $('log').update('Testing...');

    // Show running
    $('btnTest').disabled = true;

    // Run after a pause while the browser updates display
    btnTestClickPart2.defer();
}
function btnTestClickPart2() {

    try {
        runTests();
    }
    catch (e) {
        log("Exception: " + e);
    }

    // Re-enable the button; we don't yheidl
    $('btnTest').disabled = false;
}

function runTests() {
    var start, time, counter, length, defname, def, results, a, invalid, lowest, s;

    // Get loops and length
    s = $F('txtLoops');
    runcount = parseInt(s);
    if (isNaN(runcount) || runcount <= 0) {
        log("Invalid loops value '" + s + "'");
        return;
    }
    s = $F('txtLength');
    length = parseInt(s);
    if (isNaN(length) || length <= 0) {
        log("Invalid length value '" + s + "'");
        return;
    }

    // Clear log
    $('log').update('');

    // Do it
    for (counter = 0; counter <= runcount; ++counter) {

        for (defname in testdefs) {
            def = testdefs[defname];
            if ($('chk_' + defname).checked) {
                start = epoch();
                a = def.func(length);
                time = epoch() - start;
                if (counter == 0) {
                    // Don't count (warm up), but do check the algorithm works
                    invalid = validateResult(a, length);
                    if (invalid) {
                        log("<span class='error'>FAILURE</span> with def " + defname + ": " + invalid);
                        return;
                    }
                }
                else {
                    // Count this one
                    log("#" + counter + ": " + def.desc + ": " + time + "ms");
                    def.total += time;
                }
            }
        }
    }

    for (defname in testdefs) {
        def = testdefs[defname];
        if ($('chk_' + defname).checked) {
            def.avg = def.total / runcount;
            if (typeof lowest != 'number' || lowest > def.avg) {
                lowest = def.avg;
            }
        }
    }

    results =
        "<p>Results:" +
        "<br>Length: " + length +
        "<br>Loops: " + runcount +
        "</p>";
    for (defname in testdefs) {
        def = testdefs[defname];
        if ($('chk_' + defname).checked) {
            results += "<p" + (lowest == def.avg ? " class='winner'" : "") + ">" + def.desc + ", average time: " + def.avg + "ms</p>";
        }
    }
    results += "<hr>";
    $('log').insert({top: results});
}

function validateResult(a, length) {
    var n;

    if (a.length != length) {
        return "Length is wrong";
    }
    for (n = length - 1; n >= 0; --n) {
        if (a[n] != 0) {
            return "Index " + n + " is not zero";
        }
    }
    return undefined;
}

function makeWithCountDownPre(len) {
    var a;

    a = new Array(len);
    while (--len >= 0) {
        a[len] = 0;
    }
    return a;
}

function makeWithCountDownPost(len) {
    var a;

    a = new Array(len);
    while (len-- > 0) {
        a[len] = 0;
    }
    return a;
}

function makeWithCountUp(len) {
    var a, i;

    a = new Array(len);
    for (i = 0; i < len; ++i) {
        a[i] = 0;
    }
    return a;
}

function makeWithCountDownArrayUp(len) {
    var a, i;

    a = new Array(len);
    i = 0;
    while (--len >= 0) {
        a[i++] = 0;
    }
    return a;
}

function makeWithConcat(len) {
    var a, rem, currlen;

    if (len == 0) {
        return [];
    }
    a = [0];
    currlen = 1;
    while (currlen < len) {
        rem = len - currlen;
        if (rem < currlen) {
            a = a.concat(a.slice(0, rem));
        }
        else {
            a = a.concat(a);
        }
        currlen = a.length;
    }
    return a;
}

function log(msg) {
    $('log').appendChild(new Element('p').update(msg));
}
</script>
</head>
<body><div>
<label for='txtLength'>Length:</label><input type='text' id='txtLength' value='10000'>
<br><label for='txtLoops'>Loops:</label><input type='text' id='txtLoops' value='10'>
<div id='checkboxes'></div>
<br><input type='button' id='btnTest' value='Test'>
<hr>
<div id='log'></div>
</div></body>
</html>

За замовчуванням Uint8Array, Uint16Arrayі Uint32Arrayкласи тримати нулі її цінності, так що вам не потрібні ніякі складні методи наповнення, просто зробити:

var ary = new Uint8Array(10);

всі елементи масиву aryза замовчуванням будуть нулями.

Якщо ви використовуєте ES6, ви можете використовувати Array.from () так:

Array.from({ length: 3 }, () => 0);
//[0, 0, 0]

Має такий же результат, як і

Array.from({ length: 3 }).map(() => 0)
//[0, 0, 0]

Тому що

Array.from({ length: 3 })
//[undefined, undefined, undefined]

function makeArrayOf(value, length) {
  var arr = [], i = length;
  while (i--) {
    arr[i] = value;
  }
  return arr;
}

makeArrayOf(0, 5); // [0, 0, 0, 0, 0]

makeArrayOf('x', 3); // ['x', 'x', 'x']

Зверніть увагу , що while, як правило , більш ефективні , ніж for-in, forEachі т.д.

використовуючи позначення об'єкта

var x = [];

нуль заповнений? подібно до...

var x = [0,0,0,0,0,0];

заповнене "невизначеним" ...

var x = new Array(7);

noj позначення з нулями

var x = [];
for (var i = 0; i < 10; i++) x[i] = 0;

Як бічна примітка, якщо ви модифікуєте прототип Array, обидва

var x = new Array();

і

var y = [];

буде мати ці модифікації прототипу

У будь-якому випадку, я не надто переймаюся ефективністю або швидкістю цієї операції, є багато інших речей, які ви, ймовірно, будете робити, набагато більш марно і дорого, ніж інстанціювати масив довільної довжини, що містить нулі.

Я перевірив усі комбінації попереднього розподілу / не попереднього розподілу, підрахунку вгору / вниз, та циклів / для циклів в IE 6/7/8, Firefox 3.5, Chrome та Opera.

Функції нижче були послідовно найшвидшими або надзвичайно близькими у Firefox, Chrome та IE8, і не набагато повільніше, ніж найшвидші в Opera та IE 6. Це, на мій погляд, також найпростіший і зрозумілий. Я знайшов кілька браузерів, де версія циклу while трохи швидша, тому я включаю її також для довідки.

function newFilledArray(length, val) {
    var array = [];
    for (var i = 0; i < length; i++) {
        array[i] = val;
    }
    return array;
}

або

function newFilledArray(length, val) {
    var array = [];
    var i = 0;
    while (i < length) {
        array[i++] = val;
    }
    return array;
}

Якщо вам потрібно створити безліч заповнених масивів різної довжини під час виконання вашого коду, я знайшов найшвидший спосіб досягти цього - створити нульовий масив один раз , використовуючи один із методів, зазначених у цій темі, довжиною який ви знаєте, ніколи не буде перевищено, а потім наріжте цей масив за необхідності.

Наприклад (використовуючи функцію з обраної відповіді вище для ініціалізації масиву), створіть заповнений нулем масив довжиною maxLength як змінну, видиму коду, який потребує нульових масивів:

var zero = newFilledArray(maxLength, 0);

Тепер відріжте цей масив щоразу, коли вам потрібен нульовий масив довжини, необхідноїLength < maxLength :

zero.slice(0, requiredLength);

Я створював масиви, заповнені нулями тисячі разів під час виконання мого коду, це надзвичайно прискорило процес.

function zeroFilledArray(size) {
    return new Array(size + 1).join('0').split('');
}

Я нічого не маю проти:

Array.apply(null, Array(5)).map(Number.prototype.valueOf,0);
new Array(5+1).join('0').split('').map(parseFloat);

запропонований Zertosh, але в нових розширеннях масивів ES6 ви можете це зробити безпосередньо з fillметодом. Тепер IE edge, Chrome і FF підтримують його, але перевірте таблицю сумісності

new Array(3).fill(0)дасть тобі [0, 0, 0]. Ви можете заповнити масив будь-яким значеннямnew Array(5).fill('abc') (наприклад, об'єктами та іншими масивами).

Крім того, ви можете змінювати попередні масиви із заповненням:

arr = [1, 2, 3, 4, 5, 6]
arr.fill(9, 3, 5)  # what to fill, start, end

що дає вам: [1, 2, 3, 9, 9, 6]

Те, як я зазвичай це роблю (і це дивно швидко), використовує Uint8Array. Наприклад, створення нульового заповненого вектора елементів 1М:

  var zeroFilled = [].slice.apply(new Uint8Array(1000000))

Я користувач Linux і завжди працював для мене, але колись у друга, який використовував Mac, було кілька ненульових елементів. Я думав, що його машина несправна, але все-таки ось найбезпечніший спосіб, як ми її виправили:

  var zeroFilled = [].slice.apply(new Uint8Array(new Array(1000000)) 

Відредаговано

Chrome 25.0.1364.160

1. Фредерік Готліб - 6.43
2. Сем Барнум - 4,83
3. Елі - 3,68
4. Джошуа 2,91
5. Метью Крамлі - 2,67
6. бдуран - 2,55
7. Аллен Райс - 2.11
8. кенгакс - 0,68
9. Tj. Кукурудза - 0,67
10. zertosh - ПОМИЛКА

Firefox 20.0

1. Аллен Райс - 1,85
2. Джошуа - 1,82
3. Метью Крамлі - 1,79
4. бдуран - 1,37
5. Фредерік Готліб - 0,67
6. Сем Барнум - 0,63
7. Елі - 0,59
8. кагакс - 0,13
9. Tj. Кукурудза - 0,13
10. zertosh - ПОМИЛКА

Не вистачає найважливішого тесту (принаймні для мене): Node.js. Я підозрюю, що це близько до еталону Chrome.

Використання лодашу або підкреслення

_.range(0, length - 1, 0);

Або якщо у вас є масив, який існує, і ви хочете масив однакової довжини

array.map(_.constant(0));

Рішення ES6:

[...new Array(5)].map(x => 0); // [0, 0, 0, 0, 0]

Станом на ECMAScript2016 , існує великий вибір для великих масивів.

Оскільки ця відповідь все ще з’являється біля вершини в пошуку Google, ось відповідь за 2017 рік.

Ось поточний jsbench з кількома десятками популярних методів, включаючи безліч запропонованих до цього часу питань. Якщо ви знайдете кращий метод, будь ласка, додайте, розкладіть і поділіться.

Хочу зазначити, що не існує справжнього найефективнішого способу створення масиву заповненої довільною довжиною нуля. Ви можете оптимізувати швидкість чи чіткість та ремонтопридатність - або можна вважати більш ефективним вибором залежно від потреб проекту.

Оптимізуючи швидкість, ви хочете: створити масив, використовуючи буквальний синтаксис; встановіть довжину, ініціалізуйте змінну ітерації та повторіть масив, використовуючи цикл while. Ось приклад.

const arr = [];
arr.length = 120000;
let i = 0;
while (i < 120000) {
  arr[i] = 0;
  i++;
}

Іншою можливою реалізацією буде:

(arr = []).length = n;
let i = 0;
while (i < n) {
    arr[i] = 0;
    i++;
}

Але я настійно не рекомендую використовувати цю другу імплантацію на практиці, оскільки вона менш зрозуміла і не дозволяє підтримувати обсяг блоку на змінній масиву.

Вони значно швидше, ніж заповнення циклом for, і приблизно на 90% швидше, ніж стандартний метод

const arr = Array(n).fill(0);

Але цей метод заповнення все ще є найбільш ефективним вибором для менших масивів через його чіткість, стислість та ремонтопридатність. Різниця в продуктивності, швидше за все, не вб'є вас, якщо ви не зробите безліч масивів із довжиною порядку тисяч і більше.

Ще кілька важливих приміток. Більшість посібників зі стилів рекомендують більше не використовувати varбез особливих причин під час використання ES6 або новіших версій. Використовуйте constдля змінних, які не будуть переглянуті, і letдля змінних, які будуть. MDN і керівництво Стилю AirBnB в великих містах , щоб піти для отримання більш докладної інформації про передовий практиці. Питання полягало не в синтаксисі, але важливо, щоб люди, які не знають про JS, знали про ці нові стандарти під час пошуку цих витоків старих і нових відповідей.

Для створення всього нового масиву

new Array(arrayLength).fill(0);

Щоб додати деякі значення в кінці наявного масиву

[...existingArray, ...new Array(numberOfElementsToAdd).fill(0)]

Приклад

//**To create an all new Array**

console.log(new Array(5).fill(0));

//**To add some values at the end of an existing Array**

let existingArray = [1,2,3]

console.log([...existingArray, ...new Array(5).fill(0)]);

Не бачив цей метод у відповідях, тому ось він:

"0".repeat( 200 ).split("").map( parseFloat )

У результаті ви отримаєте нульовий масив довжиною 200:

[ 0, 0, 0, 0, ... 0 ]

Я не впевнений у ефективності цього коду, але це не повинно бути проблемою, якщо ви використовуєте його для відносно невеликих масивів.

Ця concatверсія набагато швидша в моїх тестах на Chrome (2013-03-21). Близько 200 мс для 10 000 000 елементів проти 675 для прямого init.

function filledArray(len, value) {
    if (len <= 0) return [];
    var result = [value];
    while (result.length < len/2) {
        result = result.concat(result);
    }
    return result.concat(result.slice(0, len-result.length));
}

Бонус: якщо ви хочете заповнити свій масив Strings, це стислий спосіб зробити це (не так швидко, як concatби):

function filledArrayString(len, value) {
    return new Array(len+1).join(value).split('');
}

Я випробовував чудову відповідь TJ Crowder і придумав рекурсивне злиття на основі лаконічного рішення, яке перевершує будь-які його тести в Chrome (я не перевіряв інших браузерів).

function makeRec(len, acc) {
    if (acc == null) acc = [];
    if (len <= 1) return acc;
    var b = makeRec(len >> 1, [0]);
    b = b.concat(b);
    if (len & 1) b = b.concat([0]);
    return b;
},

викликати метод за допомогою makeRec(29).

Про що new Array(51).join('0').split('')?

Можливо, варто зазначити, що Array.prototype.fillце було додано як частина пропозиції ECMAScript 6 (Гармонія) . Я б скоріше пішов із написаним нижче поліфілом, перш ніж розглядати інші варіанти, згадані на потоці.

if (!Array.prototype.fill) {
  Array.prototype.fill = function(value) {

    // Steps 1-2.
    if (this == null) {
      throw new TypeError('this is null or not defined');
    }

    var O = Object(this);

    // Steps 3-5.
    var len = O.length >>> 0;

    // Steps 6-7.
    var start = arguments[1];
    var relativeStart = start >> 0;

    // Step 8.
    var k = relativeStart < 0 ?
      Math.max(len + relativeStart, 0) :
      Math.min(relativeStart, len);

    // Steps 9-10.
    var end = arguments[2];
    var relativeEnd = end === undefined ?
      len : end >> 0;

    // Step 11.
    var final = relativeEnd < 0 ?
      Math.max(len + relativeEnd, 0) :
      Math.min(relativeEnd, len);

    // Step 12.
    while (k < final) {
      O[k] = value;
      k++;
    }

    // Step 13.
    return O;
  };
}

Найкоротший код циклу

a=i=[];for(;i<100;)a[i++]=0;

edit:
for(a=i=[];i<100;)a[i++]=0;
or
for(a=[],i=100;i--;)a[i]=0;

Безпечна версія версії

var a=[],i=0;for(;i<100;)a[i++]=0;

edit:
for(var i=100,a=[];i--;)a[i]=0;

Моя найшвидша функція:

function newFilledArray(len, val) {
    var a = [];
    while(len--){
        a.push(val);
    }
    return a;
}

var st = (new Date()).getTime();
newFilledArray(1000000, 0)
console.log((new Date()).getTime() - st); // returned 63, 65, 62 milliseconds

Використання нативного натискання та зсуву для додавання елементів до масиву набагато швидше (приблизно в 10 разів), ніж оголошення області масиву та посилання кожного елемента для встановлення його значення.

fyi: я постійно отримую швидші часи з першим циклом, який відлічується під час запуску цього в firebug (розширення firefox).

var a = [];
var len = 1000000;
var st = (new Date()).getTime();
while(len){
    a.push(0);
    len -= 1;
}
console.log((new Date()).getTime() - st); // returned 863, 894, 875 milliseconds
st = (new Date()).getTime();
len = 1000000;
a = [];
for(var i = 0; i < len; i++){
    a.push(0);
}
console.log((new Date()).getTime() - st); // returned 1155, 1179, 1163 milliseconds

Мені цікаво знати, що з цього робить TJ Crowder? :-)

Я знав, що у мене цей протод десь :)

Array.prototype.init = function(x,n)
{
    if(typeof(n)=='undefined') { n = this.length; }
    while (n--) { this[n] = x; }
    return this;
}

var a = (new Array(5)).init(0);

var b = [].init(0,4);

Редагувати: тести

У відповідь на Джошуа та інші методи я здійснив власний бенчмаркінг, і я бачу зовсім інші результати від тих, про які повідомлялося.

Ось що я перевірив:

//my original method
Array.prototype.init = function(x,n)
{
    if(typeof(n)=='undefined') { n = this.length; }
    while (n--) { this[n] = x; }
    return this;
}

//now using push which I had previously thought to be slower than direct assignment
Array.prototype.init2 = function(x,n)
{
    if(typeof(n)=='undefined') { n = this.length; }
    while (n--) { this.push(x); }
    return this;
}

//joshua's method
function newFilledArray(len, val) {
    var a = [];
    while(len--){
        a.push(val);
    }
    return a;
}

//test m1 and m2 with short arrays many times 10K * 10

var a = new Date();
for(var i=0; i<10000; i++)
{
    var t1 = [].init(0,10);
}
var A = new Date();

var b = new Date();
for(var i=0; i<10000; i++)
{
    var t2 = [].init2(0,10);
}
var B = new Date();

//test m1 and m2 with long array created once 100K

var c = new Date();
var t3 = [].init(0,100000);
var C = new Date();

var d = new Date();
var t4 = [].init2(0,100000);
var D = new Date();

//test m3 with short array many times 10K * 10

var e = new Date();
for(var i=0; i<10000; i++)
{
    var t5 = newFilledArray(10,0);
}
var E = new Date();

//test m3 with long array created once 100K

var f = new Date();
var t6 = newFilledArray(100000, 0)
var F = new Date();

Результати:

IE7 deltas:
dA=156
dB=359
dC=125
dD=375
dE=468
dF=412

FF3.5 deltas:
dA=6
dB=13
dC=63
dD=8
dE=12
dF=8

Так що, за моїм рахунком, поштовх дійсніше повільніше, але працює краще з довшими масивами у FF, але гірше в IE, який просто смокче загалом (quel сюрприз).

Анонімні функції:

(function(n) { while(n-- && this.push(0)); return this; }).call([], 5);
// => [0, 0, 0, 0, 0]

Трохи коротше з for-loop:

(function(n) { for(;n--;this.push(0)); return this; }).call([], 5);
// => [0, 0, 0, 0, 0]

Працює з будь-яким Object, просто змінити те, що знаходиться всередині this.push().

Ви навіть можете зберегти функцію:

function fill(size, content) {
  for(;size--;this.push(content));
  return this;
}

Телефонуйте за допомогою:

var helloArray = fill.call([], 5, 'hello');
// => ['hello', 'hello', 'hello', 'hello', 'hello']

Додавання елементів до вже наявного масиву:

var helloWorldArray = fill.call(helloArray, 5, 'world');
// => ['hello', 'hello', 'hello', 'hello', 'hello', 'world', 'world', 'world', 'world', 'world']

Продуктивність: http://jsperf.com/zero-filled-array-creation/25