ES6 विनाशकारी
विनाशकारी वाक्यविन्यास एक वस्तु को नष्ट करने और पुनर्संयोजित करने की अनुमति देता है, या तो फ़ंक्शन पैरामीटर या चर के साथ।
सीमा यह है कि चाबियों की एक सूची पूर्वनिर्धारित है, उन्हें तार के रूप में सूचीबद्ध नहीं किया जा सकता है, जैसा कि प्रश्न में उल्लेख किया गया है। यदि एक गैर-अल्फ़ान्यूमेरिक, जैसे उदाहरण के लिए विनाशकारी अधिक जटिल हो जाता है foo_bar।
नकारात्मक पक्ष यह है कि इसके लिए चाबियों की एक सूची को डुप्लिकेट करने की आवश्यकता होती है, एक सूची लंबी होने पर क्रिया कोड में यह परिणाम होता है। चूंकि इस मामले में डुप्लिकेट ऑब्जेक्ट ऑब्जेक्ट शाब्दिक सिंटैक्स को नष्ट कर देता है, एक सूची को कॉपी किया जा सकता है और जैसा कि चिपकाया जाता है।
उल्टा यह है कि यह प्रदर्शन समाधान है कि ES6 के लिए स्वाभाविक है।
Iife
let subset = (({ foo, bar }) => ({ foo, bar }))(obj); // dupe ({ foo, bar })
अस्थायी चर
let { foo, bar } = obj;
let subset = { foo, bar }; // dupe { foo, bar }
तार की एक सूची
चुनी गई कुंजियों की मनमानी सूची में तार होते हैं, जैसे प्रश्न की आवश्यकता होती है। यह उन्हें पूर्वनिर्धारित नहीं करने देता है और उन चर का उपयोग करता है जिनमें प्रमुख नाम होते हैं, जैसे pick(obj, 'foo', someKey, ...moreKeys)।
एक-लाइनर प्रत्येक JS संस्करण के साथ छोटा हो जाता है।
ES5
var subset = Object.keys(obj)
.filter(function (key) {
return ['foo', 'bar'].indexOf(key) >= 0;
})
.reduce(function (obj2, key) {
obj2[key] = obj[key];
return obj2;
}, {});
ES6
let subset = Object.keys(obj)
.filter(key => ['foo', 'bar'].indexOf(key) >= 0)
.reduce((obj2, key) => Object.assign(obj2, { [key]: obj[key] }), {});
या अल्पविराम ऑपरेटर के साथ:
let subset = Object.keys(obj)
.filter(key => ['foo', 'bar'].indexOf(key) >= 0)
.reduce((obj2, key) => (obj2[key] = obj[key], obj2), {});
ES2019
ECMAScript 2017 में है Object.entriesऔर Array.prototype.includes, ECMAScript 2019 में Object.fromEntries, जरूरत पड़ने पर उन्हें पॉलीफ़िल किया जा सकता है और कार्य को आसान बना सकता है:
let subset = Object.fromEntries(
Object.entries(obj)
.filter(([key]) => ['foo', 'bar'].includes(key))
)
एक-लाइनर को लाडश केpick समान सहायक कार्य के रूप में फिर से लिखा जा सकता है या omitजहां तर्कों के माध्यम से कुंजियों की सूची दी जाती है:
let pick = (obj, ...keys) => Object.fromEntries(
Object.entries(obj)
.filter(([key]) => keys.includes(key))
);
let subset = pick({ foo: 1, qux: 2 }, 'foo', 'bar'); // { foo: 1 }
गुम चाबियों के बारे में एक नोट
विनाशकारी और पारंपरिक लोदाश जैसे pickफ़ंक्शन के बीच मुख्य अंतर यह है कि विनाशकारी undefinedमें एक उप-मूल्य के साथ गैर-विद्यमान उठाया कुंजी शामिल हैं :
(({ foo, bar }) => ({ foo, bar }))({ foo: 1 }) // { foo: 1, bar: undefined }
यह व्यवहार वांछनीय हो सकता है या नहीं। इसे सिंटेक्स को नष्ट करने के लिए नहीं बदला जा सकता है।
जबकि pickउठाया चाबियाँ की एक सूची पुनरावृत्ति बजाय द्वारा लापता कुंजी शामिल करने के लिए बदला जा सकता है:
let inclusivePick = (obj, ...keys) => Object.fromEntries(
keys.map(key => [key, obj[key]])
);
let subset = inclusivePick({ foo: 1, qux: 2 }, 'foo', 'bar'); // { foo: 1, bar: undefined }
