जावास्क्रिप्ट सरणी घोषित करते समय "एरे ()" और "[]" में क्या अंतर है?

Question

इस तरह एक सरणी घोषित करने के बीच वास्तविक अंतर क्या है:

var myArray = new Array();

तथा

var myArray = [];

Comments

[]टोकन ARRAY_INIT:; new Arrayटोकन NEW, IDENTIFIER:; new Array()टोकन:NEW, IDENTIFIER, CALL

— noobninja

Answer 1

एक अंतर है, लेकिन उस उदाहरण में कोई अंतर नहीं है।

अधिक क्रिया विधि का उपयोग करना: new Array()मापदंडों में एक अतिरिक्त विकल्प होता है: यदि आप एक संख्या को कंस्ट्रक्टर के पास करते हैं, तो आपको उस लंबाई का एक सरणी मिलेगा:

x = new Array(5);
alert(x.length); // 5

सरणी बनाने के लिए विभिन्न तरीकों का वर्णन करने के लिए:

var a = [],            // these are the same
    b = new Array(),   // a and b are arrays with length 0

    c = ['foo', 'bar'],           // these are the same
    d = new Array('foo', 'bar'),  // c and d are arrays with 2 strings

    // these are different:
    e = [3]             // e.length == 1, e[0] == 3
    f = new Array(3),   // f.length == 3, f[0] == undefined

;

एक और अंतर यह है कि जब new Array()आप उपयोग करते हैं तो सरणी के आकार को सेट करने में सक्षम होते हैं, जो स्टैक के आकार को प्रभावित करता है। यदि आप स्टैक ओवरफ्लो ( Array.push बनाम Array.unshift का प्रदर्शन ) हो रहे हैं तो यह उपयोगी हो सकता है, जो तब होता है जब सरणी का आकार स्टैक के आकार से अधिक हो जाता है, और इसे फिर से बनाना पड़ता है। इसलिए वास्तव में, उपयोग के मामले के आधार पर, उपयोग करते समय एक प्रदर्शन वृद्धि हो सकती हैnew Array() सकती है क्योंकि आप ओवरफ्लो को होने से रोक सकते हैं।

जैसा कि इस जवाब में कहा गया है , new Array(5)वास्तव undefinedमें सरणी में पांच आइटम नहीं जोड़ेंगे । यह केवल पाँच वस्तुओं के लिए स्थान जोड़ता है। ज्ञात हो कि Arrayइस तरह से उपयोग करने से array.lengthगणनाओं पर भरोसा करना मुश्किल हो जाता है ।

Comments

यह थोड़ा गलत है। नए ऐरे () और [] के बीच एक बहुत महत्वपूर्ण अंतर है मैं अपने उत्तर में बताऊंगा।

— कोडरजियो

लेकिन जैसा कि आपके उत्तर में उल्लेख किया गया है, यह केवल तभी अलग है जब आप पूरी तरह से पागल हैं और एरे फ़ंक्शन को ओवरराइट कर दें ..?

— निकफ

खैर महत्व यह है कि नए ऑपरेटर का उपयोग करने से दुभाषिया वैश्विक स्तर पर जाने के लिए सभी प्रकार के अतिरिक्त कदम उठाने का कारण बनता है, निर्माणकर्ता को देखें, निर्माता को बुलाएं और परिणाम असाइन करें ... जो कि बहुसंख्यक मामले में होने वाला है। एक रनटाइम सरणी। आप केवल [] का उपयोग करके वैश्विक कंस्ट्रक्टर की तलाश में ओवरहेड से बच सकते हैं। यह छोटा लग सकता है, लेकिन जब आप अपने ऐप में रियल-टाइम परफॉर्मेंस के लिए शूटिंग कर रहे होते हैं, तो इससे फर्क पड़ सकता है।

— कोडरजियो

एक बड़ा प्रदर्शन अंतर है: jsperf.com/create-an-array-of-initial-size/2

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

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

— निक

Answer 2

निहित सरणी और सरणी निर्माता के साथ एक सरणी बनाने के बीच का अंतर सूक्ष्म लेकिन महत्वपूर्ण है।

जब आप एक सरणी का उपयोग कर बनाते हैं

var a = [];

आप दुभाषिया को एक नया रनटाइम सरणी बनाने के लिए कह रहे हैं। कोई अतिरिक्त प्रसंस्करण आवश्यक नहीं है। किया हुआ।

यदि तुम प्रयोग करते हो:

var a = new Array();

आप दुभाषिया से कह रहे हैं, मैं कंस्ट्रक्टर को फोन करना चाहता हूं "Array " और एक वस्तु उत्पन्न करता । यह तब आपके निष्पादन संदर्भ के माध्यम से देखता है कि कंस्ट्रक्टर को कॉल करने के लिए, और उसे कॉल करने के लिए, अपनी सरणी बनाते हुए।

आप सोच सकते हैं "ठीक है, यह कोई फर्क नहीं पड़ता। वे समान हैं!"। दुर्भाग्य से आप इसकी गारंटी नहीं दे सकते।

निम्नलिखित उदाहरण लें:

function Array() {
    this.is = 'SPARTA';
}

var a = new Array();
var b = [];

alert(a.is);  // => 'SPARTA'
alert(b.is);  // => undefined
a.push('Woa'); // => TypeError: a.push is not a function
b.push('Woa'); // => 1 (OK)

उपरोक्त उदाहरण में, पहला कॉल 'स्पार्टा' को अलर्ट करेगा जैसा कि आप अपेक्षा करेंगे। दूसरा नहीं होगा। आप अपरिभाषित देखकर समाप्त हो जाएंगे। आप यह भी ध्यान देंगे कि बी में सभी मूल ऐरे ऑब्जेक्ट फ़ंक्शन शामिल हैं push, जैसे कि अन्य नहीं है।

जब आप ऐसा होने की उम्मीद कर सकते हैं, तो यह इस तथ्य को दिखाता है कि []जैसा है वैसा नहीं है new Array()।

[]यदि आप जानते हैं कि आप सिर्फ एक सरणी चाहते हैं, तो इसका उपयोग करना शायद सबसे अच्छा है । मैं यह भी सुझाव नहीं देता कि चारों ओर जाकर ऐरे को फिर से परिभाषित करना ...

Comments

अच्छा, यह जानकर मुझे अच्छा लगा। किस तरह का व्यक्ति सरणी वर्ग को अधिलेखित करेगा, मुझे नहीं पता ...

— 22

आप बिल्कुल सही कह रहे है। केवल एक पागल व्यक्ति सरणी वर्ग को अधिलेखित कर देगा। अब एक पल ले लो और नए ऐरे () का उपयोग करके सभी अतिरिक्त काम पर विचार करें जो इन पागल लोगों का समर्थन करने के लिए दुभाषिया बनाता है। मैं बस इसे एक साथ रखने से बचता हूं []।

— कोडरजियो

जावास्क्रिप्ट के साथ वैश्विक प्रदूषण के प्रकार का अच्छा उदाहरण है।

— डेविड स्नेबेल-कॉंट

वर्थ नोटिंग [] संकेतन का उपयोग करके नए ऐरे (आकार) अन्य संभावित तरीकों से तेज है। स्रोत: jsperf.com/create-an-array-of-initial-size/2

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

दुर्भाग्य से यह परीक्षण अनुचित तरीके से तैयार किया गया है। यह ऐरे की पहुँच के बाद एरे के आरंभीकरण के साथ एक ऐरे के आरंभीकरण का परीक्षण कर रहा है। यह साबित करने के लिए कोई नियंत्रण नहीं है कि ब्राउज़र वास्तव में मेमोरी को पूर्व-आबंटित कर रहे हैं (जो विनिर्देश नहीं कहता है कि उन्हें अवश्य करना चाहिए)। यदि हम मान सकते हैं कि सरणी पहुंच स्थिर है और समय का अधिकांश हिस्सा दोनों उदाहरणों में स्मृति को आवंटित करने में खर्च किया जाएगा, तो [] बेहतर हो सकता है यदि आप लाखों सरणियों को त्वरित कर रहे हैं। jsperf.com/array-instanciation

— coderjoe

Answer 3

एक महत्वपूर्ण अंतर यह है कि किसी भी उत्तर ने अभी तक उल्लेख नहीं किया है।

इस से:

new Array(2).length           // 2
new Array(2)[0] === undefined // true
new Array(2)[1] === undefined // true

आप सोच सकते हैं कि इसके new Array(2)बराबर है [undefined, undefined], लेकिन यह नहीं है!

चलो के साथ कोशिश करते हैं map():

[undefined, undefined].map(e => 1)  // [1, 1]
new Array(2).map(e => 1)            // "(2) [undefined × 2]" in Chrome

देख? शब्दार्थ बिलकुल अलग हैं! तो वह क्यों है?

ES6 कल्पना 22.1.1.2 के अनुसार, नौकरी Array(len)केवल एक नई सरणी बना रही है जिसकी संपत्ति lengthतर्क पर सेट है lenऔर यही है, जिसका अर्थ है कि कोई वास्तविक तत्व नहीं है इस नए बनाए गए सरणी के अंदर ।

map()22.1.3.15 युक्ति के अनुसार फंक्शन सबसे पहले जाँच करेगा HasPropertyफिर कॉलबैक कॉल करेगा, लेकिन यह पता चलता है कि:

new Array(2).hasOwnProperty(0) // false
[undefined, undefined].hasOwnProperty(0) // true

और इसीलिए आप सामान्य रूप से बनाए गए सरणियों पर काम करने वाले किसी भी पुनरावृत्ति कार्यों की अपेक्षा नहीं कर सकते new Array(len) ।

BTW, सफारी और फ़ायरफ़ॉक्स इस स्थिति के लिए बहुत बेहतर "मुद्रण" है:

// Safari
new Array(2)             // [](2)
new Array(2).map(e => 1) // [](2) 
[undefined, undefined]   // [undefined, undefined] (2) 

// Firefox
new Array(2)             // Array [ <2 empty slots> ]
new Array(2).map(e => 1) // Array [ <2 empty slots> ]
[undefined, undefined]   // Array [ undefined, undefined ]

मैंने पहले ही क्रोमियम को एक मुद्दा सौंप दिया है और उनसे इस भ्रामक मुद्रण को ठीक करने के लिए कहा है: https://bugs.chromium.org/p/chromium/issues/detail?id=732021

अद्यतन: यह पहले से ही तय है। क्रोम अब के रूप में मुद्रित:

new Array(2)             // (2) [empty × 2]

Comments

तुम्हारा एकमात्र वास्तविक उत्तर है

— विक्टर

यह समझ में आता है, मैं सिर्फ एक अलग निर्माण में टकरा रहा हूं [...Array(2)]जिसके लिए मैं दस्तावेजित संदर्भ नहीं पा सकता हूं: जो [undefined, undefined]एक परिणाम के दृष्टिकोण से बराबर है ।

— रॉबर्टो एंड्रेड

मेरी पिछली टिप्पणियों के उत्तर की तरह लगता है "स्प्रेड ऑपरेटर": javascript.info/rest-parameters-spread-operator

— रॉबर्टो एंड्रेड

@RrobertoAndrade से समझ में आता है क्योंकि प्रसार ऑपरेटर को प्रविष्टियों को पढ़ने की आवश्यकता होगी ताकि यह इस तरह की प्रतिलिपि को लागू कर सके ... और undefinedहमेशा की तरह इस तरह के खाली स्लॉट रिटर्न को पढ़ना ।

— हक्स

Answer 4

विचित्र रूप से पर्याप्त है, क्रोम की new Array(size)तुलना []में लगभग 2x तेज है , और एफएफ और आईई में समान है (एक सरणी बनाकर और भरकर मापा जाता है)। यह केवल तभी मायने रखता है जब आप सरणी के अनुमानित आकार को जानते हैं। यदि आप दी गई लंबाई से अधिक आइटम जोड़ते हैं, तो प्रदर्शन बूस्ट खो जाता है।

अधिक सटीक रूप से: Array(एक तेजी से निरंतर समय ऑपरेशन है जो कोई मेमोरी आवंटित नहीं करता है, व्हाटस []एक रैखिक समय ऑपरेशन है जो प्रकार और मूल्य सेट करता है।

Comments

मैंने इसे Node.js में बहुत परीक्षण किया है: जब आपको new Array(length)0 <= size <= 1000 पर, आकार में ~> 1000 जीतता है[]

— glukki

इस stackoverflow.com/questions/7375120/…

— Xsmael

Answer 5

अधिक जानकारी के लिए, निम्न पृष्ठ बताता है कि आपको कभी भी उपयोग करने की आवश्यकता क्यों नहीं हैnew Array()

आपको new Object()जावास्क्रिप्ट में उपयोग करने की आवश्यकता नहीं है । {} इसके बजाय ऑब्जेक्ट शाब्दिक का उपयोग करें । इसी तरह, उपयोग न करें new Array(), [] इसके बजाय सरणी शाब्दिक का उपयोग करें। जावास्क्रिप्ट में एरर्स जावा में सरणियों की तरह कुछ भी काम नहीं करते हैं, और जावा की तरह सिंटैक्स का उपयोग आपको भ्रमित करेगा।

का प्रयोग न करें new Number, new Stringया new Boolean। ये रूप अनावश्यक ऑब्जेक्ट रैपर का उत्पादन करते हैं। इसके बजाय बस साधारण शाब्दिक का उपयोग करें।

टिप्पणियों को भी देखें - new Array(length)फ़ॉर्म किसी भी उपयोगी उद्देश्य (जावास्क्रिप्ट के कम से कम आज के कार्यान्वयन में) की सेवा नहीं करता है।

Comments

क्रॉकफोर्ड भी, नए ऐरे () के बजाय [] का उपयोग करने के लिए कहते हैं। दुर्भाग्य से, वह यह नहीं कहता कि लिंक किए गए लेख में क्यों। मुझे लगता है कि यह केवल अंतरिक्ष और गति की बात है। javascript.crockford.com/code.html

— Nosredna

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

— एलन स्टॉर्म

@ एलन तूफान: कम से कम संख्या के लिए, स्ट्रिंग और बूलियन वह कहते हैं कि "ये रूप अनावश्यक वस्तु रैपर पैदा करते हैं", लेकिन मुझे लगता है कि एरे पर लागू नहीं होगा।

— बेलीफिट्ज़

Answer 6

बेहतर समझने []और करने के लिए new Array():

> []
  []
> new Array()
  []
> [] == []
  false
> [] === []
  false
> new Array() == new Array()
  false
> new Array() === new Array()
  false
> typeof ([])
  "object"
> typeof (new Array())
  "object"
> [] === new Array()
  false
> [] == new Array()
  false

उपरोक्त परिणाम विंडोज 7 पर Google क्रोम कंसोल से है।

Comments

लेकिन क्यों [] == [] या [] === [] झूठा है?

— अनु

"ऑब्जेक्ट्स की तुलना करने वाला एक अभिव्यक्ति केवल तभी सच है जब ऑपरेंड उसी ऑब्जेक्ट को संदर्भित करते हैं।" (स्रोत: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… )

— srph

यह उत्तर चेरी का उदाहरण है कि दो निर्माण समान हैं। इस पृष्ठ के अन्य पोस्ट मतभेदों को इंगित करते हैं, जैसे कि Array(3)या new Array(3)जैसा नहीं है [3]।

— गॉर्जलीन

Answer 7

पहला एक डिफ़ॉल्ट ऑब्जेक्ट कंस्ट्रक्टर कॉल है। यदि आप चाहें तो इसका उपयोग कर सकते हैं।

var array = new Array(5); //initialize with default length 5

दूसरा आपको खाली सरणी नहीं बनाने की क्षमता देता है:

var array = [1, 2, 3]; // this array will contain numbers 1, 2, 3.

Comments

आप वर्बोज़ कंस्ट्रक्टर के साथ एक ही काम कर सकते हैं: var array = new Array (1, 2, 3);

— nickf

तो फिर मुझे लगता है कि आप var array = [5]वर्ग कोष्ठक का उपयोग कर सकते हैं लेकिन निर्माणकर्ता का उपयोग नहीं कर रहे हैं जैसा var array = Array(5)कि 5 तत्वों का एक खाली सरणी बनाता है।

— cdmckay

cdmckay - यह गलत है। var a = [5] एक एकल आइटम के साथ एक सरणी होगी - संख्या पांच।

— बेलीफिट्ज़

@BarelyFitz: यही मैंने कहा है। बोगडन्स के उत्तर में, वह कहता है कि कंस्ट्रक्टर कॉल का उपयोग किसी सरणी को निष्क्रिय करने के लिए नहीं किया जा सकता है, लेकिन वह गलत था। मेरी टिप्पणी केवल यह स्पष्ट करने के लिए थी कि आप किसी एकल तत्व की एक सरणी को आरंभीकृत करने के लिए कंस्ट्रक्टर कॉल का उपयोग नहीं कर सकते।

— cdmckay

@cdmckay: क्षमा करें, मुझे आपकी टिप्पणी गलत लगी। स्पष्ट करने के लिए: नया ऐरे (arg) - यदि arg संख्यात्मक है, तो यह लंबाई = arg के साथ एक खाली सरणी बनाता है; नया ऐरे (arg1, arg2) - एक नया सरणी बनाता है और सरणी तत्वों को आरंभ करता है। इसलिए यदि आप [5] जैसे एक संख्यात्मक तत्व के साथ एक सरणी बनाना चाहते हैं, तो आप नए ऐरे (5) का उपयोग करके ऐसा नहीं कर सकते। लेकिन वास्तव में आपको कभी भी नए ऐरे () का उपयोग नहीं करना चाहिए ताकि यह एक महत्वपूर्ण बिंदु हो।

— बेलीफिट्ज

Answer 8

मैं इस उदाहरण के साथ शुरू करने वाले अधिक विशिष्ट तरीके से समझा सकता हूं जो फ्रेड्रिक के अच्छे पर आधारित है।

var test1 = [];
test1.push("value");
test1.push("value2");

var test2 = new Array();
test2.push("value");
test2.push("value2");

alert(test1);
alert(test2);
alert(test1 == test2);
alert(test1.value == test2.value);

मैंने केवल सरणियों में एक और मूल्य जोड़ा है, और चार अलर्ट किए हैं: पहला और दूसरा हमें प्रत्येक सरणी में संग्रहीत मान देने के लिए है, मूल्यों के बारे में सुनिश्चित करने के लिए। वही लौटेंगे! अब तीसरा प्रयास करें, यह गलत है, ऐसा इसलिए है

JS एक डेटा प्रकार के सरणी के साथ Test1 को एक VARIABLE के रूप में मानता है , और यह एक सरणी की कार्यक्षमता के साथ OBJECT के रूप में test2 का इलाज करता है , और यहां कुछ मामूली अंतर हैं।

पहला अंतर यह है कि जब हम test1 को कॉल करते हैं तो यह बिना सोचे समझे एक वैरिएबल को कॉल कर देता है, यह सिर्फ इस वैरिएबल में संग्रहीत मानों को लौटाता है जो आपके डेटा प्रकार की अवहेलना करता है! लेकिन, जब हम test2 को कॉल करते हैं, तो यह ऐरे () फ़ंक्शन को कॉल करता है और तब यह हमारे "पुश" मूल्यों को अपनी "वैल्यू" प्रॉपर्टी में स्टोर करता है , और ऐसा ही तब होता है जब हम टेस्ट 2 को अलर्ट करते हैं, यह एरे ऑब्जेक्ट के "वैल्यू" प्रॉपर्टी को लौटाता है ।

इसलिए जब हम जांचते हैं कि क्या test1 समान रूप से test2 के बराबर है, तो वे कभी भी सच नहीं लौटेंगे, एक फ़ंक्शन है और दूसरा एक वेरिएबल है (एक प्रकार की सरणी के साथ), भले ही उनका मूल्य समान हो!

उस बारे में निश्चित होने के लिए, 4 चेतावनी को आज़माएं; यह सच हो जाएगा। इस मामले में हम जेएस को बताते हैं "कंटेनर के प्रकार की अवहेलना, चाहे वह फ़ंक्शन या चर था, कृपया उन मूल्यों की तुलना करें जो प्रत्येक कंटेनर में संग्रहीत हैं और हमें बताएं कि आपने क्या देखा है!" ठीक ऐसा ही होता है।

मुझे आशा है कि मैंने इसके पीछे के विचार को स्पष्ट रूप से कहा है, और मेरी खराब अंग्रेजी के लिए खेद है।

Comments

यह आश्चर्यजनक है कि इस तरह के पूर्ण और पूरी बकवास को वोट दिया गया है। सरणियों के बीच तुलना झूठी होगी चाहे आप उन्हें कैसे बना लें क्योंकि यह वस्तु पहचान की तुलना करता है और वे अलग-अलग वस्तुएं हैं। एरे के पास कोई मूल्य संपत्ति नहीं है। []और new Array()समान है; दोनों मामलों में .valueहोगा undefined, और उनकी तुलना हमेशा झूठी होगी।

— slikts

सहमत, यह जवाब कोई मतलब नहीं है और कुछ भी नहीं दिखाता है। जैसी कोई बात नहीं है array.value। और दोनों typeof []और typeof new Array()वापसी object। यह एक कारण है कि वहाँ एक समारोह कहा जाता हैArray.isArray

— gman

Answer 9

जब आप किसी भी लंबाई के बिना सरणी को आरम्भ करते हैं तो कोई अंतर नहीं है। तो var a = []& var b = new Array()एक ही है।

लेकिन अगर आप सरणी को लंबाई के साथ इनिशियलाइज़ करते हैं var b = new Array(1);, तो यह सरणी ऑब्जेक्ट की लंबाई को 1. पर सेट करेगा var b = []; b.length=1;।

जब भी आप array_object.push करते हैं तो यह समस्याग्रस्त होगा, यह अंतिम तत्व के बाद आइटम जोड़ता है और लंबाई बढ़ाता है।

var b = new Array(1);
b.push("hello world");
console.log(b.length); // print 2

बनाम

var v = [];
a.push("hello world");
console.log(b.length); // print 1

Answer 10

पहला एक डिफ़ॉल्ट ऑब्जेक्ट कंस्ट्रक्टर है। गतिशील मूल्यों के लिए इसका उपयोग किया जाता है।

var array = new Array(length); //initialize with default length

स्थिर मान बनाते समय दूसरी सरणी का उपयोग किया जाता है

var array = [red, green, blue, yellow, white]; // this array will contain values.

Answer 11

कोई बड़ा अंतर नहीं है, वे मूल रूप से एक ही काम करते हैं लेकिन उन्हें अलग-अलग तरीकों से करते हैं, लेकिन पढ़ते हैं, डब्ल्यू 3 पर इस कथन को देखें:

var cars = ["Saab", "Volvo","BMW"];

तथा

var cars = new Array("Saab", "Volvo", "BMW");

ऊपर दिए गए दो उदाहरण बिलकुल एक जैसे हैं। नए ऐरे () का उपयोग करने की कोई आवश्यकता नहीं है।
सादगी, पठनीयता और निष्पादन की गति के लिए, पहले एक (सरणी शाब्दिक विधि) का उपयोग करें।

लेकिन एक ही समय में, new Arrayवाक्यविन्यास का उपयोग करके नए सरणी बनाना एक बुरा अभ्यास माना जाता है:

नए ऐरे से बचें ()

जावास्क्रिप्ट के बिल्ट-इन एरे कंस्ट्रक्टर नए ऐरे () का उपयोग करने की कोई आवश्यकता नहीं है।
इसके बजाय [] का उपयोग करें।
ये दो अलग-अलग कथन दोनों एक नए खाली सरणी अंक बनाते हैं:

var points = new Array();         // Bad
var points = [];                  // Good 

ये दो अलग-अलग कथन दोनों एक नई सरणी बनाते हैं जिसमें 6 नंबर होते हैं:

var points = new Array(40, 100, 1, 5, 25, 10); // Bad    
var points = [40, 100, 1, 5, 25, 10];          // Good

नए कीवर्ड केवल कोड पेचीदा हो। यह कुछ अप्रत्याशित परिणाम भी दे सकता है:

var points = new Array(40, 100);  // Creates an array with two elements (40 and 100)

अगर मैं तत्वों में से एक को हटा दूं तो क्या होगा?

var points = new Array(40);       // Creates an array with 40 undefined elements !!!!!

तो मूल रूप से सबसे अच्छा अभ्यास नहीं माना जाता है, वहां भी एक मामूली अंतर है, आप new Array(length)इस तरह से लंबाई पारित कर सकते हैं , जो अनुशंसित तरीका भी नहीं है।

Comments

हाय अलिर्ज़ा, क्या ये कहीं से कॉपी और पेस्ट किए गए हैं? कृपया उस पृष्ठ पर एक लिंक जोड़ें जहां से पाठ की प्रतिलिपि बनाई गई है। देखें , इस सहायता केंद्र पेज जानकारी के लिए। धन्यवाद।

— पेंग

के लिए उपयोगीnew Array(40).fill(123)

— 1

Answer 12

उपयोग करने का अंतर

var arr = new Array(size);

या

arr = [];
arr.length = size;

जैसा कि इस प्रश्न में पर्याप्त चर्चा की गई है।

मैं गति के मुद्दे को जोड़ना चाहूंगा - वर्तमान सबसे तेज़ तरीका, परgoogle chrome दूसरा है।

लेकिन ध्यान दें, ये चीजें अपडेट के साथ बहुत कुछ बदल देती हैं। साथ ही रन टाइम अलग-अलग ब्राउजर के बीच अलग-अलग होगा।

उदाहरण के लिए - दूसरा विकल्प, जिसका मैंने उल्लेख किया है, 2 मिलियन [सेशन / सेकंड] पर चलता है chrome, लेकिन यदि आप इसे आज़माएँगे तो आपको mozilla dev.आश्चर्यजनक रूप से 23 मिलियन की उच्च दर मिलेगी।

वैसे भी, मैं आपको सुझाव दूंगा कि आप इसे हर बार, अलग-अलग ब्राउज़रों (और मशीनों) पर देखें, जैसे साइट का उपयोग करके

Answer 13

मैं diference जानते हैं यू टुकड़ा (या सरणी के अन्य funcitons) की तरह पा सकते हैं code1 .और code2 यू दिखाने सरणी और उसके उदाहरणों :

code1:

[].slice; // find slice here
var arr = new Array();
arr.slice // find slice here
Array.prototype.slice // find slice here

code2:

[].__proto__ == Array.prototype; // true
var arr = new Array();
arr.__proto__ == Array.prototype; // true

निष्कर्ष:

जैसा कि आप Array का नया उदाहरण देख []और new Array()बना सकते हैं। और वे सभी से प्रोटोटाइप फ़ंक्शंस प्राप्त करते हैंArray.prototype

वे Array.so का अलग उदाहरण हैं [] != []

:)

Answer 14

मैंने [] का उपयोग करते हुए एक अजीब व्यवहार किया है।

हमारे पास कुछ मूल्य से आरंभ किए गए फ़ील्ड के साथ मॉडल "कक्षाएं" हैं। उदाहरण के लिए:

require([
  "dojo/_base/declare",
  "dijit/_WidgetBase",
], function(declare, parser, ready, _WidgetBase){

   declare("MyWidget", [_WidgetBase], {
     field1: [],
     field2: "",
     function1: function(),
     function2: function()
   });    
});

मैंने पाया कि जब खेतों के साथ आरंभ किया जाता है []तो यह सभी मॉडल वस्तुओं द्वारा साझा किया जाएगा। एक में परिवर्तन करने से अन्य सभी प्रभावित होते हैं।

यह उनके साथ शुरू करने से नहीं होता है new Array()। वस्तुओं के प्रारंभिककरण के लिए समान ( {}बनाम नया Object())

टीबीएच मुझे यकीन नहीं है कि इसकी रूपरेखा के साथ एक समस्या है जिसका हम उपयोग कर रहे थे ( डोजो )

Answer 15

आंख से मिलने की तुलना में यह अधिक है। अधिकांश अन्य उत्तर सही हैं, लेकिन यह भी ..

new Array(n)

• अनुमति देता है इंजन nतत्वों के लिए अंतरिक्ष reallocates
• सरणी निर्माण के लिए अनुकूलित
• सृजित सरणी को विरल चिह्नित किया जाता है जिसमें कम से कम प्रदर्शन करने वाले सरणी संचालन होते हैं, ऐसा इसलिए है क्योंकि प्रत्येक अनुक्रमणिका एक्सेस को सीमा की जांच करनी है, देखें कि क्या मान मौजूद है और प्रोटोटाइप श्रृंखला चलना
• यदि सरणी को विरल के रूप में चिह्नित किया गया है, तो कोई रास्ता नहीं है (कम से कम V8 में), यह हमेशा अपने जीवनकाल के दौरान धीमा हो जाएगा, भले ही आप इसे सामग्री से भर दें (पैक सरणी) 1ms या 2 घंटे बाद, कोई फर्क नहीं पड़ता

[1, 2, 3] || []

• निर्मित सरणी चिह्नित है पैक (जब तक आप का उपयोग deleteया [1,,3]वाक्य रचना)
• सरणी के लिए अनुकूलित आपरेशन ( for .., forEach, map, आदि)
• सरणी बढ़ने पर इंजन को जगह खाली करने की आवश्यकता होती है

यह शायद पुराने ब्राउज़र संस्करणों / ब्राउज़र के लिए ऐसा नहीं है।

Answer 16

मैंने दोनों निर्माणों के बीच एक अंतर पाया है जो मुझे बहुत कठिन लगता है।

मान लीजिए कि मेरे पास है:

function MyClass(){
  this.property1=[];
  this.property2=new Array();
};
var MyObject1=new MyClass();
var MyObject2=new MyClass();

वास्तविक जीवन में, अगर मैं ऐसा करता हूं:

MyObject1.property1.push('a');
MyObject1.property2.push('b');
MyObject2.property1.push('c');
MyObject2.property2.push('d');

मैं इसके साथ अंत करता हूं:

MyObject1.property1=['a','c']
MyObject1.property2=['b']
MyObject2.property1=['a','c']
MyObject2.property2=['d']

मुझे नहीं पता कि भाषा विनिर्देश क्या कहता है, क्या होना चाहिए, लेकिन अगर मैं चाहता हूं कि मेरी दो वस्तुओं को मेरी वस्तुओं में अद्वितीय संपत्ति सरणियाँ हैं, तो मुझे उपयोग करना होगा new Array()।

Comments

यह JSField दिखाता है कि आउटपुट वह है जो आप ऐरे शाब्दिक []और new Array()कंस्ट्रक्टर के साथ उम्मीद करेंगे, जिसके परिणामस्वरूप एक गुण प्रति सरणी प्रति गुण होगा। आपके पास ऊपर दिखाए गए परिणाम के साथ समाप्त करने के लिए आपके पास कोड में कुछ और होना चाहिए।

— गुफलाम

बकी, मेरे लिए ऐसा नहीं होता, किसी भी ब्राउज़र में। उस व्यवहार को पाने के लिए आपको कुछ ऐसा करना होगा: var property1static=[]; function MyClass(){ this.property1=property1static; this.property2=new Array(); };

— डेव बर्टन

Answer 17

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

Comments

नहीं, सरणी आबाद नहीं है, कोई सूचकांक / चाबियाँ अंदर नहीं हैं। उदाहरण के लिए। कोई काम नहीं करेगा।

— CFrei