Я ищу любые альтернативы ниже для создания массива 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 from () и keys () .

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,5577575915358745, 0,5577581530874532, 0,17617830308732

объяснение

Во-первых, обратите внимание, что 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. От и { 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

Edit: Изменен Array(45)в Array(N)виду того что вы обновили вопрос.

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

Используйте очень популярный метод Underscore _.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.

(основано на максимальных целочисленных значениях ), также здесь больше о Typed Arrays ):

(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]

Если вы используете lodash, вы можете использовать _.range :

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

Создает массив чисел (положительных и / или отрицательных), начиная от начала до, но не включая конец. Шаг -1 используется, если указано отрицательное начало без конца или шага. Если end не указан, он запускается с start, затем устанавливается на 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);
// ➜ []

Новый способ заполнения Array:

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

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

с 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 . Версия Cocco выше близка, но не самая короткая.

(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);

а = [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, вы можете очень легко создать массив случайностей:

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})()]

Вы можете использовать Array fill и map из 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]сделать массив повторяемым. Примечание: ноль более распространен, так как первый аргумент применяется, но короче 0.
• Object.keys(Array.apply(0,Array(3))) // ['0', '1', '2'] затем получить ключи массива (работает, потому что массивы typeof это массив с индексами для ключей.
• Object.keys(Array.apply(0,Array(3))).map(Number) // [0, 1, 2] и сопоставьте ключи, преобразовав строки в числа.