कैसे एक सरणी बनाने के लिए 1… N युक्त

1161

मैं एन के माध्यम से 1 के लिए एक जावास्क्रिप्ट सरणी बनाने के लिए नीचे किसी भी विकल्प की तलाश कर रहा हूं जहां एन केवल रनटाइम पर जाना जाता है।

var foo = [];

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

मेरे लिए ऐसा लगता है कि लूप के बिना ऐसा करने का एक तरीका होना चाहिए।

javascript  arrays 
— Godders
स्रोत
224
इस पूरे पृष्ठ को पढ़ने के बाद, मैं इस निष्कर्ष पर पहुंचा हूं कि आपका स्वयं का सरल-लूप सबसे सरल, सबसे पठनीय और कम से कम त्रुटि वाला है।
— कोकोडको
अगर किसी को कुछ और अधिक उन्नत करने की आवश्यकता है, तो मैंने एक नोड.जेएस लिब बनाया है जो संख्याओं, अक्षरों, नकारात्मक / सकारात्मक सीमाओं, आदि के लिए ऐसा करता है। github.com/jonschlinkert/fill-range । इसका उपयोग
— bith
1
आपको "... 1 ... N" के बजाय लंबाई N की एक सरणी बनाने के लिए "कैसे संपादित करना चाहिए" संपादित करना चाहिए, इसका तात्पर्य है कि 1 से N के मान वाले तत्व होंगे
— स्टीवन लैंडो
7
@StevenLandow ओपी का नाम क्यों बदलना चाहिए? वह मूल्यों के साथ एक सरणी चाहता है 1 ... N?
— आंद्रे एलरिको
अच्छा सवाल, अच्छा शीर्षक, (थोड़े) मूर्खतापूर्ण जवाब।
— बिटरब्लू

जवाबों:

381

यदि मुझे वह मिलता है जो आप के बाद है, तो आप एक संख्या चाहते हैं 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/

— scunliffe
स्रोत
4
प्रभावित होने पर आप मेरे प्रश्न को बेहतर तरीके से वाक्यांश से प्रबंधित कर सकते हैं, आप वास्तव में सही हैं क्योंकि प्रतिबिंब पर मुझे ज़रूरत है सभी संख्याओं की एक सरणी है जिसे मैं बाद में लूप कर सकता हूं :) आपके उत्तर के लिए धन्यवाद।
— गोड्स
147
@Godders: यदि यह वही है जो आप खोज रहे हैं, तो आपको एक सरणी की आवश्यकता क्यों है? एक सरल var n = 45;और तब से पाशन 1..nकरना होगा।
— कैसाब्लांका
3
@Godders - नोट करने के लिए, यदि आप लंबाई M के बनने के बाद सरणी के आकार को कम करना चाहते हैं, तो बस उपयोग करें foo.length = M--- कट ऑफ जानकारी खो गई है। इसे कार्रवाई में देखें ==> jsfiddle.net/ACMXp
— पीटर अज़ताई
24
मैं वास्तव में नहीं मिलता है कि यह उत्तर भी क्यों होता है ... खासकर जब ओपी खुद सहमत है तो ऊपर कुछ टिप्पणियों में इसका कोई मतलब नहीं है क्योंकि वह अभी कर सकता था var n = 45;।
— प्लेक्स
72
@scunliffe: कृपया ध्यान दें, कि new Array(45);"एक 45 तत्व सरणी नहीं बनाता है" (जैसा कि [undefined,undefined,..undefined]करता है उसी अर्थ में )। इसके बजाय "लंबाई = 45" ( [undefined x 45]) के साथ खाली सरणी बनाता है , जैसा कि var foo = []; foo.length=45;। इसीलिए forEach, और mapइस मामले में लागू नहीं होगा।
— टोमेकेल
1307

ES6 में () और कुंजियों () विधियों से एरे का उपयोग किया जाता है ।

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]
— निको रुआत्सलानेन
स्रोत
74
बस एक नोट, यह हमेशा 0 पर शुरू होगा। mapमूल्यों को समायोजित करने के लिए सरणी में श्रृंखला की आवश्यकता होगी ( [...Array(10).keys()].map(x => x++);) 1 पर शुरू करने के लिए
— स्टर्लिंग आर्चर
32
बस परिवर्तन map(x => x++)करने के लिए map(x => ++x)पूर्वता वेतन वृद्धि की वजह से मूल्य वापसी के बाद :) होता है
— ब्रॉक
92
एर क्या !? mapजब आप बस कर सकते हैं तो क्यों slice? [...Array(N+1).keys()].slice(1)
— रॉबिन
19
या उपयोग न करें keysऔर केवल 1 मानचित्र ->Array.from(Array(10)).map((e,i)=>i+1)
— yonatanmn
60
या कुंजियों और मानचित्रों का उपयोग न करें और बस एक मैपिंग फ़ंक्शन पास करेंfrom Array.from(Array(10), (e,i)=>i+1)
— Fabio Antunes
844

आप ऐसा कर सकते हैं:

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.00833987747313190427, 0.9911756622605026, 0.8133423360995948, 0.8377588465465465865865865865465822465865465865465865465465865465465865465465465465465656546546546546546546546546565654

व्याख्या

पहले, ध्यान दें कि Number.call(undefined, N)इसके बराबर है Number(N), जो सिर्फ रिटर्न देता है N। हम बाद में उस तथ्य का उपयोग करेंगे।

Array.apply(null, [undefined, undefined, undefined])के समतुल्य है Array(undefined, undefined, undefined), जो तीन-तत्व ऐरे का निर्माण करता है undefinedऔर प्रत्येक तत्व को असाइन करता है।

आप इसे एन तत्वों के लिए कैसे सामान्य कर सकते हैं ? विचार करें कि कैसे 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)इसके दूसरे पैरामीटर के रूप में एक duck-typed सरणी जैसी ऑब्जेक्ट को भी स्वीकार करता है। यदि हम आह्वान करते हैं 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)? आखिरकार, दोनों अभिव्यक्तियों में अपरिभाषित तत्वों का एक एन-कोड सरणी होगा। अंतर यह है कि पूर्व अभिव्यक्ति में, प्रत्येक तत्व स्पष्ट रूप से अपरिभाषित करने के लिए सेट है, जबकि बाद वाले में, प्रत्येक तत्व कभी भी सेट नहीं किया गया था। के प्रलेखन के अनुसार .map():

callbackकेवल उसी सरणी के अनुक्रमित के लिए लागू किया जाता है जिसने मान निर्दिष्ट किए हैं; यह उन अनुक्रमणिकाओं के लिए लागू नहीं किया गया है जिन्हें हटा दिया गया है या जिन्हें कभी मान निर्दिष्ट नहीं किए गए हैं।

इसलिए, Array(N)अपर्याप्त है; Array(N).map(Number.call, Number)लंबाई का एक अप्रारंभीकृत सरणी में परिणाम होगा एन ।

अनुकूलता

चूंकि यह तकनीक Function.prototype.apply()ईसीएमएस्क्रिप्ट 5 में निर्दिष्ट व्यवहार पर निर्भर करती है , इसलिए यह क्रोम 14 और इंटरनेट एक्सप्लोरर 9 जैसे प्री-ईसीएमएस्क्रिप्ट 5 ब्राउज़र में काम नहीं करेगा ।

— इगोर शुबिन
स्रोत
62
चालाकी के लिए +1 लेकिन कृपया ध्यान दें कि यह लूप के लिए एक आदिम की तुलना में परिमाण का क्रम है: jsperf.com/array-magic-vs-for
— warpech
7
बहुत चालाक - शायद बहुत। इस तथ्य को उजागर करते हुए कि Function.prototype.callपहले पैरामीटर को thisसीधे मैप करने के लिए ऑब्जेक्ट का उपयोग किया जाता है Array.prototype.map, इटरेटर पैरामीटर के पास इसकी एक निश्चित प्रतिभा है।
— नूह फ्रीटास
14
यह वास्तव में, वास्तव में चालाक है (जेएस को गाली देने पर सीमाएं)। यहाँ वास्तव में महत्वपूर्ण अंतर्दृष्टि mapमेरी राय में, अप्रकाशित मूल्यों पर विचारधारा है। एक और संस्करण (और संभवतः थोड़ा स्पष्ट है, हालांकि अब): Array.apply(null, { length: N }).map(function(element, index) { return index; })
— बेन रीच
6
@BenReich इससे भी बेहतर (जेएस दुरुपयोग के स्तर के संदर्भ में): Array.apply(null, new Array(N)).map(function(_,i) { return i; }) या, es6 और तीर के कार्यों के मामले में, और भी कम: Array.apply(null, new Array(N)).map((_,i) => i)
— ओडी
1
यदि यह 1 से शुरू होने वाली सरणी देता है, तो यह वास्तव में ओपी के सवाल का जवाब देगा
— हाई फान
479

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)

सामान्यीकृत रूप के बारे में ध्यान दें

बदलकर काफी किसी भी वांछित मूल्यों के लिए initialised कर सकते हैं उपज सरणियों ऊपर सभी रूपों 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

उदाहरण सभी रूपों को दिखाने वाला

कोड स्निपेट दिखाएं

कस्टम प्रारंभिक फ़ंक्शन के साथ अधिक सामान्य उदाहरण fअर्थात

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

या सरल भी

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

कोड स्निपेट दिखाएं

— अब्देनूर TOUMI
स्रोत
33
सबसे अच्छा जवाब IMHO। यह भी देखें developer.mozilla.org/de/docs/Web/JavaScript/Reference/...
— le_m
5
0 से शुरू होने वाले सरणियों के लिए k ++ का उपयोग करें
— Borgboy
1
यदि आप वेतन वृद्धि चाहते हैं, तो उपयोग न करें k++, उपयोग करें ++k।
— एलेक्स
4
जब तक आप इसे पॉली-फिल नहीं करते हैं, तब तक IE में Bray Array.from समर्थित नहीं है।
— लॉरेन
2
TS संकलक को खुश करने के लिए अप्रयुक्त परम को लेश के साथ बदलने पर विचार करें: Array.from ({लंबाई: 5}, (_, k) => k + 1);
— जर्नीसॉकर
296

Arrays अपनी लंबाई को सहजता से प्रबंधित करता है। जैसा कि वे ट्रैवर्स किए गए हैं, उनके सूचकांक को स्मृति में रखा जा सकता है और उस बिंदु पर संदर्भित किया जा सकता है। यदि एक यादृच्छिक सूचकांक को ज्ञात करने की आवश्यकता है, तो 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

यह आकार एन की लंबाई के लिए प्रारंभिक होना चाहिए और एक पास में सरणी को आबाद करना चाहिए।

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



टिप्पणियों और भ्रम के एवज में, यदि आप वास्तव में 1. उदाहरणों से मान कैप्चर करना चाहते हैं, तो उपरोक्त उदाहरणों में कुछ विकल्प हैं:

  1. यदि सूचकांक उपलब्ध है, तो आप इसे एक (उदाहरण के लिए ++i) बढ़ा सकते हैं ।

  2. उन मामलों में जहां सूचकांक का उपयोग नहीं किया गया है - और संभवतः एक अधिक कुशल तरीका है - अपनी सरणी बनाने के लिए, लेकिन एन का प्रतिनिधित्व N + 1 करें, फिर सामने से हट जाएं।

    इसलिए यदि आप 100 नंबर चाहते हैं: 

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




— vol7ron
स्रोत
मेरा मानना ​​है कि यह उपयोगी है जब संख्याओं के सरणी का उपयोग डेटा के लिए किया जा रहा है जिसे प्राप्त करने के अंत में संसाधित नहीं किया जा सकता है। (एक HTML टेम्पलेट की तरह जो केवल मूल्यों की जगह ले रहा है।)
— नील मुनरो
कोई ऐसा क्यों करेगा यह एक ड्रॉपडाउन सूची को पॉप्युलेट करने के लिए संख्याओं की एक सरणी है, उपयोगकर्ता को 1 से 10 तक का विकल्प देता है। हाथ से एक छोटा सा सरणी [1,2,3 ... 10] समझ में आता है, लेकिन क्या अगर यह 1 से 50 तक है क्या होगा अगर अंतिम संख्या बदल जाए?
— सिगारडॉग
@CigarDoug मुझे शक नहीं है कि एक usecase है, लेकिन मेरा अनुमान है कि यह छोटा है। संख्याओं की एक सरणी की आवश्यकता क्यों होगी, आमतौर पर जब एक सरणी पर एक अनुक्रमणिका का उपयोग लूप निर्माण के हिस्से के रूप में किया जाएगा - या तो लूपिंग बॉडी फ़ंक्शन के तर्क के रूप में, या एक काउंटर चर - इसलिए संख्याओं के सरणी को पकड़ना तुच्छ लगता है केवल निर्दिष्ट चौड़ाई का एक सरणी बनाने के लिए, या केवल एक चर जो ऊपरी सरणी की सीमा रखता है। मैं कुछ उपयोग मामलों के बारे में सोच सकता हूं, लेकिन उनमें से कोई भी ओपी द्वारा व्यक्त नहीं किया गया था
— vol7ron
4
जैसा मैंने कहा, मुझे 10. के माध्यम से संख्या 1 के साथ एक ड्रॉपडाउन को पॉप्युलेट करने की आवश्यकता है। वहाँ एक usecase, मेरा usecase है। मुझे यह पेज कैसा लगा। तो बस हाथ से एक सरणी का निर्माण मेरे द्वारा देखी गई किसी भी चीज़ से कम जटिल नहीं था। इसलिए मेरी आवश्यकताएं ओपी की आवश्यकताएं नहीं हैं। लेकिन मेरा जवाब मेरे पास है।
— सिगारडॉउग
1
@ vol7ron एक usecase है, मेरे पास भी एक है। कोणीय में, पेजिंग में, मैं पाद लेख में उन पृष्ठों को दिखाना चाहता हूं जो क्लिक करने योग्य हैं। इसलिए मैं तत्वों को एक दृश्य में * ngFor = "let पेज ऑफ एनकाउंटर" के साथ लूप करता हूं। आपके पास इसके लिए एक बेहतर उपाय है? BTW, बाहर की जाँच करें stackoverflow.com/questions/36354325/…
— Dalibor
186

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)
);
स्निपेट का विस्तार करें

— नैट
स्रोत
3
+1 यह एक पूरी है, क्योंकि बड़ी हे बुरा की तुलना में बेहतर .join.splitसंस्करण - लेकिन मैं अभी भी लगता है कि विनम्र पाश बेहतर है।
— रॉबिन
मैं मानता हूं @ रॉबिन - एल्गोरिथम जटिलता एक तरफ, विनम्र पाश हमेशा अधिक पठनीय होता है। हालांकि, जावा में लैम्ब्डा के आगमन के साथ, मुझे लगता है कि mapजल्द ही इस तरह की चीजों के लिए एक मानक बन जाएगा।
— नैट
4
const gen = N => [...(function*(){let i=0;while(i<N)yield i++})()]
— रॉबिन
8
मुझे समझ नहीं आता कि क्यों .fill()जरूरी है। मैं देखता हूं कि यह तब है जब मैं नोड के उत्तर पर परीक्षण करता हूं, लेकिन चूंकि Array(1)[0] === undefined, कॉल को भरने के लिए क्या अंतर है Array(1).fill(undefined)?
— डोमिनिक
11
किसी और के लिए जो रुचि रखता है, एरे (एन) और एरे (एन) .fill () के बीच का अंतर यहां
— डोमिनिक
108

बहुत लोकप्रिय अंडरस्कोर _.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); // => []
— इवान
स्रोत
6
— ब्रूनोएलएम
बहुत बढ़िया। मुझे एक बड़ी परियोजना दिखाओ जो वैसे भी अंडरस्कोर का उपयोग नहीं करता है ...
— इरेज़ कोहेन
63 
function range(start, end) {
    var foo = [];
    for (var i = start; i <= end; i++) {
        foo.push(i);
    }
    return foo;
}

फिर कहा जाता है

var foo = range(1, 5);

जावास्क्रिप्ट में ऐसा करने का कोई अंतर्निहित तरीका नहीं है, लेकिन यह पूरी तरह से वैध उपयोगिता फ़ंक्शन है यदि आपको इसे एक बार से अधिक करने की आवश्यकता है।

संपादित करें: मेरी राय में, निम्नलिखित एक बेहतर रेंज फ़ंक्शन है। शायद सिर्फ इसलिए कि मैं 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;
}
— इयान हेनरी
स्रोत
2
यह मुझे पंसद है। यदि आप इसके साथ अतिरिक्त मील जाना चाहते हैं, तो आप इसे Array.prototype.range = function (start, end) {...}; घोषित कर सकते हैं। फिर, आप किसी भी ऐरे ऑब्जेक्ट पर रेंज (x, y) कह सकते हैं।
— जैच रैटनर
8
बल्कि यह की एक विधि बनाने Arrayके बजाय Array.prototypeके रूप में वहाँ कोई कारण नहीं है (यह भी नहीं बल्कि गूंगा माना जा सकता है) हर सरणी पर इस विधि का उपयोग करने के लिए है।
— adamse
9
Array.range(1, 5)शायद अधिक उपयुक्त होगा, लेकिन लेखन के बारे में कुछ अच्छा है [].range(1, 5)।
— मूओगू
"बल्कि इसे Array.prototype के बजाय एरे की विधि बनाएं" - क्या अंतर है? आप एक विशिष्ट सरणी पर ही मतलब है?
— पिलाउ
3
@ पिलाऊ जैसा कि एडम्स कहते हैं, यह अजीब लगता है। यदि यह प्रोटोटाइप पर है, तो आप कह सकते हैं foo = [1, 2, 3]; bar = foo.range(0, 10);। लेकिन यह सिर्फ ... भ्रामक है। bar = Array.range(0, 10)बहुत अधिक स्पष्ट और स्पष्ट है। रेंज का इंस्टेंस से कोई लेना-देना नहीं है, इसलिए इसे इंस्टेंस मेथड बनाने का कोई कारण नहीं है।
— इयान हेनरी
53

Arrayv8 भरने का सबसे तेज़ तरीका है:

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

परिणाम होगा: [0, 1, 2, 3, 4]

— ऐलेक्स डाईकी
स्रोत
वहाँ अतिरिक्त चर के बिना इसे करने के लिए एक रास्ता है _
— ब्लूजैके
@bluejayke no :(
— एलेक्स डाइकिए
कठोर, क्या आप जानते हैं कि .map का स्रोत कोड क्या है? मुझे यकीन है कि नहीं कर रहा हूँ अगर इसकी सैद्धांतिक रूप से हम सिर्फ defineProperty कर सकते हैं पाश के लिए एक से किसी भी तेजी से, लेकिन नहीं करता है, तो उसके बाद और एक नया बनाने
— bluejayke
49

इस सवाल के बहुत सारे जटिल जवाब हैं, लेकिन एक साधारण लाइनर:

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

इसके अलावा, हालांकि ऊपर लिखने के लिए छोटा (और साफ) है, मुझे लगता है कि निम्नलिखित थोड़ा तेज है (अधिकतम लंबाई के लिए:

127, Int8,

255, यूंट 8,

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;

इस कथन के बाद कभी भी, आप मौजूदा दायरे में "गिरफ्तार" चर का उपयोग कर सकते हैं;

यदि आप इसे (कुछ मूल सत्यापन के साथ) एक सरल कार्य करना चाहते हैं: 

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);
— bluejayke
स्रोत
@ जेवीजी लेकिन तेज कार्य के लिए नहीं?
— नीलाजय
बिल्कुल सही। यह इस सरल एक लाइनर हर कोई देख रहा है!
— सुपरसन
@ सुपरपर्सन हालांकि इसका सुपर स्लो :)
— ब्लूजैक
नई fillविधि के साथ आधुनिक जावास्क्रिप्ट :Array(255).fill(0,0,255)
— cacoder
@ कैकोडर कितना तेज़ है, यह कितने ऐरे बनाता है और कितने पुनरावृत्तियों करता है?
— ब्लूजैके
42

आप इसका उपयोग कर सकते हैं:

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]
— nktssh
स्रोत
भी, क्यों नहीं new Array(10).join().split(',').map(function() {return ++arguments[1]});?
— सुपर
1
@ कुछ मामलों में कार्य के लिए मर्प्लेक्स अंदर जेएस इंजन द्वारा अनुकूलित नहीं किया जाएगा (वी 8 के लिए भी सच है, देखें jsperf.com/arguments-vs-array-argument/2 )
— nktssh
4
यह एक दिलचस्प समाधान है, लेकिन यह पूरी तरह से अव्यावहारिक है - सरणी को 3 बार पार्स करना (एक बार join, एक बार split, और एक बार उस चीज़ के लिए जिसे आप वास्तव में करना चाहते हैं) सिर्फ अच्छा नहीं है - मुझे पता है कि वे एहसान से बाहर हो गए हैं किसी कारण के लिए, लेकिन यह सिर्फ एक पुराने जमाने लूप का उपयोग करना बेहतर होगा !
— रॉबिन
42

ES6 यह चाल करेगा:

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

परिणाम देखें:

[...Array(12).keys()].map(number => console.log(number))
स्निपेट का विस्तार करें

— ईसाई
स्रोत
5
वास्तव में, उन्होंने 1..N के लिए कहा, न कि 0..N-1
— याकॉव
1
हाँ, [...Array(N + 1).keys()].slice(1)उपज होगी 1. एन।
— डेविड जी
किसी कारण से यह समाधान एक्सपो (प्रतिक्रिया-मूल) ऐप से प्रोडक्शन संस्करण में काम नहीं करता है। [...Array(N + 1).keys()]यह कोड खाली सरणी देता है, लेकिन विकास मोड के उपयोग से सिर्फ उत्पादन मोड में।
— FabianoLothor
3
.keys()जवाब पहले से ही दिया गया था साल पहले और 500+ upvotes है। आपका जवाब इसमें क्या जोड़ता है?
— Dan Dascalescu
39

यदि आप अपने ऐप में d3.js का उपयोग कर रहे हैं जैसा कि मैं हूं, तो डी 3 एक सहायक फ़ंक्शन प्रदान करता है जो आपके लिए ऐसा करता है।

तो 0 से 4 तक एक सरणी प्राप्त करने के लिए, यह उतना आसान है:

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

और 1 से 5 तक एक सरणी प्राप्त करने के लिए, जैसा कि आप अनुरोध कर रहे थे:

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

की जाँच करें इस ट्यूटोरियल अधिक जानकारी के लिए।

— टायलर रिक
स्रोत
इस टिप्पणी ने मुझे RamdaJS में रेंज () फ़ंक्शन को देखने का विचार दिया , जो कि जेएस लाइब्रेरी मैं अपने वर्तमान प्रोजेक्ट पर काम कर रहा हूं। उत्तम।
— मोर्फ़ैटिक
38

यह संभवतः संख्याओं की एक सरणी उत्पन्न करने का सबसे तेज़ तरीका है

सबसे छोटा

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]
— cocco
स्रोत
8
बेंचमार्क के साथ इन दावों का बैकअप लेना बेहतर होगा। Jsperf.com पर कोशिश करें ।
— मैट बॉल
2
lol jsperf ... pls मैट सिर्फ बीक्युस आपको पसंद नहीं है मेरा जवाब मेरे दूसरों को नीचा दिखाना बंद करें ... stackoverflow.com/a/18344296/2450730 ... कंसोल का उपयोग करें।) () या यह कैसे कहा जाता है ... नॉट जेम्परफ। ।
— cocco
4
FYI करें: जैसा कि जॉन रिइग ने पहली बार कुछ साल पहले प्रकाशित किया था - कुछ प्लेटफार्मों पर (मतलब विंडोज़: पी) समय ब्राउज़र में हर 16ms पर एक बार खिलाया जा रहा है। मल्टीटास्किंग वातावरण में निष्पादन के समय को मापने के साथ अन्य समस्याएं भी हैं। jsperf.com ने परीक्षण चलाना शुरू कर दिया है ताकि वे सांख्यिकीय रूप से सही हों। यह console.time()अंतर्ज्ञान पाने के लिए चलाने के लिए ठीक है , लेकिन एक सबूत के लिए, आपको jsperf.com की आवश्यकता है और यह आपको अन्य लोगों (अलग हार्डवेयर आदि) से क्रॉस-ब्राउज़र परिणाम
— दिखाता है
3
@ यह गलत है:var a=[],b=N;while(b--){a[b]=a+1};
— विंटेजक्सव
5
@ कोको- जबकि अन्य छोरों की तुलना में हमेशा तेज नहीं होता है। कुछ ब्राउज़रों में, लूप के लिए एक घटते समय लूप की तुलना में बहुत धीमा होता है, आप इस तरह के जावास्क्रिप्ट प्रदर्शन के बारे में सामान्य बयान नहीं दे सकते क्योंकि बहुत सारे अलग-अलग अनुकूलन के साथ बहुत सारे कार्यान्वयन हैं। हालांकि, सामान्य तौर पर मुझे आपका दृष्टिकोण पसंद है। ;-)
— रॉबग
32

भरने Arrayका नया तरीका है:

const array = [...Array(5).keys()]
console.log(array)
स्निपेट का विस्तार करें

परिणाम होगा: [0, 1, 2, 3, 4]

— ऐलेक्स डाईकी
स्रोत
यह एक बहुत अच्छा जवाब है, हालांकि अजीबोगरीब सवाल 1-एन से था, 0- (एन -1) से नहीं
— ब्लूजैक
31

आप 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);
// ➜ []
— होंगबो मियाओ
स्रोत
30

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)
चूंकि सरणी के मूल्य वास्तव में इस समाधान का उपयोग करके भरे हुए हैं, mapऔर forEachकाम करेंगे।
— नॉटिमेंटेशनबैकअप
26

अंतिम सारांश रिपोर्ट .. द्रुमम रोल -

यह ES6 का उपयोग किए बिना आकार N (यहाँ 10) का एक सरणी उत्पन्न करने वाला सबसे छोटा कोड है । ऊपर कोको का संस्करण करीब है लेकिन सबसे छोटा नहीं है।

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

लेकिन इस कोड गोल्फ के निर्विवाद विजेता (स्रोत कोड के सबसे कम बाइट्स में एक विशेष समस्या को हल करने की प्रतियोगिता) निको रूट्सटैलन है । एरियर कंस्ट्रक्टर और ईएस 6 स्प्रेड ऑपरेटर का उपयोग करना । (ES6 सिंटैक्स के अधिकांश मान्य टाइपस्क्रिप्ट हैं, लेकिन निम्नलिखित नहीं है। इसलिए इसका उपयोग करते समय विवेकपूर्ण बनें)

[...Array(10).keys()]
— sapy
स्रोत
वोट डाउन क्यों? लंबी उत्तर सूची का पालन करना कठिन है, इसलिए संक्षेप में सोचा।
— चिकित्सा
यह 0-10 नहीं है? [... अर्रे (10) .keys ()]
— ग्रेग
वेबस्टॉर्म सुझाव देता है (नया ऐरे (10))। चाबियाँ (), क्या यह सही है?
— गाइ
(नया ऐरे (10))। कीज़ (), एरियरइंटरेटर {} लौटाता है, न कि सरणी
— सिप्ला जूल
यह एक वैश्विक चर बनाता है a। लूप होना चाहिएfor(var a=[];n--;a[n]=n+1)
— kube
20

ES6 में एक और तरीका है, Array.from का उपयोग करके जो 2 तर्क लेता है, पहला एक सरणी है (इस मामले में 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")
स्निपेट का विस्तार करें

— gafi
स्रोत
अरे यह साफ-सुथरा है, मुझे यह पसंद है। हालांकि यह परिणाम नहीं देता है कि ओपी को उम्मीद है। यह करने के लिए कि इसे लिखा जाना चाहिएArray.from({length:N}, (v,i) => i+1)
— CervEd
लूप के लिए ये नेक्सो हैक अभी भी एक पुराने से 5-10x धीमे हैं ।
— डैन डस्केल्सस्कू
16

नए ऐरे तरीकों का उपयोग करना और =>ईएस 6 मानक (केवल लेखन के समय फ़ायरफ़ॉक्स) से फ़ंक्शन सिंटैक्स ।

छेद भरने के साथ undefined:

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

Array.from"छेद" बदल जाता है undefinedताकि Array.mapअपेक्षा के अनुरूप काम हो:

Array.from(Array(5)).map((_, i) => i + 1)
— szymzet
स्रोत
7
इसी तरह, आप भी ES6 में निम्नलिखित कर सकते हैं: Array.from({length: N}, (v, k) => k)।
— XåpplI'-I0llwlg'I -
Xappli के दृष्टिकोण को प्राथमिकता दी जाती है: Array.from लगभग इस सटीक परिदृश्य के लिए बनाया गया था, और यह एक मैपिंग कॉलबैक का अर्थ है। यह कुछ सरणी की तरह ऐरे तरीकों का उपयोग करने की इच्छा की सामान्य समस्या का एक उत्कृष्ट समाधान है Array.prototype.map.call, जैसे कि मौखिक दृष्टिकोणों का सहारा लिए बिना , जैसे कि NodeLists से लौटे document.querySelectorAll। developer.mozilla.org/en/docs/Web/JavaScript/Reference/…
— Qaribou से जोश
मैं इसे बनाम अंडरस्कोर रेंज सिंटैक्स का वजन कर रहा हूं, और रेंज बेहतर पढ़ता है।
— ओलाला
तकनीकी रूप से ऐसा नहीं है Array.fromजो विरल मूल्यों को अपरिभाषित में बदल देता है। बल्कि Array(5)एक तर्क वस्तु के रूप में कहा जाता है, जो विरल मूल्यों के रूप में विरल मूल्यों की व्याख्या करता है :)
— CervEd
11

ES6 में:

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

ES5:

Array.apply(0, {length: 1000}).map(function(x,i){return i});
— bluejayke
स्रोत
10

बस एक और 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);
स्निपेट का विस्तार करें

— zurfyx
स्रोत
यह अधिक जटिल और ~ 10x से धीमा है [...Array(11).keys()].slice(1)।
— Dan Dascalescu
10

ऐसा लगता है कि वर्तमान में जवाबों की पूरी सूची में एक भी ऐसा स्वाद नहीं है जो किसी जेनरेटर की विशेषता है; तो उपाय है कि:

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})()]
— रोबिन
स्रोत
10

आप 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]

मैं इसे पसंद करता हूं क्योंकि मुझे यह सीधे आगे और आसान लगता है।

— गबेमी कादरी
स्रोत
9

ES6 का उपयोग करना

const generateArray = n => [...Array(n)].map((_, index) => index + 1);
— जेफ्री अब्दुल्ला
स्रोत
धन्यवाद! यह मेरी राय में सबसे सुंदर जवाब था! Array.from(Array(n))यदि प्रसार संचालक समर्थित नहीं है तो कोई भी उपयोग कर सकता है।
— अमित
पहले तो मुझे नहीं पता था कि आपको स्प्रेड ऑपरेटर का उपयोग क्यों करना है, लेकिन फिर मैंने mapएमडीएन पर निम्नलिखित के बारे में पढ़ा : "यह सरणी के लापता तत्वों के लिए नहीं कहा जाता है (यानी, सूचकांक जो कभी सेट नहीं किए गए हैं, जो हैं हटा दिया गया है या जिसे कभी भी एक मूल्य नहीं सौंपा गया है)। "
— बैटमैनज़
9

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 का अधिक सामान्य लागू होने के रूप में पहला arg लेकिन 0 छोटा है।
  • Object.keys(Array.apply(0,Array(3))) // ['0', '1', '2'] फिर एरे की कुंजियाँ प्राप्त करें (काम करता है क्योंकि एर्रेज़ टाइप टाइप सरणी हैं, कुंजी के लिए अनुक्रमित के साथ एक ऑब्जेक्ट है।
  • Object.keys(Array.apply(0,Array(3))).map(Number) // [0, 1, 2] और कुंजियों पर नक्शा, स्ट्रिंग को संख्याओं में परिवर्तित करना।
— mLuby
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.