दिलचस्प पोस्ट
क्या मुझे सारिका या इंट की प्राथमिक कुंजी के साथ तालिका तैयार करनी चाहिए? मैक्रो नामों के लिए वैध वर्ण क्या हैं? क्या यह संभव है "टी के एक सामान्य सरणी एक varargs पैरामीटर के लिए बनाया है" संकलक चेतावनी? ऑडियो फ़ाइल को कैसे रिवर्स करना है? UISearchBar नमूना कोड अतिप्रवाह सॉर्ट चरण बफ़ेड डेटा उपयोग आंतरिक सीमा से अधिक है डिस्पैचर का उपयोग करने से रोकें JQuery, स्प्रिंग एमवीसी @ अनुरोध बॉडी और जेएसओएन – यह एक साथ काम करता है मुझे एक अरेंज ऑफ़ वेरियंट्स के लिए एक रेंज प्रदान करने में समस्या क्यों हो रही है? क्या किसी संपत्ति के नाम के समान नाम होना चाहिए? जावा में एक 2d सरणी कॉपी करें आपको C ++ 11 में स्थिरता क्षमता का उपयोग कब करना चाहिए? कुकीज़ को रेखांकित करता है, प्रारंभ तिथि सेट करें और तिथि की समय सीमा समाप्त करें ब्राउज़र पॉपअप ब्लॉकर से बचें जावास्क्रिप्ट में घुंघराले ब्रेसिज़ क्या मतलब है?

एक जावास्क्रिप्ट एआरआर बनाएँ जिसमें 1 … एन

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

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

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

Solutions Collecting From Web of "एक जावास्क्रिप्ट एआरआर बनाएँ जिसमें 1 … एन"

यदि मुझे लगता है कि आप क्या कर रहे हैं, तो आप नंबर 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/

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

 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.70826 94901619107, 0.9572225909214467, 0.8586748542729765, 0.8653848143294454, 0.008339877473190427, 0.9911756622605026, 0.8133423360995948, 0.8377588465809822, 0.5577575915958732, 0.16363654541783035]

व्याख्या

सबसे पहले, ध्यान दें कि Number.call(undefined, N) Number(N) बराबर है, जो अभी 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) एक डुक-टाइप एरे-ऑब्जेक्ट ऑब्जेक्ट को दूसरे पैरामीटर के रूप में भी स्वीकार करता है। अगर हम Array.apply(null, { length: N }) आमंत्रित करते हैं। 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; } 

अब हमारे पास एक एन -एलिमेंट सरणी है, जिसमें प्रत्येक तत्व को undefined सेट किया गया है। जब हम फोन पर कॉल करें .map(callback, thisArg) यह .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 मूल्यांकन करता है। यह सरणी पूर्ण करता है जिसका तत्व उनके सूचकांक के समान है I

Array(N) की बजाय Array(N) की Array.apply(null, {length: N}) कारण क्यों जाएं? Array.apply(null, {length: N}) Array(N) ? सब के बाद, दोनों एक्सप्रेशंस के परिणामस्वरूप अनिर्धारित तत्वों की एक एन- एलिमेंट सरणी होगी। अंतर यह है कि पूर्व अभिव्यक्ति में, प्रत्येक तत्व स्पष्ट रूप से अपरिभाषित निर्धारित होता है, जबकि बाद में प्रत्येक तत्व कभी भी सेट नहीं होता था। .map() के प्रलेखन के अनुसार:

callback केवल सरणी के इंडेक्स के लिए लागू किया जाता है, जो कि मूल्य निर्दिष्ट करता है; अनुक्रमितों के लिए इसे लागू नहीं किया जाता है जिन्हें हटा दिया गया है या जिन्हें कभी मूल्य नहीं सौंपा गया है

इसलिए, Array(N) अपर्याप्त है; Array(N).map(Number.call, Number) का परिणाम नं

अनुकूलता

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

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] 

ES6 में आप यह कर सकते हैं:

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

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

संपादित करें: Array(45) से Array(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); // => [] 

सरल और संक्षिप्त तरीका:

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

इस प्रकार:

  Array.from({length: N}, (v, k) => k+1); // [1,2,3,...,N] 
 const range = (N) => Array.from({length: N}, (v, k) => k+1) ; console.log( range(5) ) 
 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; } 

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

 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] 

यदि आप अपने ऐप में 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] 

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

मुझे पता है कि आपका प्रश्न संख्यात्मक रूप से सरणी में आना चाहता है, लेकिन मैं अनिश्चित हूँ कि आप ऐसा क्यों करना चाहते हैं।

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

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

भरें / मानचित्र

आप पहले की जरूरत के सरणी का आकार बना सकते हैं, इसे अपरिभाषित कर सकते हैं और फिर map का उपयोग करके एक नया सरणी बना सकते हैं, जो सूचकांक में प्रत्येक तत्व को सेट करता है।

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

संख्याओं की एक सरणी उत्पन्न करने के लिए यह सबसे तेज तरीका है

सबसे छोटा

 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) तुलना में तेज़ है 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] 

ध्यान दें : apply , map , joinsplit …. srsly ??? यह बहुत धीमी है !!!!!! और संगतता ???

ES2015 / ES6 फैल ऑपरेटर का उपयोग करना

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

अंतिम सारांश रिपोर्ट .. Drrruummm Rolll –

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

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

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

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

ईएस 6 में एक और तरीका है, अर्रे का इस्तेमाल करके। 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") 

यदि आप रद्दी का प्रयोग कर रहे हैं, तो आप _.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 मानक से नए अर्रे विधियों और => फ़ंक्शन सिंटैक्स का उपयोग करना (केवल लिखने के समय फ़ायरफ़ॉक्स)

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

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

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

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

इसे इस्तेमाल करे:

 var foo = [1, 2, 3, 4, 5]; 

यदि आप कॉफी स्क्रिप्ट का प्रयोग कर रहे हैं, तो आप ऐसा करके एक सीमा बना सकते हैं:

 var foo = [1..5]; 

अन्यथा, यदि आप वेनिला जावास्क्रिप्ट का उपयोग कर रहे हैं, तो आपको एक लूप का उपयोग करना होगा यदि आप किसी सरणी को एक चर लंबाई तक प्रारंभ करना चाहते हैं।

मैं एक कार्यात्मक समाधान की तलाश कर रहा था और मैं इसके साथ समाप्त हुआ:

 function numbers(min, max) { return Array(max-min+2).join().split(',').map(function(e, i) { return min+i; }); } console.log(numbers(1, 9)); 

नोट: join().split(',') विरल सरणी को एक निकटतम रूप में बदल देती है

निम्नलिखित फ़ंक्शन संख्याओं के साथ आबादी वाली एक सरणी देता है:

 var createArrayOfNumbers = function (n) { return Array.apply(null, new Array(n)).map(function (empty, index) { return index; }); }; 

ध्यान दें कि सरणी निर्माता के साथ बनाई गई सरणी में छेद होते हैं, इसलिए इसे नक्शा जैसे सरणी फ़ंक्शंस के साथ नहीं किया जा सकता। अतः Array.apply फ़ंक्शन का उपयोग कर।

स्ट्रिंग संस्करण की तुलना में थोड़ा आसान है:

 // create range by N Array(N).join(0).split(0); // create a range starting with 0 as the value Array(7).join(0).split(0).map(Number.call, Number); // [0, 1, 2, 3, 4, 5, 6] 

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'] तो सरणी की चाबियाँ पाएं (काम करती है क्योंकि एरेज सरणी के प्रकार हैं एक ऑब्जेक्ट कुंजी के लिए अनुक्रमित
  • Object.keys(Array.apply(0,Array(3))).map(Number) // [0, 1, 2] और चाबियों पर नक्शा, स्ट्रिंग्स को नंबरों में कनवर्ट करना

बस एक और ES6 संस्करण

Array.from प्रयोग करके दूसरा वैकल्पिक तर्क:

Array.from (सरणी [जैसे, [[mapFn [, thisArg]])

हम रिक्त Array(10) स्थितियों से क्रमांकित सरणी बना सकते हैं:

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

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

मुझे रिकर्सिव फ़ंक्शंस के आधार पर कोई समाधान नहीं मिला (और कभी भी रिकर्सिव फ़ंक्शन नहीं लिखा गया) तो मेरा प्रयास है

ध्यान दें कि array.push (कुछ) सरणी की नई लंबाई देता है:

 (a=[]).push(a.push(a.push(0))) // a = [0, 1, 2] 

और एक रिकर्सिव फ़ंक्शन के साथ:

 var a = (function f(s,e,a,n){return ((n?n:n=s)>e)?a:f(s,e,a?a:a=[],a.push(n)+s)})(start,end) // eg, start = 1, end = 5 

संपादित करें: दो अन्य समाधान

 var a = Object.keys(new Int8Array(6)).map(Number).slice(1) 

तथा

 var a = [] var i=setInterval(function(){a.length===5?clearInterval(i):a.push(a.length+1)}) 
 for(var i,a=[i=0];i<10;a[i++]=i); 

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

उपरोक्त सुधार:

 var range = function (n) { return Array(n).join().split(',').map(function(e, i) { return i; }); } 

कोई भी निम्न विकल्प प्राप्त कर सकता है:

1) Array.init को मान v

 var arrayInitTo = function (n,v) { return Array(n).join().split(',').map(function() { return v; }); }; 

2) एक उलट श्रेणी प्राप्त करें:

 var rangeRev = function (n) { return Array(n).join().split(',').map(function() { return n--; }); }; 
 Array(8).fill(0).map(Number.call, Number) 

Number.call चाल को क्लिक करें, लेकिन थोड़े से छोटा करने के लिए fill() का उपयोग करें। केवल ES6 और इसके बाद के संस्करण के साथ काम करता है

आप फ़ंक्शन जनरेटर या फ़ंक्शन * अभिव्यक्ति का उपयोग कर सकते हैं यहां [ https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/function ] के बारे में और [ https://developer.mozilla.org/en-en/ ] पर फ़ंक्शन जेनरेटर लिंक का एक संदर्भ है। यूएस / डॉक्स / वेब / जावास्क्रिप्ट / संदर्भ / वक्तव्य / फ़ंक्शन ]

let a = 1, b = 10;

function* range(a, b) { for (var i = a; i <= b; ++i) yield i; }

Array.from(range(a, b)); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

[...range(a, b)] // [1, 2, 3, 4, 5, 6, 7, 8, 9, 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})()] 

चलो मेरा हिस्सा: पी

 var i = 10; Math.pow(2, i).toString(2).split('').map((i,j) => j) 

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

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