जावास्क्रिप्ट में एक सरणी की लंबाई को इनिशियलाइज़ कैसे करें?

Question

अधिकांश ट्यूटोरियल जो मैंने जावास्क्रिप्ट में पढ़े हैं ( w3schools और devguru सहित ) सुझाव देते हैं कि आप var test = new Array(4);सिंटैक्स का उपयोग करके ऐरे कंस्ट्रक्टर के पूर्णांक को पास करके एक निश्चित लंबाई के साथ एक सरणी को आरंभीकृत कर सकते हैं ।

इस सिंटैक्स को उदारतापूर्वक मेरी js फ़ाइलों में उपयोग करने के बाद, मैंने फ़ाइलों में से एक को jsLint के माध्यम से चलाया , और यह पूरा हो गया:

त्रुटि: लाइन 1 चरित्र 22 पर समस्या: अपेक्षित ')' और इसके बजाय '4' को देखा।
var परीक्षण = नया ऐरे (4);
लाइन 1 चरित्र 23 में समस्या: अपेक्षित ';' और इसके बजाय ')' को देखा।
var परीक्षण = नया ऐरे (4);
लाइन 1 की समस्या पर समस्या 23: एक पहचानकर्ता की अपेक्षा की और इसके बजाय ')' 'को देखा।

JsLint के अपने व्यवहार की व्याख्या के माध्यम से पढ़ने के बाद , ऐसा लगता है कि jsLint वास्तव में new Array()वाक्यविन्यास को पसंद नहीं करता है , और इसके बजाय []सरणियों की घोषणा करते समय पसंद करता है ।

इसलिए मेरे पास कुछ सवाल हैं:

पहला, क्यों? क्या मैं new Array()इसके बजाय वाक्यविन्यास का उपयोग करके कोई जोखिम उठा रहा हूं ? क्या ब्राउज़र असंगतताएं हैं जिनके बारे में मुझे पता होना चाहिए?

और दूसरा, अगर मैं स्क्वायर ब्रैकेट सिंटैक्स पर स्विच करता हूं, तो क्या किसी ऐरे को घोषित करने और उसकी लंबाई को एक लाइन पर सेट करने का कोई तरीका है, या क्या मुझे ऐसा कुछ करना है:

var test = [];
test.length = 4;

Comments

मानक जेएस भी सामान्य रूप सेउपयोग करने के खिलाफ सलाह देते हैंnew Array() , लेकिन यह निर्दिष्ट आकार के साथ ठीक है। मुझे लगता है कि यह पूरे संदर्भ के माध्यम से कोड स्थिरता के लिए नीचे आता है।

— cregox

अधिक कठोर सरणी संरचनाओं का प्रचार करने की चाह रखने वालों के लिए, टाइप किए गए एरे हैं । ध्यान दें कि प्रदर्शन लाभ अलग

— 23

Answer 1

1. आप लंबाई को इनिशियलाइज़ क्यों करना चाहते हैं? सैद्धांतिक रूप से इसके लिए कोई आवश्यकता नहीं है। यह भ्रामक व्यवहार का भी परिणाम हो सकता है, क्योंकि सभी परीक्षण जो यह lengthपता लगाने के लिए उपयोग करते हैं कि कोई सरणी खाली है या नहीं, यह रिपोर्ट करेगा कि सरणी खाली नहीं है।
   कुछ परीक्षणों से पता चलता है कि बड़े सरणियों की प्रारंभिक लंबाई सेट करना अधिक कुशल हो सकता है यदि सरणी बाद में भरी जाती है, लेकिन प्रदर्शन लाभ (यदि कोई हो) ब्राउज़र से ब्राउज़र में भिन्न होता है।

2. jsLint को पसंद नहीं है new Array()क्योंकि कंस्ट्रक्टर अस्पष्ट है।

   new Array(4);

   लंबाई का एक खाली सरणी बनाता है 4. लेकिन

   new Array('4');

   एक सरणी बनाता है जिसमें मान होता है '4' ।

अपनी टिप्पणी के बारे में: जेएस में आपको सरणी की लंबाई को आरंभीकृत करने की आवश्यकता नहीं है। यह गतिशील रूप से बढ़ता है। आप बस लंबाई को कुछ चर में स्टोर कर सकते हैं, जैसे

var data = [];
var length = 5; // user defined length

for(var i = 0; i < length; i++) {
    data.push(createSomeObject());
}

Comments

सरणी में ऑब्जेक्ट की संख्या उपयोगकर्ता-परिभाषित है, इसलिए मैं उपयोगकर्ता को एक नंबर चुनने दे रहा था, फिर उस कई स्लॉट के साथ सरणी को इनिशियलाइज़ कर रहा था। फिर मैं एक forलूप चलाता हूं जो सरणी की लंबाई पर पुनरावृत्त करता है और इसे भरता है। मुझे लगता है कि जावास्क्रिप्ट में ऐसा करने के अन्य तरीके होंगे, इसलिए असली उत्तर "मैं ऐसा क्यों करना चाहता हूं?" "पुरानी आदतों के कारण जो अन्य भाषाओं में प्रोग्रामिंग करते समय बनाई गई है।" :)

— माइकल मार्टिन-स्मकर

@mlms केवल सरणी लंबाई सेट करने और फिर उस पर पुनरावृति करने के बजाय उपयोगकर्ता-परिभाषित संख्या पर लूप के लिए पुनरावृति होने दें। क्या इससे आपको कोई मतलब नहीं है?

— 43इम विद

<blockquote> आप लंबाई को इनिशियलाइज़ क्यों करना चाहते हैं? सैद्धांतिक रूप से इसके लिए कोई आवश्यकता नहीं है। और सभी परीक्षण जो यह जानने के लिए लंबाई का उपयोग करते हैं कि क्या कोई सरणी खाली है या नहीं विफल हो जाएगी। </ blockquote> उम, प्रदर्शन शायद? किसी सरणी के पहले से मौजूद तत्व को फ़्लाई पर सेट करने की तुलना में तेज़ी से सेट करना तेज़ है।

— कोडहैड

"पुरानी प्रोग्रामिंग आदतों को छोड़ने का समय" टिप्पणी वास्तव में अनावश्यक है। ठीक से संरचित भाषाएं हमेशा परमानंद मोम्बो जाम्बो को बेहतर बनाएगी

— user151496

@ कोडहेड: इस उद्धरण के जवाब में: "मक्खी पर जोड़ने के लिए सरणी के पूर्व-मौजूदा तत्व को सेट करना अधिक तेज़ है।": ध्यान दें कि new Array(10)10 अपरिभाषित तत्वों के साथ एक सरणी नहीं बनाता है। यह केवल 10. की लंबाई के साथ एक खाली सरणी बनाता है। इस सच्चाई का जवाब देखें: stackoverflow.com/questions/18947892/…

— Milimetric

Answer 2

• Array(5) आपको लंबाई 5 के साथ एक सरणी देता है लेकिन कोई मान नहीं है, इसलिए आप इस पर पुनरावृति नहीं कर सकते।

• Array.apply(null, Array(5)).map(function () {}) आपको लंबाई 5 के साथ एक सरणी देता है और मानों के रूप में अपरिभाषित है, अब इसे पुनरावृत्त किया जा सकता है।

• Array.apply(null, Array(5)).map(function (x, i) { return i; }) आपको लंबाई 5 और मान 0,1,2,3,4 के साथ एक सरणी देता है।

• Array(5).forEach(alert)कुछ नहीं करता, Array.apply(null, Array(5)).forEach(alert)आपको 5 अलर्ट देता है

• ES6हमें देता है Array.fromतो अब आप भी उपयोग कर सकते हैंArray.from(Array(5)).forEach(alert)

• यदि आप एक निश्चित मूल्य के साथ आरंभ करना चाहते हैं, तो ये जानना अच्छा है ...
  Array.from('abcde'), Array.from('x'.repeat(5))
  याArray.from({length: 5}, (v, i) => i) // gives [0, 1, 2, 3, 4]

Comments

यह वही है जिसे मैं देख रहा था। मैं एक तार्किक अनुक्रम पर एक नक्शा लागू करना चाहता था; यह करना चाहिए। धन्यवाद!

— jedd.ahyoung

क्यों Array.apply () यह मान के रूप में अपरिभाषित देता है?

— wdanxna

@wdanxna जब Arrayकई तर्क दिए जाते हैं, तो यह argumentsऑब्जेक्ट पर पुनरावृत्त होता है और प्रत्येक मान को नए सरणी में स्पष्ट रूप से लागू करता है। जब आप Array.applyकिसी सरणी के साथ कॉल करते हैं या एक लंबाई के साथ एक ऑब्जेक्ट होता है Array, तो नए सरणी के प्रत्येक मान को स्पष्ट रूप से सेट करने के लिए लंबाई का उपयोग करने जा रहा है। यही कारण है कि Array(5)5 elisions की Array.apply(null, Array(5))एक सरणी देता है , जबकि 5 अपरिभाषित की एक सरणी देता है। अधिक जानकारी के लिए, यह उत्तर देखें ।

— KylePlusPlus

क्या ऐरे (5) और नए ऐरे (5) में अंतर है?

— पेट्र हर्टक

के Array.apply(null, Array(5)) रूप में भी लिखा जा सकता है Array.apply(null, {length: 5})। वास्तव में बहुत अंतर नहीं है, लेकिन उत्तरार्द्ध स्पष्ट रूप से स्पष्ट है कि इरादे की एक सरणी बनाने के लिए है length 5, और एक सरणी से युक्त नहीं है5

— AlexMorley-Finch

Answer 3

ES2015 के.fill() साथ अब आप बस कर सकते हैं:

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

जो कि बहुत अधिक संक्षिप्त है Array.apply(0, new Array(n)).map(i => value)

बिना तर्क के 0अंदर गिरना .fill()और भागना संभव है , जो सरणी को भर देगा undefined। ( हालांकि, यह टाइपस्क्रिप्ट में विफल हो जाएगा )

Comments

तुम हमेशा इस्तेमाल कर सकते हैं @AralRoca polyfill MDN पृष्ठ पर दिए गए, या का उपयोग कर विचार Modernizr ।

— ए.पी.

हां, कृपया टिप्पणी करने से पहले इसे आज़माएं

— एपी।

@GarretWilson और @Christian यह कल्पना में है । When Array is called as a function rather than as a constructor, it also creates and initializes a new Array object. Thus the function call Array(…) is equivalent to the object creation expression new Array(…) with the same arguments

— ए.पी.

@ आप।, शून्य निरर्थक है। क्याArray(n).fill()

— पसियर

@ स्पेसर मुझे नहीं लगता कि 0 बेमानी था। Es6 प्रकार की परिभाषा के अनुसार, यह फ़ंक्शन हस्ताक्षर है: भरण (मान: टी, प्रारंभ ;: संख्या, अंत ?: संख्या): यह; इसलिए भरण मूल्य वैकल्पिक नहीं लगता है। फ़ंक्शन कॉल ऊपर लिखे जाने पर टाइपस्क्रिप्ट संकलन विफल हो जाएगा।

— मीका श्वाब

Answer 4

[...Array(6)].map(x => 0);
// [0, 0, 0, 0, 0, 0]

या

Array(6).fill(0);
// [0, 0, 0, 0, 0, 0]

नोट: आप खाली स्लॉट्स को लूप नहीं कर सकते हैं Array(4).forEach(() => …)

---

या

( टाइपस्क्रिप्ट सुरक्षित )

Array(6).fill(null).map((_, i) => i);
// [0, 1, 2, 3, 4, 5]

---

या

फ़ंक्शन का उपयोग करने वाला क्लासिक तरीका (किसी भी ब्राउज़र में काम करता है)

function NewArray(size) {
    var x = [];
    for (var i = 0; i < size; ++i) {
        x[i] = i;
        return x;
    }
}

var a = NewArray(10);
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

---

नेस्टेड ऐरे बनाना

जब सहज ज्ञान के साथ एक 2 डी सरणी fillबनाने के लिए नए उदाहरण बनाने चाहिए। लेकिन वास्तव में जो होने वाला है, वही सरणी एक संदर्भ के रूप में संग्रहीत किया जाएगा।

var a = Array(3).fill([6]);
// [  [6], [6], [6]  ]

a[0].push(9);
// [  [6, 9], [6, 9], [6, 9]  ]

समाधान

var a = [...Array(3)].map(x => []);

a[0].push(4, 2);
// [  [4, 2], [], []  ]

तो एक 3x2 ऐरे कुछ इस तरह दिखेगा:

[...Array(3)].map(x => Array(2).fill(0));
// [  [0, 0], [0, 0], [0, 0]  ]

---

एन-आयामी सरणी

function NArray(...dimensions) {
    var index = 0;
    function NArrayRec(dims) {
        var first = dims[0], next = dims.slice().splice(1); 
        if(dims.length > 1) 
            return Array(dims[0]).fill(null).map((x, i) => NArrayRec(next ));
        return Array(dims[0]).fill(null).map((x, i) => (index++));
    }
    return NArrayRec(dimensions);
}

var arr = NArray(3, 2, 4);
// [   [  [ 0,  1,  2,  3 ] , [  4,  5,  6,  7]  ],
//     [  [ 8,  9,  10, 11] , [ 12, 13, 14, 15]  ],
//     [  [ 16, 17, 18, 19] , [ 20, 21, 22, 23]  ]   ]

---

एक शतरंज की बिसात पर शुरुआत करें

var Chessboard = [...Array(8)].map((x, j) => {
    return Array(8).fill(null).map((y, i) => {
        return `${String.fromCharCode(65 + i)}${8 - j}`;
    });
});

// [ [A8, B8, C8, D8, E8, F8, G8, H8],
//   [A7, B7, C7, D7, E7, F7, G7, H7],
//   [A6, B6, C6, D6, E6, F6, G6, H6],
//   [A5, B5, C5, D5, E5, F5, G5, H5],
//   [A4, B4, C4, D4, E4, F4, G4, H4],
//   [A3, B3, C3, D3, E3, F3, G3, H3],
//   [A2, B2, C2, D2, E2, F2, G2, H2],
//   [A1, B1, C1, D1, E1, F1, G1, H1] ]

Comments

a[0].push(9); // [ [6, 9], [6], [6] ] होना चाहिए a[0].push(9); // [ [6, 9], [6, 9], [6, 9] ] क्योंकि प्रत्येक नेस्टेड सरणी को एक संदर्भ के रूप में संग्रहीत किया जाता है, इसलिए एक सरणी को बदलना बाकी को प्रभावित करता है। आप इसे गलत समझ सकते हैं, हालांकि मुझे लगता है :)

— Alex_Zhong

@Alex_Zhong ने कहा कि, धन्यवाद, कि एक संपादित में खो दिया

— व्लाद

Answer 5

सबसे छोटा:

[...Array(1000)]

Comments

अपविटेड, लेकिन एक कैविएट, आपको जेएस में एक लाइन को [बिना उपयोग के शुरू नहीं करना चाहिए ;क्योंकि यह ऊपर की लाइन को डीरेल करने का प्रयास करेगा। तो कोड के किसी भी हिस्से में अनुमानित रूप से इस लाइन का उपयोग करने का एक सुरक्षित तरीका होगा:;[...Array(1000)]//.whateverOpsNeeded()

— एपी।

ज़रुरी नहीं। डेवलपर टूल में प्रयास करें। [...Array(5)].map((item, index) => ({ index })) इसे भी आज़माएं:[...Array(5)]; console.log('hello');

— माइकल मैमोलिटी

मल्टी-लाइन js फ़ाइल में इसका उपयोग करने का प्रयास करें। अगर आपकी पहली लाइन है const a = 'a'और अगली लाइन है [...Array(5)].//irrelevent। आपको क्या लगता है कि पहली पंक्ति किसका समाधान करेगी? यह वह होगा const a = 'a'[...Array(5)]जिसमें परिणाम होगा:Uncaught SyntaxError: Unexpected token ...

— एपी।

यह सच है लेकिन इस मामले में मैं कहूंगा कि समस्या कहीं और है, अर्धविराम और लाइनिंग महत्वपूर्ण दिन हैं।

— माइकल मैमोलिटी

@AP उदाहरण बिल्कुल यही कारण है कि कई स्टाइल गाइड प्रत्येक कथन को अर्धविराम के साथ समाप्त करते हैं। const a = 'a'उस मामले में एक त्रुटि होगी। वैसे भी, इसका वास्तव में इस जवाब से कोई लेना-देना नहीं है।

— '10:

Answer 6

ES6 परिचय Array.fromदेता है जो आपको Arrayकिसी भी "सरणी जैसी" या पुनरावृत्त वस्तुओं से बनाने देता है :

Array.from({length: 10}, (x, i) => i);
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

इस मामले {length: 10}में एक "सरणी जैसी" वस्तु की न्यूनतम परिभाषा का प्रतिनिधित्व करता है : एक खाली वस्तु जो केवल lengthपरिभाषित संपत्ति के साथ है।

Array.from परिणामी सरणी पर मैप करने के लिए दूसरे तर्क की अनुमति देता है।

Comments

@ मुझे लगता है कि [... ऐरे (10)] बेहतर stackoverflow.com/a/47929322/4137472 है

— अलेक्जेंडर शटॉ

बेहतर क्यों? ऐरे कंस्ट्रक्टर के उपयोग को हतोत्साहित किया जाता है, और कुछ लिंटर भी शिकायत कर सकते हैं

— क्रिस्टियान ट्रैना

Answer 7

यह लंबाई गुण को 4 से आरंभ करेगा:

var x = [,,,,];

Comments

यह चालाकी है। इसमें कंस्ट्रक्टर का लचीलापन नहीं है, क्योंकि आप लंबाई निर्धारित करने के लिए एक चर का उपयोग नहीं कर सकते हैं, लेकिन यह मेरे प्रश्न का उत्तर देता है क्योंकि मैंने मूल रूप से इसे बनाया था, इसलिए +1।

— माइकल मार्टिन-स्मूकर

कल्पना कीजिए कि 300 आइटम के लिए जब प्रदर्शन वास्तव में मायने रखेगा!

— मार्को लुग्लियो

इतने छोटे आकार के साथ एक सरणी का प्रचार करते समय संभवतः अधिक प्रदर्शन लाभ नहीं होता है। बड़े सरणियों का निर्माण करते समय प्रदर्शन अंतर बेहतर माना जाएगा। और उन मामलों में, उन्हें अल्पविराम से शुरू करना थोड़ा भारी होगा।

— बजे मार्को लुग्लियो

मुझे लगता है कि इससे अंतिम कॉमा, कभी-कभी 4 और कभी-कभी 5 के कारण अलग-अलग ब्राउज़रों में अलग-अलग परिणाम

— मिलेंगे

कैसे के बारे में var size = 42; var myArray = eval("["+",".repeat(size)+"]");? (इतना गंभीर नहीं;)

— xoxox

Answer 8

मुझे आश्चर्य है कि एक कार्यात्मक समाधान का सुझाव नहीं दिया गया है जो आपको एक पंक्ति में लंबाई निर्धारित करने की अनुमति देता है। निम्नलिखित UnderscoreJS पर आधारित है:

var test = _.map(_.range(4), function () { return undefined; });
console.log(test.length);

ऊपर वर्णित कारणों के लिए, मैं इसे तब तक करने से बचूंगा जब तक कि मैं किसी विशिष्ट मान के लिए सरणी को प्रारंभ नहीं करना चाहता। यह ध्यान रखना दिलचस्प है कि लो-डैश और लेज़ी सहित रेंज को लागू करने वाले अन्य पुस्तकालय हैं, जिनमें अलग-अलग प्रदर्शन विशेषताएं हो सकती हैं।

Comments

अंडरस्कोर काले जादू वास्तव में यहाँ की जरूरत नहीं है। निर्भरताएं चीनी की तरह होती हैं, यह पहली बार में मीठा लगता है, लेकिन इससे पहले कि आप जानते हैं कि आपको मधुमेह है।

— रोमेन विंसेंट

Answer 9

कृपया लोग अभी तक अपनी पुरानी आदतों को न छोड़ें। स्मृति को आवंटित करने के बीच गति में एक बड़ा अंतर है, फिर उस सरणी (पुरानी के रूप में) में प्रविष्टियों के साथ काम करना, और इसे कई बार आवंटित करना एक सरणी के रूप में बढ़ता है (जो अनिवार्य रूप से अन्य सुझाई गई विधियों के साथ हुड के तहत क्या करता है) ।

इस मामले में से कोई भी नहीं, जब तक आप बड़े सरणियों के साथ कुछ ठंडा नहीं करना चाहते। फिर करता है।

यह देखते हुए कि अभी भी जेएस में कोई विकल्प नहीं है, फिलहाल किसी सरणी की प्रारंभिक क्षमता निर्धारित करने के लिए, मैं निम्नलिखित का उपयोग करता हूं ...

var newArrayWithSize = function(size) {
  this.standard = this.standard||[];
  for (var add = size-this.standard.length; add>0; add--) {
   this.standard.push(undefined);// or whatever
  }
  return this.standard.slice(0,size);
}

इसमें शामिल हैं:

• यह विधि फ़ंक्शन के पहले कॉल के लिए दूसरों के रूप में लंबे समय तक लेती है, लेकिन बाद में कॉल करने के लिए बहुत कम समय (जब तक कि बड़े सरणी के लिए नहीं पूछती)।
• standardसरणी स्थायी रूप से सबसे बड़ा सरणी आप के लिए कहा है के रूप में ज्यादा स्थान के रूप में आरक्षित है।

लेकिन अगर यह वहाँ है जो आप कर रहे हैं के साथ फिट बैठता है एक भुगतान हो सकता है। अनौपचारिक समय डालता है

for (var n=10000;n>0;n--) {var b = newArrayWithSize(10000);b[0]=0;}

बहुत तेज़ी से (10000 के लिए लगभग 50ms दिए गए कि n = 1000000 के साथ इसमें लगभग 5 सेकंड लगे), और

for (var n=10000;n>0;n--) {
  var b = [];for (var add=10000;add>0;add--) {
    b.push(undefined);
  }
}

एक मिनट में (एक ही क्रोम कंसोल पर 10000 के लिए लगभग 90 सेकंड, या लगभग 2000 गुना धीमा)। यह सिर्फ आवंटन नहीं होगा, बल्कि लूप आदि के लिए 10000 पुश भी होगा।

Comments

यदि हर बार जब आप उस सरणी के अंत तक पहुँचते हैं जिसे आप इसे डुप्लिकेट करते हैं, तो n मान डालने की जटिलता अभी भी O (n) है, इसलिए जटिलता में अंतर नहीं है (लेकिन यह धीमा है)।

— तोमर वोल्बर्ग

अच्छी तरह से पकड़ा @TomerWolberg, मैं अपने शब्द बदल दिया है। यह बात है कि क्या स्लाइस द्वारा किसी व्यक्ति के सदस्य के प्रारंभिककरण / कॉपी की तुलना में पुश पद्धति में उच्च जटिलता है। AFAIK कि वे दोनों निरंतर समय हैं, बहुत कम से कम वे हो सकते हैं इसलिए मैंने इसके बजाय 'गति' शब्द का उपयोग किया है।

— wils

Answer 10

(यह शायद एक टिप्पणी के रूप में बेहतर था, लेकिन बहुत लंबा हो गया)

इसलिए, इसे पढ़ने के बाद मैं उत्सुक था कि क्या पूर्व-आवंटन वास्तव में तेज था, क्योंकि सिद्धांत रूप में यह होना चाहिए। हालाँकि, इस ब्लॉग ने इसके खिलाफ कुछ सुझाव दिए हैं http://www.html5rocks.com/en/tutorials/speed/v8/ ।

इसलिए अभी भी अनिश्चित होने के कारण, मैंने इसे परीक्षण के लिए रखा। और जैसा कि यह पता चला है कि यह वास्तव में धीमा है।

var time = Date.now();
var temp = [];
for(var i=0;i<100000;i++){
    temp[i]=i;
}
console.log(Date.now()-time);


var time = Date.now();
var temp2 = new Array(100000);
for(var i=0;i<100000;i++){
    temp2[i] = i;
}
console.log(Date.now()-time); 

यह कोड कुछ आकस्मिक रन के बाद निम्न देता है:

$ node main.js 
9
16
$ node main.js 
8
14
$ node main.js 
7
20
$ node main.js 
9
14
$ node main.js 
9
19

Comments

दिलचस्प है, यह अप्रत्याशित लग रहा था, इसलिए मैंने एक JSPerf परीक्षण किया । Chrome परिणाम आपके नोड परीक्षणों से मेल खाते हैं, लेकिन जब आप सरणी के लिए स्थान आवंटित करते हैं तो फ़ायरफ़ॉक्स और IE थोड़ा तेज़ होते हैं।

— माइकल मार्टिन-स्मकर

@ MichaelMartin-Smucker रुको ... इसका मतलब यह है कि V8 वास्तव में पूरी तरह से अनुकूलित और सही नहीं है?!?! : पी

— ज़ेब मैककॉरल

@ MichaelMartin-Smucker - मैंने अभी-अभी क्रोम संस्करण 42.0.2311.90 में आपका jsperf चलाया (विशिष्ट होने के लिए - Chrome में परीक्षण 42.0.2311.90 Windows Server 2008 R2 / 7 64-बिट पर 32-बिट) और गतिशील रूप से आकार का सरणी 69% धीमा था ।

— येलन

डिट्टो। (मैंने मूल नोड परीक्षण लिखा था) क्रोम में 42.0.2311.90 खिड़कियों पर गतिशील रूप से आकार 81% धीमा था :)। लेकिन हमारे मूल परीक्षण अब एक साल पहले खत्म हो गए थे। समय

— फिसलन भरा

आकर्षक ... jsperf पर परिणामों से ऐसा लगता है कि पूर्व-आवंटित को Chrome 38 में भारी बढ़ावा मिला है। भविष्य!

— माइकल मार्टिन-स्मूकर

Answer 11

var arr=[];
arr[5]=0;
alert("length="+arr.length); // gives 6

Comments

हां, हालांकि कंसोल.लॉग (गिरफ्तार) देता है [5: 0]यह एक विरल सरणी है और शायद वह नहीं है जो चाहता था।

— dreftymac

Answer 12

यहाँ एक और उपाय है

var arr = Array.apply( null, { length: 4 } );
arr;  // [undefined, undefined, undefined, undefined] (in Chrome)
arr.length; // 4

का पहला तर्क apply()यह एक बाध्यकारी वस्तु है, जिसकी हमें यहाँ कोई परवाह नहीं है, इसलिए हम इसे निर्धारित करते हैं null।

Array.apply(..)Array(..)फ़ंक्शन को कॉल कर रहा है और { length: 3 }ऑब्जेक्ट वैल्यू को उसके तर्कों के रूप में फैला रहा है ।

Comments

मुझे समझ में नहीं आ रहा है कि इस उत्तर को क्यों ठुकरा दिया गया। यह वास्तव में एक अच्छा हैक है। मतलब आप new Array(n)इस तरह एक सरणी को इनिशियलाइज़ करने के लिए उपयोग नहीं कर सकते हैं new Array(n).map(function(notUsed,index){...}), लेकिन इस दृष्टिकोण के साथ, जैसा कि @zangw ने उल्लेख किया है, आप इसे कर सकते हैं। मुझ से +1।

— विक्टर.पिलवोडा

Answer 13

एरे कंस्ट्रक्टर में अस्पष्ट सिंटैक्स होता है होता है, और जेएसएलआईएनटी सिर्फ आपकी भावनाओं को आहत करता है।

इसके अलावा, आपका उदाहरण कोड टूट गया है, दूसरा varविवरण एक बढ़ाएगा SyntaxError। आप lengthएरे की संपत्ति सेट कर रहे हैं test, इसलिए दूसरे की कोई आवश्यकता नहीं है var।

जहाँ तक आपके विकल्प जाते हैं, array.lengthकेवल "स्वच्छ" है। प्रश्न है, आपको पहले स्थान पर आकार निर्धारित करने की आवश्यकता क्यों है? उस निर्भरता से छुटकारा पाने के लिए अपने कोड को फिर से भरने की कोशिश करें।

Comments

वाह, उस दूसरे पर अच्छी नज़र var test। यह मेरी ओर से कुछ मैला-नकल और चिपकाने वाला था।

— माइकल मार्टिन-स्मूकर

@IvoWetzel, आप प्रदर्शन को बेहतर बनाने के लिए आकार निर्धारित करना चाहते हैं। जेएस सरणियाँ गतिशील सरणियाँ हैं । यदि आप आकार सेट नहीं करते (या बल्कि, यह क्षमता है), JS डिफ़ॉल्ट आकार की एक सरणी आवंटित करेगा। यदि आप फिट होने की तुलना में अधिक तत्व जोड़ते हैं, तो उसे सरणी को बढ़ाना होगा, जिसका अर्थ है कि यह आंतरिक रूप से एक नया सरणी आवंटित करेगा और फिर सभी तत्वों को कॉपी करेगा।

— डोमी

Answer 14

यह मानते हुए कि ऐरे की लंबाई स्थिर है। जावास्क्रिप्ट में, यह वही है जो हम करते हैं:

const intialArray = new Array(specify the value);

Answer 15

जैसा कि ऊपर बताया गया है, का उपयोग new Array(size)करना कुछ खतरनाक है। इसे सीधे उपयोग करने के बजाय, इसे "सरणी क्रिएटर फ़ंक्शन" के अंदर रखें। आप आसानी से सुनिश्चित कर सकते हैं कि यह फ़ंक्शन बग-मुक्त है और आप new Array(size)सीधे कॉल करने के खतरे से बचते हैं। इसके अलावा, आप इसे एक वैकल्पिक डिफ़ॉल्ट प्रारंभिक मूल्य दे सकते हैं। यह createArrayफ़ंक्शन ठीक यही करता है:

function createArray(size, defaultVal) {
    var arr = new Array(size);
    if (arguments.length == 2) {
        // optional default value
        for (int i = 0; i < size; ++i) {
            arr[i] = defaultVal;
        }
    }
    return arr;
}

Answer 16

अधिकांश उत्तरों में यह fillसरणी के लिए अनुशंसित है क्योंकि अन्यथा "आप इस पर पुनरावृति नहीं कर सकते" , लेकिन यह सच नहीं है। आप एक खाली सरणी को पुनरावृत्त कर सकते हैं, बस साथ नहीं forEach। जबकि छोरों, छोरों के लिए और मैं छोरों के लिए ठीक काम करते हैं।

const count = Array(5);

काम नहीं करता।

console.log('---for each loop:---');
count.forEach((empty, index) => {
    console.log(`counting ${index}`);
});

ये काम:

console.log('---for of loop:---');
for (let [index, empty] of count.entries()) {
  console.log(`counting for of loop ${index}`);
}

console.log('---for i loop:---');
for (let i = 0, il = count.length; i < il; ++i) {
  console.log(`counting for i loop ${i}`);
}

console.log('---while loop:---');
let index = 0;
while (index < count.length) { 
  console.log(`counting while loop ${index}`); 
  index++; 
}

इस फिडल को चेक करेंउपरोक्त उदाहरणों के साथ ।

इसके अलावा कोणीय *ngForरिक्त सरणी के साथ ठीक काम करता है:

<li *ngFor="let empty of count; let i = index" [ngClass]="
  <span>Counting with *ngFor {{i}}</span>
</li>

Answer 17

आप उपयोग करके सरणी की लंबाई निर्धारित कर सकते हैं array.length = youValue

तो यह होगा

var myArray = [];
myArray.length = yourValue;

Answer 18

आपके new Arrayद्वारा उपयोग किए जाने वाले कारण को इस कोड द्वारा प्रदर्शित नहीं किया जाना चाहिए :

var Array = function () {};

var x = new Array(4);

alert(x.length);  // undefined...

कुछ अन्य कोड एरे चर के साथ गड़बड़ कर सकते हैं । मुझे पता है कि यह थोड़ा दूर है कि कोई भी ऐसा कोड लिखेगा, लेकिन फिर भी ...

साथ ही, जैसा कि फेलिक्स किंग ने कहा, इंटरफ़ेस थोड़ा असंगत है, और कुछ बहुत मुश्किल से ट्रैक-डाउन बग्स को जन्म दे सकता है।

यदि आप लंबाई = x के साथ एक सरणी चाहते थे, तो अपरिभाषित से भरा हुआ था (जैसा new Array(x)कि आप करेंगे), आप ऐसा कर सकते हैं:

var x = 4;
var myArray = [];
myArray[x - 1] = undefined;

alert(myArray.length); // 4

Comments

इस तर्क के अनुसार आपको उपयोग नहीं करना चाहिए alertऔर undefined, क्योंकि कुछ अन्य कोड उनके साथ गड़बड़ कर सकते हैं। दूसरा उदाहरण की तुलना में कम पठनीय है new Array(4), और आपको एक ही परिणाम नहीं देता है: jsfiddle.net/73fKd

— एलेक्सी लेब्डेव

यह उत्तर विचित्र है

— मार्को डेमायो

आप जावास्क्रिप्ट में वैश्विक वस्तुओं के साथ खिलवाड़ करने वाले लोगों से बच नहीं सकते; बस ऐसा न करें या फ्रेमवर्क का उपयोग न करें जहां लोग ऐसा करते हैं।

— रिचर्ड कॉनामॅकर

वर्तमान में क्रोम उत्तर में: j = new Array (4); j.length; // परिणाम 4

— पैरिस