घुंघराले ब्रैकेट्स के संदर्भ को समझना {} '

Question

मैं अन्य लोगों के कोड की समीक्षा कर रहा हूं और जबकि ईएस2015 पूरी तरह से कुछ उपयोग कर रहा है, हालांकि, मैं विनाश के साथ अटक गया हूं।

पहले, जावास्क्रिप्ट में, घुंघराले ब्रैकेट {} या तो ब्लॉक या ऑब्जेक्ट्स के लिए उपयोग किए जाते थे। जैसे

// Curly Brackets Block 
If() { 
    ... 
} 

// Curly Brackets in Obj 
var obj = { 
    a : 1, 
    ... 
} 

हालांकि, destructuring में, हम फिर से और फिर निम्न सिंटैक्स देखें:

let a = ({ a, b }) => { 
} 

मेरा प्रश्न, तर्क कंटेनर एक वास्तविक वस्तु या सिर्फ एक ब्लॉक है? कृपया व्याख्या है कि क्या निम्नलिखित उपरोक्त कोड के रूप में ही:

let a = (a, b) => { 
} 

संपादित करें: मेरी समझ (अभी तक) Destruturing पर एक्सल Rauschmayers लेख को पढ़ने से है कि हम केवल रंगमंच की सामग्री मानचित्रण कर रहे हैं। हमेशा एक नए Obj में? अर्थात:

let a = { first : a, second : b } = AnObj; 
=== 
a.a === AnObj.first; 
a.b === AnObj.second; 

ऊपर सही है? क्या ओबीजी हमेशा तत्काल होता है? हालांकि, यह उपरोक्त फ़ंक्शन के रूप में समझ में नहीं आता है, इस प्रकार प्रोप के लिए बनाई गई वस्तु एक अज्ञात वस्तु होगी, है ना?

बहुत धन्यवाद,

Answer 1

नहीं, विनाशकारी में घुंघराले ब्रेसिज़ न तो ब्लॉक और न ही एक वस्तु शब्दशः बनाते हैं।

वे निश्चित रूप से एक ब्लॉक, क्योंकि वे एक बयान नहीं कर रहे हैं (और एक बयान सूची शामिल नहीं है) नहीं हैं, वे एक अभिव्यक्ति एक वस्तु शाब्दिक की तरह हैं। असल में उनके पास एक ऑब्जेक्ट शाब्दिक के समान वाक्यविन्यास भी होता है, केवल अंतर यह है कि वे एक असाइनमेंट लक्ष्य (असाइनमेंट ऑपरेटर के बाएं हाथ की ओर) या फ़ंक्शन पैरामीटर की स्थिति में हैं।

let a = ({ a, b }) => {…}let a = (a, b) => {…} जैसा ही है?

नहीं, वास्तव में नहीं। दोनों पैरामीटर सूचियां फ़ंक्शन स्कोप के लिए a और b वैरिएबल घोषित करती हैं, लेकिन पहला फ़ंक्शन किसी ऑब्जेक्ट को .a और .b गुणों की अपेक्षा करता है जबकि दूसरा फ़ंक्शन दो तर्कों की अपेक्षा करता है।

मेरी समझ यह है कि हम केवल नए ओब्जे में गुणों का मानचित्रण कर रहे हैं?

नहीं। कोई नई वस्तु नहीं बनाई गई/तत्काल नहीं है। केवल वह ऑब्जेक्ट है जिसे आप पास करते हैं (दाईं ओर)। और यह नष्ट हो गया - "अलग खींच लिया गया" - उन टुकड़ों में जिन्हें फिर विभिन्न उप-लक्ष्य (चर, संपत्ति संदर्भ) को सौंपा गया है।

एक destructuring काम के साथ

a.b = anObj.first; 
a.c = anObj.second; 

लिखने के लिए आप उपयोग करेंगे

({first: a.b, second: a.c}) = anObj; 

(कोष्ठक एक ब्लॉक से अभिव्यक्ति भेद करने के लिए आवश्यक हैं)।

हालांकि अधिक सामान्य उपयोग केस वैरिएबल प्रारंभिकरणों के लिए है। आप

let b = anObj.first, 
    c = anObj.second; 

छोटा कर सकते हैं

let {first: b, second: c} = anObj; 

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

let first = anObj.first, 
    second = anObj.second; 

let {first, second} = anObj; 

के बराबर है

let a = { first : a, second : b } = anObj; सही है?

नहीं, यह अधिक समझ में नहीं आता है। यह

let a; 
a = anObj.first; 
b = anObj.second; 
a = anObj; 

Answer 2

यह destructuring के लिए है:

var obj = {a: 1, b: 2}, 
    add = ({a, b}) => a + b; 

console.log(add(obj)); //3 

बयान समारोह के अंदर यह वहाँ 2 तर्क हैं, लेकिन जब आप इसे आप केवल एक वस्तु पारित करने के लिए प्रकट होता

तो मूल रूप से।