Ben N sadece çalışma zamanında bilinen 1 ila N içeren bir JavaScript dizisi oluşturmak için aşağıdaki herhangi bir alternatif arıyorum.

var foo = [];

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

Bana göre bunu döngü olmadan yapmanın bir yolu olmalı gibi geliyor.

Eğer peşinde olduğun şeyi alırsam 1..n, sonradan geçebileceğin bir dizi sayı istersin.

Tüm ihtiyacınız olan bu ise, bunun yerine bunu yapabilir misiniz?

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

kullanmak istediğinizde ... (optimize edilmemiş, örneğin)

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

Örneğin , dizide herhangi bir şey depolamanız gerekmiyorsa, yalnızca yineleyebileceğiniz doğru uzunlukta bir kaba ihtiyacınız vardır ... bu daha kolay olabilir.

Burada iş başında görün: http://jsfiddle.net/3kcvm/

ES6'da Array from () ve keys () yöntemlerini kullanarak.

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

Forma operatörü kullanarak daha kısa versiyon .

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

Bunu yapabilirsiniz:

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

sonuç: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

veya rastgele değerlerle:

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

sonuç: [0.7082694901619107, 0.9572225909214467, 0.8586748542729765, 0.8653848143294454, 0.008339877473190427, 0.9911756622605026, 0.8133423360995948, 0.8377588465809822, 0.55775759359511

açıklama

İlk olarak, not Number.call(undefined, N)eşdeğerdir Number(N)hangi sadece getiriler,N . Bu gerçeği daha sonra kullanacağız.

Array.apply(null, [undefined, undefined, undefined])eşdeğerdir Array(undefined, undefined, undefined), üç elemanlı bir dizi oluşturur veundefined her bir öğeye .

Bunu N elementlerine nasıl genelleştirebilirsiniz ? Nasıl Array()çalıştığını düşünün , ki böyle bir şey gider:

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'ten bu yana , Function.prototype.apply(thisArg, argsArray)ördek parametresi olan dizi benzeri bir nesneyi ikinci parametresi olarak kabul eder. Eğer çağırırsak Array.apply(null, { length: N }), o zaman

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

Şimdi her elemanın ayarlanmış bir N- element dizisi var undefined. Onu çağırdığımızda .map(callback, thisArg), her öğe sonucuna ayarlanacaktır callback.call(thisArg, element, index, array). Bu nedenle, [undefined, undefined, …, undefined].map(Number.call, Number)her bir öğeyi daha önce gözlemlediğimiz gibi (Number.call).call(Number, undefined, index, array)aynı olanla Number.call(undefined, index, array)eşler index. Bu, öğeleri dizinleriyle aynı olan diziyi tamamlar.

Neden Array.apply(null, {length: N})sadece yerine beladan geçiyorsun Array(N)? Sonuçta, her iki ifade de tanımsız öğelerden oluşan bir N öğeli diziye neden olur . Fark, önceki ifadede, her öğenin açıkça tanımsız olarak ayarlanmışken , son ifadede her öğenin hiçbir zaman ayarlanmamış olmasıdır. Belgelerine göre .map():

callbackyalnızca atanmış değerleri olan dizinin dizinleri için çağrılır; silinmiş veya hiç değer atanmamış dizinler için çağrılmaz.

Bu nedenle, Array(N)yetersiz; Array(N).map(Number.call, Number)başlatılmamış bir uzunluk N dizisine neden olur .

uygunluk

Bu teknik Function.prototype.apply()ECMAScript 5'te belirtilen davranışa dayandığından, Chrome 14 ve Internet Explorer 9 gibi ECMAScript 5 öncesi tarayıcılarda çalışmaz .

ES6'yı Kullanmanın Birden Çok Yolu

Spread operator ( ...) ve keys yöntemini kullanma

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

Dolgu / Harita

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

Array.from

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

Array.from ve { length: N }kesmek

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

Genelleştirilmiş form hakkında not

Değiştirerek hemen hemen arzu edilen herhangi bir değerlere başlatıldı kutu üretmek dizileri üzerindeki tüm formları i+1(örneğin, gerekli ekspresyonuna i*2, -i, 1+i*2, i%2vb). İfade bir işlevle ifade edilebilirse f, ilk form basitçe olur

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

Örnekler:

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

Dizi ile başlatılır yana undefinedher bir pozisyon ile, değeri v olacaktırundefined

Tüm formları gösteren örnek

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)

Özel başlatma işleviyle daha genel bir örnek fyani

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

hatta daha basit

[ ...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)

Diziler uzunluklarını doğuştan yönetir. Geçildikçe, dizinleri bellekte tutulabilir ve o noktada referans gösterilebilir. Rastgele bir dizinin bilinmesi gerekiyorsa, indexOfyöntem kullanılabilir.

Bu, ihtiyaçlarınız için sadece belirli bir boyutta bir dizi bildirmek isteyebileceğinizi söyledi:

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

Yaymak

Forma operatörünü ( ...) ve keysyöntemi kullanarak, dizinleri oluşturmak için N boyutunda geçici bir dizi oluşturmanıza ve ardından değişkeninize atanabilecek yeni bir dizi oluşturmanıza olanak tanır:

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

Dolgu / Harita

Önce ihtiyacınız olan dizinin boyutunu oluşturabilir, tanımsız olarak doldurabilir ve ardından mapher bir öğeyi dizine ayarlayan yeni bir dizi oluşturabilirsiniz .

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

Array.from

Bu, N boyutunun uzunluğuna başlamalı ve diziyi bir geçişte doldurmalıdır.

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

Yorumlar ve karışıklık yerine, yukarıdaki örneklerde 1.N'deki değerleri gerçekten yakalamak istiyorsanız, birkaç seçenek vardır:

1. eğer indeks mevcutsa, sadece bir arttırabilirsiniz (örn ++i.).

2. dizinin kullanılmadığı ve muhtemelen daha etkili bir yol olduğu durumlarda dizinizi oluşturmak, ancak N'yi N + 1'i temsil etmek, sonra önden kaydırmaktır.

   Yani 100 sayı istiyorsanız:

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

ES6'da şunları yapabilirsiniz:

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

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

Düzenleme: Değiştirildi Array(45)için Array(N)soruyu güncelledik beri.

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

Çok popüler Alt Çizgi _.range yöntemini kullanın

// _.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;
}

Sonra

var foo = range(1, 5);

Javascript'te bunu yapmanın yerleşik bir yolu yoktur, ancak bir kereden fazla yapmanız gerekirse oluşturmak için mükemmel bir yardımcı program işlevidir.

Düzenleme: Bence, aşağıdaki daha iyi bir aralık işlevidir. Belki sadece LINQ tarafından önyargılı olduğum için, ama daha fazla durumda daha yararlı olduğunu düşünüyorum. Kilometreniz değişebilir.

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;
}

bir Arrayv8'i doldurmanın en hızlı yolu :

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

sonuç: [0, 1, 2, 3, 4]

Bu sorunun birçok karmaşık yanıtı var, ancak basit bir tek katlı:

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

Ayrıca, yukarıdakiler yazmak için kısa (ve temiz) olmasına rağmen, aşağıdakilerin biraz daha hızlı olduğunu düşünüyorum (maksimum uzunluk için:

127, Int8,

255, Uint8,

32,767, Int16,

65.535, Uint16,

2.147.483.647, Int32,

4,294,967,295, Uint32.

( maks. tamsayı değerlerine dayalı olarak ), burada da Yazılı Diziler hakkında daha fazla bilgi bulabilirsiniz :

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

Her ne kadar bu çözüm o kadar ideal olmasa da, iki dizi oluşturduğundan ve "$" ekstra değişken bildirimini kullandığından (bu yöntemi kullanarak bu sorunu çözmenin hiçbir yolu olmadığından). Aşağıdaki çözümün bunu yapmanın mümkün olan en hızlı yolu olduğunu düşünüyorum:

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

Bu ifade yapıldıktan sonra, geçerli kapsamda "arr" değişkenini basit bir şekilde kullanabilirsiniz;

Basit bir işlev yapmak istiyorsanız (bazı temel doğrulamalarla):

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

böylece, yukarıdaki işlevle, yukarıdaki süper yavaş "basit bir astar" süper hızlı, daha da kısa hale gelir:

range(1,14000);

Bunu kullanabilirsiniz:

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

Örneğin

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

şu diziyi oluşturur:

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

ES6 bu işe yarayacak:

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

sonucu kontrol et:

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

Uygulamanızda d3.js'yi benim gibi kullanıyorsanız , D3 bunu sizin için yapan bir yardımcı işlev sağlar.

Yani 0'dan 4'e kadar bir dizi almak için, bu kadar kolay:

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

ve istediğiniz gibi 1'den 5'e kadar bir dizi almak için:

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

Daha fazla bilgi için bu eğiticiye göz atın .

ES2015 / ES6 forma operatörünü kullanma

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

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

Bu muhtemelen bir dizi sayı oluşturmanın en hızlı yoludur

En kısa

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

Çizgide

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'den başlamak istiyorsanız

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]

Bir işlev mi istiyorsunuz?

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]

NEDEN?

1. while en hızlı döngü

2. Doğrudan ayar daha hızlı push

3. [] daha hızlı new Array(10)

4. kısa ... ilk koda bak. o zaman buradaki diğer tüm işlevlere bakın.

İsterseniz olmadan canlı olamaz için

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

veya

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

doldurmanın yeni yolu Array:

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

sonuç: [0, 1, 2, 3, 4]

Eğer lodash kullanıyorsanız, kullanabilirsiniz _.range :

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

Başlangıçtan sona kadar ilerleyen, ancak bitiş içermeyen bir dizi sayı (pozitif ve / veya negatif) oluşturur. Bir bitiş veya adım olmadan negatif bir başlangıç ​​belirtilirse -1 adımı kullanılır. End belirtilmezse, start ile başlayıp 0'a ayarlanır.

Örnekler:

_.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 ile şunları yapabilirsiniz:

// `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)

Nihai Özet raporu .. Drrruummm Rolll -

Bu, ES6 kullanmadan N boyutunda (burada 10) bir Array oluşturmak için en kısa koddur . Cocco'nun yukarıdaki sürümü yakın ancak en kısa değil.

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

Ancak bu Kod golfünün tartışmasız kazananı (kaynak kodunun en az baytında belirli bir sorunu çözme yarışması) Niko Ruotsalainen'dir . Array Constructor ve ES6 spread operatörünü kullanma . (ES6 sözdiziminin çoğu geçerli typeScript'tir, ancak aşağıdakiler değildir. Bu yüzden kullanırken dikkatli olun)

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

ES6'da, 2 bağımsız değişken alan Array.from'u kullanan başka bir yol daha var, ilki bir arrayLike (bu durumda özellikli bir nesne length) ve ikincisi bir eşleme işlevidir (bu durumda öğeyi dizinine eşleriz )

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

bu daha kısadır ve çift sayı üretmek gibi diğer diziler için de kullanılabilir

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

Ayrıca bu, diğer birçok yoldan daha iyi bir performansa sahiptir, çünkü dizi boyunca sadece bir kez döngü yapar. Bazı karşılaştırmalar için snippit'i kontrol edin

// 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")

=>ES6 standardından yeni Array yöntemleri ve işlev sözdizimi kullanma (yalnızca yazma sırasında Firefox).

Delikleri aşağıdakilerle doldurarak undefined:

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

Array.fromdönüşler "delikler" içine undefinedöylesine Array.mapbeklendiği gibi çalışır:

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'da:

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

ES5:

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

Sadece başka bir ES6 sürümü.

Yararlanarak Array.fromikinci opsiyonel argüman:

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

Numaralandırılmış diziyi boş Array(10)konumlardan oluşturabiliriz:

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

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

Şu anda bu tam cevap listesinde yer almayan tek lezzet, bir jeneratörü içeren bir lezzet gibi görünüyor; bunu düzeltmek için:

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

bu şekilde kullanılabilir:

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

Bununla ilgili güzel bir şey, sadece artırmak zorunda kalmamanız ... @ igor-shubin'in verdiği cevaptan ilham almak için çok kolay bir dizi rastgele oluşturabilirsiniz:

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

Ve operasyonel olarak pahalı uzun bir şey yerine :

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

bunun yerine şunları yapabilirsiniz:

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

Es6'dan dizi dolgusu ve harita kullanabilirsiniz; tıpkı bu soru için verdikleri cevaplarda birkaç kişinin önerdiği gibi. Aşağıda birkaç örnek verilmiştir:

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]

Bunu tercih ederim çünkü doğrudan ileri ve daha kolay buluyorum.

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

Kaynak: https://developer.mozilla.org/tr-TR/docs/Web/JavaScript/Reference/Global_Objects/Array/from

ES6'yı kullanma

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

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

İade [0, 1, 2]. Igor Shubin'in mükemmel cevabına çok benzer , ancak biraz daha az hile (ve bir karakter daha uzun).

Açıklama:

• Array(3) // [undefined × 3]N = 3 uzunluğunda bir dizi oluşturun. Ne yazık ki bu dizi bizim için neredeyse işe yaramaz, bu yüzden ...
• Array.apply(0,Array(3)) // [undefined, undefined, undefined]diziyi yinelenebilir hale getirin. Not: null, uygulamanın ilk argümanı olarak daha yaygındır ancak 0 daha kısadır.
• Object.keys(Array.apply(0,Array(3))) // ['0', '1', '2'] sonra dizinin anahtarlarını alın (Diziler typeof dizisi olduğu için çalışır, anahtarlar için dizinleri olan bir nesnedir.
• Object.keys(Array.apply(0,Array(3))).map(Number) // [0, 1, 2] ve dizgileri sayılara dönüştürerek tuşların üzerinden eşleştirin.