Я шукаю альтернативи нижче для створення масиву JavaScript, що містить від 1 до N, де N відомий лише під час виконання.

var foo = [];

for (var i = 1; i <= N; i++) {
   foo.push(i);
}

Мені здається, що має бути спосіб зробити це без циклу.

Якщо я отримаю те, що ви шукаєте, ви хочете масив чисел, 1..nякий ви зможете згодом пропустити.

Якщо це все, що вам потрібно, чи можете це зробити замість цього?

var foo = new Array(45); // create an empty array with length 45

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

for(var i = 0; i < foo.length; i++){
  document.write('Item: ' + (i + 1) + ' of ' + foo.length + '<br/>'); 
}

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

Побачити це в дії тут: http://jsfiddle.net/3kcvm/

В ES6 використовують Array від () та ключів () методів.

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

Коротша версія з використанням оператора розширення .

[...Array(10).keys()]
//=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Ви можете зробити це:

var N = 10; 
Array.apply(null, {length: N}).map(Number.call, Number)

результат: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

або з випадковими значеннями:

Array.apply(null, {length: N}).map(Function.call, Math.random)

результат: [0.7082694901619107, 0,9572225909214467, 0,8586748542729765, 0,8653848143294454, 0,008339877473190427, 0,9911756622605026, 0,8133423360995948, 0,8377588465809822, 0,55775759159558545, 0,1577575915958765, 0,1577575915958735, 0,157, 755, 15955, 585, 0,16, 755, 15955, 585, 0,16, 6005, 15955, 585, 0,16, 755, 1595, 585, 0,16, 6005, 1595, 585, 0,16, 755, 555, 585, 575, 596, 585, 585, 585, 585, 585, 585, 575, 585]

Пояснення

По-перше, зауважте, що Number.call(undefined, N)це рівноцінно тому Number(N), що просто повертається N. Ми будемо використовувати цей факт пізніше.

Array.apply(null, [undefined, undefined, undefined])еквівалентний Array(undefined, undefined, undefined), який створює триелементний масив і призначає undefinedкожному елементу.

Як ви можете узагальнити це до N елементів? Розглянемо, як Array()працює, що йде приблизно так:

function Array() {
    if ( arguments.length == 1 &&
         'number' === typeof arguments[0] &&
         arguments[0] >= 0 && arguments &&
         arguments[0] < 1 << 32 ) {
        return [ … ];  // array of length arguments[0], generated by native code
    }
    var a = [];
    for (var i = 0; i < arguments.length; i++) {
        a.push(arguments[i]);
    }
    return a;
}

Оскільки ECMAScript 5 , Function.prototype.apply(thisArg, argsArray)також приймає об’єкт, схожий на масив типу качки, як свій другий параметр. Якщо ми посилаємося Array.apply(null, { length: N }), то він виконається

function Array() {
    var a = [];
    for (var i = 0; i < /* arguments.length = */ N; i++) {
        a.push(/* arguments[i] = */ undefined);
    }
    return a;
}

Тепер у нас є масив N- елементів, з кожним елементом встановлено undefined. Коли ми закликаємо .map(callback, thisArg)його, кожен елемент буде встановлений у результаті callback.call(thisArg, element, index, array). Таким чином, [undefined, undefined, …, undefined].map(Number.call, Number)буде відображати кожен елемент (Number.call).call(Number, undefined, index, array), який є тим же самим Number.call(undefined, index, array), що, як ми спостерігали раніше, оцінює index. Це завершує масив, елементи якого збігаються з їх індексом.

Навіщо переживати неприємності, Array.apply(null, {length: N})а не просто Array(N)? Зрештою, обидва вирази спричинили б N -елементний масив невизначених елементів. Різниця полягає в тому, що в першому виразі кожен елемент явно встановлюється невизначеним, тоді як в другому кожен елемент ніколи не встановлювався. Відповідно до документації .map():

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

Тому Array(N)недостатньо; Array(N).map(Number.call, Number)приведе неініціалізованих масив довжиною N .

Сумісність

Оскільки ця методика покладається на поведінку, Function.prototype.apply()визначену в ECMAScript 5, вона не працюватиме в браузерах попереднього ECMAScript 5, таких як Chrome 14 та Internet Explorer 9.

Кілька способів використання ES6

Використовуючи ...метод оператора розповсюдження ( ) та ключів

[ ...Array(N).keys() ].map( i => i+1);

Заповнення / карта

Array(N).fill().map((_, i) => i+1);

Array.from

Array.from(Array(N), (_, i) => i+1)

Array.from і { length: N }зламати

Array.from({ length: N }, (_, i) => i+1)

Примітка про узагальнену форму

Всі форми можуть видавати масиви инициализируются в значній мірі будь-яких необхідних значення, змінюючи i+1для вираження необхідного (наприклад i*2, -i, 1+i*2, i%2і т.д.). Якщо вираз можна виразити якоюсь функцією, fто перша форма стає просто

[ ...Array(N).keys() ].map(f)

Приклади:

Array.from({length: 5}, (v, k) => k+1); 
// [1,2,3,4,5]

Оскільки масив ініціалізований з undefinedкожною позицією, значення v будеundefined

Приклад демонструє всі форми

let demo= (N) => {
  console.log(
    [ ...Array(N).keys() ].map(( i) => i+1),
    Array(N).fill().map((_, i) => i+1) ,
    Array.from(Array(N), (_, i) => i+1),
    Array.from({ length: N }, (_, i) => i+1)
  )
}

demo(5)

Більш загальний приклад із власною функцією ініціалізатора, fтобто

[ ...Array(N).keys() ].map((i) => f(i))

або навіть простіше

[ ...Array(N).keys() ].map(f)

let demo= (N,f) => {
  console.log(
    [ ...Array(N).keys() ].map(f),
    Array(N).fill().map((_, i) => f(i)) ,
    Array.from(Array(N), (_, i) => f(i)),
    Array.from({ length: N }, (_, i) => f(i))
  )
}

demo(5, i=>2*i+1)

Масиви внутрішньо керують їх довжиною. По мірі їх проходження їх індекси можуть зберігатися в пам'яті та посилатися на них у той момент. Якщо потрібно знати випадковий індекс, indexOfметод може бути використаний.

Це означає, що для ваших потреб ви можете просто оголосити масив певного розміру:

var foo = new Array(N);   // where N is a positive integer

/* this will create an array of size, N, primarily for memory allocation, 
   but does not create any defined values

   foo.length                                // size of Array
   foo[ Math.floor(foo.length/2) ] = 'value' // places value in the middle of the array
*/

ES6

Поширення

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

var foo = [ ...Array(N).keys() ];

Заповнення / карта

Спочатку можна створити потрібний розмір масиву, заповнити його невизначеним, а потім створити новий масив за допомогою map, який встановлює кожен елемент на індекс.

var foo = Array(N).fill().map((v,i)=>i);

Array.from

Це має бути ініціалізацією до довжини розміру N та заповнення масиву одним проходом.

Array.from({ length: N }, (v, i) => i)

Замість коментарів та плутанини, якщо ви справді хотіли захопити значення з 1..N у наведених вище прикладах, є кілька варіантів:

1. якщо індекс доступний, його можна просто збільшити на один (наприклад, ++i).

2. у випадках, коли індекс не використовується - і, можливо, більш ефективний спосіб - це створити свій масив, але зробіть N поданням N + 1, а потім зміститься з передньої частини.

   Тож якщо ви хочете 100 номерів:

   let arr; (arr=[ ...Array(101).keys() ]).shift()

У ES6 ви можете:

Array(N).fill().map((e,i)=>i+1);

http://jsbin.com/molabiluwa/edit?js,console

Редагувати: Змінено Array(45)з Array(N)моменту оновлення питання.

console.log(
  Array(45).fill(0).map((e,i)=>i+1)
);

Використовуйте дуже популярний метод підкреслення _.range

// _.range([start], stop, [step])

_.range(10); // => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
_.range(1, 11); // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
_.range(0, 30, 5); // => [0, 5, 10, 15, 20, 25]
_.range(0, -10, -1); //  => [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
_.range(0); // => []

function range(start, end) {
    var foo = [];
    for (var i = start; i <= end; i++) {
        foo.push(i);
    }
    return foo;
}

Потім подзвонив

var foo = range(1, 5);

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

Редагувати: На мою думку, наступна краща функція діапазону. Можливо, тому, що я упереджений LINQ, але я думаю, що це корисніше у більшості випадків. Ваш пробіг може відрізнятися.

function range(start, count) {
    if(arguments.length == 1) {
        count = start;
        start = 0;
    }

    var foo = [];
    for (var i = 0; i < count; i++) {
        foo.push(start + i);
    }
    return foo;
}

найшвидший спосіб заповнити Arrayv8:

[...Array(5)].map((_,i) => i);

Результатом буде: [0, 1, 2, 3, 4]

На це запитання є багато складних відповідей, але простий однолінійний:

[...Array(255).keys()].map(x => x + 1)

Крім того, хоча написання вище коротке (і акуратне), я думаю, що наступне трохи швидше (для максимальної довжини:

127, Int8,

255, Uint8,

32,767, Int16,

65,535, Uint16,

2,147,483,647, Int32,

4,294,967,295, Uint32.

(на основі максимальних цілих значень ), також тут докладніше про набрані масиви ):

(new Uint8Array(255)).map(($,i) => i + 1);

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

for(var i = 0, arr = new Uint8Array(255); i < arr.length; i++) arr[i] = i + 1;

Будь-який час після створення цього твердження ви можете просто використовувати змінну "arr" у поточному діапазоні;

Якщо ви хочете зробити з нього просту функцію (з деякою базовою верифікацією):

function range(min, max) {
    min = min && min.constructor == Number ? min : 0;
    !(max && max.constructor == Number && max > min) && // boolean statements can also be used with void return types, like a one-line if statement.
        ((max = min) & (min = 0));  //if there is a "max" argument specified, then first check if its a number and if its graeter than min: if so, stay the same; if not, then consider it as if there is no "max" in the first place, and "max" becomes "min" (and min becomes 0 by default)

    for(var i = 0, arr = new (
        max < 128 ? Int8Array : 
        max < 256 ? Uint8Array :
        max < 32768 ? Int16Array : 
        max < 65536 ? Uint16Array :
        max < 2147483648 ? Int32Array :
        max < 4294967296 ? Uint32Array : 
        Array
    )(max - min); i < arr.length; i++) arr[i] = i + min;
    return arr;
}



//and you can loop through it easily using array methods if you want
range(1,11).forEach(x => console.log(x));

//or if you're used to pythons `for...in` you can do a similar thing with `for...of` if you want the individual values:
for(i of range(2020,2025)) console.log(i);

//or if you really want to use `for..in`, you can, but then you will only be accessing the keys:

for(k in range(25,30)) console.log(k);

console.log(
    range(1,128).constructor.name,
    range(200).constructor.name,
    range(400,900).constructor.name,
    range(33333).constructor.name,
    range(823, 100000).constructor.name,
    range(10,4) // when the "min" argument is greater than the "max", then it just considers it as if there is no "max", and the new max becomes "min", and "min" becomes 0, as if "max" was never even written
);

таким чином, з вищевказаною функцією, вищевказаний над повільний "простий однолінійний" стає надшвидким, ще коротшим:

range(1,14000);

Ви можете скористатися цим:

new Array(/*any number which you want*/)
    .join().split(',')
    .map(function(item, index){ return ++index;})

наприклад

new Array(10)
    .join().split(',')
    .map(function(item, index){ return ++index;})

створить наступний масив:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

ES6 це зробить фокус:

[...Array(12).keys()]

перевірити результат:

[...Array(12).keys()].map(number => console.log(number))

Якщо у вашому додатку d3.js використовується як я, D3 надає допоміжну функцію, яка робить це для вас.

Отже, отримати масив від 0 до 4, це так просто, як:

d3.range(5)
[0, 1, 2, 3, 4]

і отримати масив від 1 до 5, як ви просили:

d3.range(1, 5+1)
[1, 2, 3, 4, 5]

Перегляньте цей підручник для отримання додаткової інформації.

Використовуючи оператор розповсюдження ES2015 / ES6

[...Array(10)].map((_, i) => i + 1)

console.log([...Array(10)].map((_, i) => i + 1))

Це, мабуть, найшвидший спосіб генерувати масив чисел

Найкоротший

var a=[],b=N;while(b--)a[b]=b+1;

В лінію

var arr=(function(a,b){while(a--)b[a]=a;return b})(10,[]);
//arr=[0,1,2,3,4,5,6,7,8,9]

Якщо ви хочете почати з 1

var arr=(function(a,b){while(a--)b[a]=a+1;return b})(10,[]);
//arr=[1,2,3,4,5,6,7,8,9,10]

Хочете функцію?

function range(a,b,c){c=[];while(a--)c[a]=a+b;return c}; //length,start,placeholder
var arr=range(10,5);
//arr=[5,6,7,8,9,10,11,12,13,14]

ЧОМУ?

1. while є найшвидшим циклом

2. Пряме налаштування швидше, ніж push

3. [] швидше, ніж new Array(10)

4. це коротко ... подивіться перший код. потім подивіться всі інші функції тут.

Якщо ви хочете не може жити без для

for(var a=[],b=7;b>0;a[--b]=b+1); //a=[1,2,3,4,5,6,7]

або

for(var a=[],b=7;b--;a[b]=b+1); //a=[1,2,3,4,5,6,7]

новий спосіб заповнення Array:

const array = [...Array(5).keys()]
console.log(array)

Результатом буде: [0, 1, 2, 3, 4]

Якщо ви використовуєте lodash, ви можете використовувати _.range :

_.range([start=0], end, [step=1])

Створює масив чисел (позитивних та / або негативних), що прогресують від початку до кінця, але не включаючи його. Крок -1 використовується, якщо вказаний негативний початок без кінця чи кроку. Якщо кінець не вказаний, його слід починати зі старту, а потім встановлювати на 0.

Приклади:

_.range(4);
// ➜ [0, 1, 2, 3]

_.range(-4);
// ➜ [0, -1, -2, -3]

_.range(1, 5);
// ➜ [1, 2, 3, 4]

_.range(0, 20, 5);
// ➜ [0, 5, 10, 15]

_.range(0, -4, -1);
// ➜ [0, -1, -2, -3]

_.range(1, 4, 0);
// ➜ [1, 1, 1]

_.range(0);
// ➜ []

за допомогою ES6 ви можете:

// `n` is the size you want to initialize your array
// `null` is what the array will be filled with (can be any other value)
Array(n).fill(null)

Підсумковий підсумковий звіт .. Drrruummm Rolll -

Це найкоротший код для створення масиву розміром N (тут 10) без використання ES6 . Версія Кокко вище є близькою, але не найкоротшою.

(function(n){for(a=[];n--;a[n]=n+1);return a})(10)

Але безперечним переможцем цього гольф-кодексу (змагання за вирішення конкретної проблеми в найменших байтах вихідного коду) є Ніко Руотсалайнен . Використання Array Constructor та ES6-оператора розповсюдження . (Більшість синтаксисів ES6 є дійсним typeScript, але наступний - ні. Тому будьте обережні, використовуючи його)

[...Array(10).keys()]

Є ще один спосіб у ES6, використовуючи Array.from, який бере 2 аргументи, перший - arrayLike (в даному випадку об’єкт із lengthвластивістю), а другий - функція відображення (у цьому випадку ми відображаємо елемент у його індекс)

Array.from({length:10}, (v,i) => i)

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

Array.from({length:10}, (v,i) => i*2)

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

// open the dev console to see results

count = 100000

console.time("from object")
for (let i = 0; i<count; i++) {
  range = Array.from({length:10}, (v,i) => i )
}
console.timeEnd("from object")

console.time("from keys")
for (let i =0; i<count; i++) {
  range = Array.from(Array(10).keys())
}
console.timeEnd("from keys")

console.time("apply")
for (let i = 0; i<count; i++) {
  range = Array.apply(null, { length: 10 }).map(function(element, index) { return index; })
}
console.timeEnd("apply")

Використання нових методів Array та =>синтаксису функцій із стандарту ES6 (на момент написання лише Firefox).

Заповнюючи отвори undefined:

Array(N).fill().map((_, i) => i + 1);

Array.fromперетворює "дірки" в undefinedтак, Array.mapяк очікувалося:

Array.from(Array(5)).map((_, i) => i + 1)

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

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

У ES6:

Array.from({length: 1000}, (_, i) => i);

ES5:

Array.apply(0, {length: 1000}).map(function(x,i){return i});

Ще одна версія ES6 .

Використовуючи Array.fromдругий необов’язковий аргумент:

Array.from (arrayLike [, mapFn [, thisArg]])

Ми можемо побудувати нумерований масив із порожніх Array(10)позицій:

Array.from(Array(10), (_, i) => i)

var arr = Array.from(Array(10), (_, i) => i);
document.write(arr);

Здається, єдиний аромат, який наразі не є в цьому досить повному списку відповідей, - це генератор; щоб виправити це:

const gen = N => [...(function*(){let i=0;while(i<N)yield i++})()]

які можна використовувати таким чином:

gen(4) // [0,1,2,3]

Приємно в тому, що ти не просто збільшуєшся ... Щоб взяти натхнення у відповіді, яку дав @ igor-shubin, ти можеш дуже легко створити масив randoms:

const gen = N => [...(function*(){let i=0;
  while(i++<N) yield Math.random()
})()]

А замість чогось тривалого в експлуатації дорогого типу:

const slow = N => new Array(N).join().split(',').map((e,i)=>i*5)
// [0,5,10,15,...]

ви можете замість цього зробити:

const fast = N => [...(function*(){let i=0;while(i++<N)yield i*5})()]

Ви можете використовувати заповнення масиву та карту від Es6; так само, як деякі з них запропонували у відповідях на це запитання. Нижче наведено кілька прикладів:

Example-One: Array(10).fill(0).map((e,i)=>i+1)

Result-One: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Example-Two: Array(100/10).fill(0).map((e,i)=>(i*10)+10)

Result-Two:[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

Я вважаю за краще це, тому що мені здається, що це прямо і простіше.

Array.from({ length: (stop - start) / step + 1}, (_, i) => start + (i * step));

Джерело: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from

Використання ES6

const generateArray = n => [...Array(n)].map((_, index) => index + 1);

Object.keys(Array.apply(0, Array(3))).map(Number)

Повертається [0, 1, 2]. Дуже схожа на відмінну відповідь Ігоря Шубіна , але з трохи меншою хитрістю (і на одного персонажа довше).

Пояснення:

• Array(3) // [undefined × 3]Створити масив довжиною n = 3. На жаль, цей масив для нас майже марний, тому ми повинні ...
• Array.apply(0,Array(3)) // [undefined, undefined, undefined]зробити масив ітерабельним. Примітка: null частіше, ніж перший аргумент застосунку, але 0 - коротший.
• Object.keys(Array.apply(0,Array(3))) // ['0', '1', '2'] потім дістаньте ключі масиву (працює, тому що масиви - це тип. масив - це об'єкт з індексами для ключів.
• Object.keys(Array.apply(0,Array(3))).map(Number) // [0, 1, 2] і карта над клавішами, перетворюючи рядки в числа.