मैं एक जावास्क्रिप्ट ऑब्जेक्ट से एक संपत्ति कैसे निकालूं?

Question

मान लीजिए कि मैं एक वस्तु बनाता हूं:

let myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};

संपत्ति regexको हटाने का सबसे अच्छा तरीका क्या है जो नए के साथ समाप्त हो सकता myObjectहै?

let myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI"
};

Comments

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

— titusfx

@EscapeNetscape यह व्यवहार के बारे में एक प्रश्न है, इसलिए एक बेंचमार्क गलत चित्र को चित्रित करता है। बेशक deleteयह सबसे सरल विकल्प होगा क्योंकि यह अन्य दो के बजाय एक वास्तविक ऑपरेशन है जो केवल सरल असाइनमेंट हैं। लेकिन इस मामले की जड़ यह है कि संपत्ति को वास्तव में उस वस्तु से हटा देना nullया undefinedनहीं देना है, बल्कि उस संपत्ति को किसी विशेष स्थिर मूल्य के बराबर सेट करना है। (नीचे दिए गए उत्तर कारण देते हैं कि यह एक महत्वपूर्ण अंतर क्यों है।)

— अबिओन 47

Answer 1

ऐशे ही:

delete myObject.regex;
// or,
delete myObject['regex'];
// or,
var prop = "regex";
delete myObject[prop];

डेमो

var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};
delete myObject.regex;

console.log(myObject);

इसके बारे में और अधिक पढ़ने में रुचि रखने वाले किसी के लिए, स्टैक ओवरफ्लो उपयोगकर्ता कंगैक्स ने deleteअपने ब्लॉग पर दिए गए बयान के बारे में एक अविश्वसनीय रूप से गहराई से पोस्ट लिखा है, अंडरस्टैंडिंग डिलीट । यह अत्यधिक अनुशंसित है।

Comments

चेक किया गया, यह "myJSONObject ['regex'] को हटाने के साथ भी काम करता है;" देखें: developer.mozilla.org/en/Core_JavaScript_1.5_Reference/…

— johnstok

ऊपर दिए गए "समझ हटाएं" लिंक पर टिप्पणियों में से एक का एक उत्थान यह है कि, चूंकि आप आवश्यक रूप से एक चर नहीं हटा सकते हैं, लेकिन केवल ऑब्जेक्ट गुण, इसलिए आप किसी वस्तु गुण को "संदर्भ द्वारा" नहीं हटा सकते हैं - var value = obj [ 'प्रोप']; हटाएँ मान // काम नहीं करता है

— Dex

तो यह वास्तव में इसे हटा नहीं है? यह सिर्फ अपरिभाषित हो जाता है, लेकिन कुंजी अभी भी मौजूद है? क्या मैं कुछ भूल रहा हूँ?

— डॉग मोलिनक्स

@ पता नहीं, यह इसे हटा देता है। दिया गया: var x = {a : 'A', b : 'B'};तुलना करें: delete x.a; typeof x.a; /* "undefined" */ x.hasOwnProperty('a'); /* false */सेx.b = undefined; typeof x.b; /* "undefined" */; x.hasOwnProperty('b'); /* true */

— 10:१०

@ChristopherPfohl मेरे लिए काम करता है। जैसा मैंने कहा, यह वास्तव में काफी गहराई में है, इसलिए इसे संक्षेप में प्रस्तुत करना थोड़ा मुश्किल है। ऊपर दिए गए उत्तर में मूल प्रतिक्रिया लगभग सभी मामलों के लिए पर्याप्त है, ब्लॉग किनारे के कुछ मामलों में जाता है और उन मामलों के कारण मौजूद हैं।

— निक डे

Answer 2

जावास्क्रिप्ट में वस्तुओं को कुंजी और मूल्यों के बीच के नक्शे के रूप में सोचा जा सकता है। deleteऑपरेटर इन कुंजियों, और अधिक सामान्यतः वस्तु गुण, एक समय में एक के रूप में जाना दूर करने के लिए प्रयोग किया जाता है।

var obj = {
  myProperty: 1    
}
console.log(obj.hasOwnProperty('myProperty')) // true
delete obj.myProperty
console.log(obj.hasOwnProperty('myProperty')) // false

deleteऑपरेटर नहीं सीधे मुक्त स्मृति करता है, और यह बस के मान निर्दिष्ट से अलग है nullया undefinedमें है कि संपत्ति, एक संपत्ति के लिए ही वस्तु से हटा दिया है। ध्यान दें कि यदि हटाई गई संपत्ति का मूल्य एक संदर्भ प्रकार (एक वस्तु) था, और आपके कार्यक्रम का एक अन्य हिस्सा अभी भी उस वस्तु का संदर्भ रखता है, तो उस वस्तु को, निश्चित रूप से तब तक एकत्र नहीं किया जाएगा, जब तक कि उसके पास सभी संदर्भ न हों। गायब हो गया।

delete केवल उन गुणों पर काम करेंगे जिनके विवरणकर्ता उन्हें विन्यास के रूप में चिह्नित करते हैं।

Comments

एक संपत्ति को अपरिभाषित सौंपा गया है फिर भी एक वस्तु की संपत्ति है, इसलिए इसे जीसी द्वारा हटाया नहीं जाएगा, जब तक कि आपके अंतिम पैराग्राफ को गलत न किया जाए।

— लांस

यहां जीसी की थीम को छूना गलत था। दोनों विधियों में GC के लिए समान परिणाम है: वे कुंजी से जुड़े मूल्य को हटा देते हैं। यदि वह मान किसी अन्य वस्तु का अंतिम संदर्भ था, तो वह वस्तु साफ हो जाएगी।

— डैन

एक संपत्ति को अपरिभाषित सौंपा गया है फिर भी एक वस्तु की संपत्ति है, इसलिए इसे GC द्वारा नहीं हटाया जाएगा GC GC गुणों के बारे में कुछ भी प्रबंधित नहीं करता है। यह मूल्यों को एकत्र करता है और हटाता है। जब तक कुछ भी एक मूल्य (एक वस्तु, स्ट्रिंग, आदि) का संदर्भ नहीं देता है, तब तक जीसी इसे मेमोरी से हटा देता है।

— मेन्ड्रे

BTW, यह जांचने के लिए दोहरी समस्या है कि क्या कोई वस्तु जावास्क्रिप्ट ऑब्जेक्ट पर मौजूद है। का प्रयोग में ऑपरेटर विश्वसनीय लेकिन धीमी है। जांचें कि क्या संपत्ति अपरिभाषित नहीं है "सही उत्तर नहीं है" लेकिन यह एक तरह से तेज है। चेक

— rdllopes

क्या यह उत्तर अभी भी प्रासंगिक है? jsperf वर्तमान में नीचे है, लेकिन यह मानदंड इंगित करता है कि गति अंतर केवल 25% है, जो इस उत्तर में "~ 100 गुना धीमी" के करीब है ।

— सेरेब्रस

Answer 3

var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
    
delete myObject.regex;

console.log ( myObject.regex); // logs: undefined

यह फ़ायरफ़ॉक्स और इंटरनेट एक्सप्लोरर में काम करता है, और मुझे लगता है कि यह अन्य सभी में काम करता है।

Answer 4

deleteऑपरेटर वस्तुओं से गुण दूर करने के लिए प्रयोग किया जाता है।

const obj = { foo: "bar" }
delete obj.foo
obj.hasOwnProperty("foo") // false

ध्यान दें कि, सरणियों के लिए, यह एक तत्व को हटाने के समान नहीं है । किसी तत्व को किसी सरणी से निकालने के लिए, उपयोग करें Array#spliceया Array#pop। उदाहरण के लिए:

arr // [0, 1, 2, 3, 4]
arr.splice(3,1); // 3
arr // [0, 1, 2, 4]

विवरण

deleteजावास्क्रिप्ट में C और C ++ में कीवर्ड के लिए एक अलग फ़ंक्शन है: यह सीधे मुक्त मेमोरी नहीं करता है। इसके बजाय, इसका एकमात्र उद्देश्य वस्तुओं से गुणों को निकालना है।

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

var array = [0, 1, 2, 3]
delete array[2] // [0, 1, empty, 3]

ध्यान दें कि में deleteस्थानांतरित नहीं array[3]है array[2]।

जावास्क्रिप्ट में अलग-अलग अंतर्निहित फ़ंक्शन अलग-अलग तरीके से संभालते हैं।

• for...in खाली इंडेक्स को पूरी तरह से छोड़ देगा।

• एक पारंपरिक forलूप undefinedसूचकांक में मूल्य के लिए वापस आ जाएगा ।

• इंडेक्स में मान के लिए किसी भी विधि का उपयोग किया Symbol.iteratorजाएगा undefined।

• forEach, mapऔर reduceबस लापता सूचकांक को छोड़ देगा।

इसलिए, deleteऑपरेटर को किसी सरणी से तत्वों को हटाने के सामान्य उपयोग-मामले के लिए उपयोग नहीं किया जाना चाहिए। तत्वों को हटाने और स्मृति को पुनः प्राप्त करने के लिए Arrays के पास एक समर्पित तरीका है: Array#splice()और Array#pop।

ऐरे # ब्याह (प्रारंभ [, DeleteCount [, item1 [, item2 [, ...]]]]]

Array#spliceसरणी को बदल देता है, और किसी भी हटाए गए सूचकांकों को लौटाता है। deleteCountतत्वों को इंडेक्स से हटा दिया जाता है start, और item1, item2... itemNइंडेक्स से सरणी में डाला जाता है start। यदि deleteCountछोड़ दिया जाता है तो startIndex से तत्वों को सरणी के अंत तक हटा दिया जाता है।

let a = [0,1,2,3,4]
a.splice(2,2) // returns the removed elements [2,3]
// ...and `a` is now [0,1,4]

वहाँ भी पर एक समान नाम है, लेकिन अलग, समारोह है Array.prototype: Array#slice।

एरे # स्लाइस ([शुरू, अंत]])

Array#sliceगैर-विनाशकारी है, और संकेतित सूचकांकों से startलेकर एक नया सरणी देता है end। यदि endअनिर्दिष्ट छोड़ दिया जाता है, तो यह सरणी के अंत में चूक कर देता है। यदि endसकारात्मक है, तो यह शून्य-आधारित गैर-समावेशी सूचकांक को रोकने के लिए निर्दिष्ट करता है। यदि endयह नकारात्मक है, तो यह सरणी के अंत से वापस गिनती करके सूचकांक को रोकने के लिए निर्दिष्ट करता है (जैसे -1 अंतिम सूचकांक को छोड़ देगा)। यदि end <= start, परिणाम एक खाली सरणी है।

let a = [0,1,2,3,4]
let slices = [
    a.slice(0,2),
    a.slice(2,2),
    a.slice(2,3),
    a.slice(2,5) ]

//   a           [0,1,2,3,4]
//   slices[0]   [0 1]- - -   
//   slices[1]    - - - - -
//   slices[2]    - -[3]- -
//   slices[3]    - -[2 4 5]

सरणी # पॉप

Array#popकिसी सरणी से अंतिम तत्व निकालता है, और उस तत्व को वापस करता है। यह ऑपरेशन सरणी की लंबाई को बदलता है।

Comments

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

— तमस Czinege

@ B1KMusic यहाँ एक एरे से एक तत्व को हटाने का तरीका है: ब्याह

— वुल्फटोन

@wulftone nope, जो ऐरे को विभाजित करता है और एक मूल्य को हटाने के लिए कुछ भी नहीं करता है। मैं वास्तव में एक सरणी से हटाने का सबसे अच्छा तरीका समझता हूं जहां विशिष्ट मूल्यों को हटाने की आवश्यकता होती है, deleteइसे साफ करने के लिए एक कचरा संग्रह समारोह का उपयोग करना और बनाना है।

— ब्रैडेन बेस्ट

मैं नहीं दिख रहा है spliceअपने संपादन में है, लेकिन removeहोना चाहिएArray.prototype.remove = function(index) { this.splice(index, 1); };

— Ry-

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

— बेकिम बकाज

Answer 5

पुराना सवाल, आधुनिक जवाब। ईसीएमएस्क्रिप्ट 6 सुविधा को नष्ट करने वाली वस्तु का उपयोग करना , यह उतना ही सरल है:

const { a, ...rest } = { a: 1, b: 2, c: 3 };

या प्रश्नों के नमूने के साथ:

const myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
const { regex, ...newObject } = myObject;
console.log(newObject);

आप इसे बेबील ट्राई-आउट संपादक में एक्शन में देख सकते हैं।

---

संपादित करें:

उसी चर को पुन: असाइन करने के लिए, letनिम्न का उपयोग करें :

let myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
({ regex, ...myObject } = myObject);
console.log(myObject);

Comments

हो सकता है क्योंकि लक्ष्य एक वस्तु से एक संपत्ति को हटाने के लिए है, न कि संपत्ति के बिना एक नया बनाने के लिए ... हालांकि, आपका समाधान मेरा पसंदीदा है, क्योंकि मैं अपरिवर्तनीय तरीके से पसंद करता हूं।

— Vingt_centimes

प्रश्न " नए myObject के साथ समाप्त करने के लिए" कहा गया है ।

— कोएन।

किसी संपत्ति को निकालने के लिए अंडरस्कोर जोड़ना आपकी परियोजना को प्रभावित करेगा :) उपलब्ध होने के बजाय जैसा कि regexआप इसे किसी अन्य चर को भी दे सकते हैं, उदाहरण के लिए _, एक परिणाम को त्यागने के लिए गो जैसी भाषाओं में क्या उपयोग किया जाता है const { regex: _, ...newObject } = myObject;:।

— कोएन।

@PranayKumar मुझे उम्मीद थी कि यह वाक्य रचना काम करेगी; const { [key], ...newObject } = myObject;लेकिन ऐसा नहीं है, इसलिए मुझे नहीं लगता कि यह विनाशकारी है।

— कोएन।

साथ freeze()'घ और seal()' घ वस्तुओं, तो आप बस नहीं कर सकते हैं deleteएक संपत्ति। तो यह एक उत्कृष्ट विकल्प है। हालांकि ज्यादातर मामलों में, किसी भी तरह से जमी / सील की गई वस्तु से संपत्ति को हटाने का कोई मतलब नहीं होगा, यह देखते हुए कि पूरे बिंदु आपके डेटा संरचनाओं के बारे में कुछ गारंटी देने के लिए है, जिनमें से यह पैटर्न कमजोर होगा। उन मामलों के लिए जहां आपको गैर-विनाशकारी रूप से किसी वस्तु को डुबोने की आवश्यकता होती है, लेकिन इसके कुछ गुणों के बिना, यह सही है

— ब्रैडेन बेस्ट

Answer 6

फैला हुआ सिंटैक्स (ES6)

जिसको भी इसकी जरूरत हो ...

इस धागे में @ का जवाब पूरा करने के लिए, यदि आप प्रसार सिंटैक्स का उपयोग करके डायनामिक चर निकालना चाहते हैं, तो आप ऐसा कर सकते हैं:

const key = 'a';
        
const { [key]: foo, ...rest } = { a: 1, b: 2, c: 3 };

console.log(foo);  // 1
console.log(rest); // { b: 2, c: 3 }

* (जो 1 है) fooके मान के साथ एक नया चर होगा a।

अतिरिक्त जवाब 😇
किसी वस्तु से संपत्ति निकालने के कुछ सामान्य तरीके हैं।
प्रत्येक के पास अपने स्वयं के पेशेवरों और विपक्ष हैं ( इस प्रदर्शन की तुलना की जाँच करें ):

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

delete obj[key];

पुनर्मूल्यांकन की
तुलना में 2X से अधिक तेजी सेdelete, हालांकि संपत्ति कोनष्टनहीं किया जाताहै और इसे पुन: प्रसारित किया जा सकता है।

obj[key] = null;
obj[key] = false;
obj[key] = undefined;

स्प्रेड ऑपरेटर
यहES6ऑपरेटर हमें किसी भी गुण को छोड़कर, किसी नई प्रॉपर्टी को मौजूदा ऑब्जेक्ट को म्यूट किए बिना वापस करने की अनुमति देता है। नकारात्मक पक्ष यह है कि यह ऊपर से खराब प्रदर्शन है और इसका उपयोग करने का सुझाव नहीं दिया जाता है जब आपको एक समय में कई गुणों को हटाने की आवश्यकता होती है।

{ [key]: val, ...rest } = obj;

Comments

मुझे लगता है कि वस्तु शाब्दिकों के लिए प्रसार / बाकी वाक्यविन्यास केवल ES2018 (ES9) में शामिल किया गया था, ES6 नहीं, हालांकि कई JS इंजनों ने इसे पहले ही लागू कर दिया था।

— 20inc में त्रिनकोट

@trincot यह पहली बार 2014 ( github.com/tc39/proposal-object-rest-spread ) में पेश किया गया था और यह एक ES6 (ECMAScript 2015 aka ECMAScript 6 वें संस्करण) फीचर है। हालांकि, भले ही मैं गलत हूं, मुझे नहीं लगता कि इससे उत्तर के संदर्भ में कोई फर्क पड़ता है।

— लायर एलरोम

लिंक ईएस 6 को संदर्भित करता है जहां वास्तव में फैलाने वाले सिंटैक्स को सरणियों के लिए पेश किया गया था, लेकिन फिर यह वस्तु शाब्दिकों के लिए कुछ समान प्रस्तावित करता है। अगर मैं गलत नहीं हूँ तो उस दूसरे भाग को केवल ES9 में शामिल किया गया था।

— त्रिनकोट

Answer 7

एक अन्य विकल्प अंडरस्कोर.जेएस लाइब्रेरी का उपयोग करना है।

ध्यान दें कि _.pick()और _.omit()दोनों वस्तु की एक प्रति लौटाते हैं और मूल वस्तु को सीधे संशोधित नहीं करते हैं। परिणाम को मूल वस्तु को सौंपकर चाल (नहीं दिखाया गया) करना चाहिए।

संदर्भ: लिंक _.पिक (ऑब्जेक्ट, * कुंजियाँ)

ऑब्जेक्ट की एक प्रति लौटाएं, केवल फ़िल्टर की गई वाइटेल्ड कुंजियों (या मान्य कुंजियों के सरणी) के लिए मानों को फ़िल्टर किया गया हो।

var myJSONObject = 
{"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};

_.pick(myJSONObject, "ircEvent", "method");
=> {"ircEvent": "PRIVMSG", "method": "newURI"};

संदर्भ: लिंक _.omit (ऑब्जेक्ट, * कुंजियाँ)

काली सूची वाली कुंजियों (या कुंजियों की सरणी) को छोड़ने के लिए फ़िल्टर की गई वस्तु की एक प्रति लौटाएं।

var myJSONObject = 
{"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};

_.omit(myJSONObject, "regex");
=> {"ircEvent": "PRIVMSG", "method": "newURI"};

सरणियों के लिए, _.filter()और _.reject()एक समान तरीके से उपयोग किया जा सकता है।

Comments

ध्यान रखें कि यदि आपके वस्तु की कुंजी नंबर दिए गए हैं, तो आप की आवश्यकता हो सकती_.omit(collection, key.toString())

— जॉर्डन Arseno

हम्म्म्म .... अंडरस्कोर है ~ ~ 100x से धीमा delete obj[prop]जो ~ ~ 100x से धीमा है obj[prop] = undefined।

— जैक गिफिन

Answer 8

आपके प्रश्न शीर्षक में आपने जो शब्द प्रयोग किया है Remove a property from a JavaScript object, उसकी व्याख्या कुछ अलग तरीकों से की जा सकती है। एक यह है कि इसे पूरी मेमोरी और ऑब्जेक्ट कुंजियों की सूची के लिए हटा दिया जाए या दूसरा केवल इसे अपनी ऑब्जेक्ट से हटाने के लिए है। जैसा कि कुछ अन्य उत्तरों में बताया गया है, deleteकीवर्ड मुख्य भाग है। मान लीजिए कि आपके पास अपनी वस्तु है:

myJSONObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};

यदि तुम करो:

console.log(Object.keys(myJSONObject));

परिणाम होगा:

["ircEvent", "method", "regex"]

आप अपनी ऑब्जेक्ट कुंजी से उस विशिष्ट कुंजी को हटा सकते हैं जैसे:

delete myJSONObject["regex"];

तब आपकी वस्तुओं का उपयोग Object.keys(myJSONObject)करना महत्वपूर्ण होगा:

["ircEvent", "method"]

लेकिन बात यह है कि यदि आप मेमोरी की परवाह करते हैं और आप चाहते हैं कि पूरी ऑब्जेक्ट मेमोरी से हट जाए, तो कुंजी को हटाने से पहले इसे शून्य पर सेट करने की सिफारिश की जाती है:

myJSONObject["regex"] = null;
delete myJSONObject["regex"];

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

var regex = myJSONObject["regex"];

या इसे किसी अन्य ऑब्जेक्ट की तरह एक नए पॉइंटर के रूप में जोड़ें:

var myOtherObject = {};
myOtherObject["regex"] = myJSONObject["regex"];

फिर भले ही आप इसे अपनी वस्तु से हटा दें myJSONObject, लेकिन उस विशिष्ट वस्तु को regexचर से हटा दिया जाएगा और फिर myOtherObject["regex"]भी उनके मान नहीं होंगे। फिर हम सुनिश्चित करने के लिए मेमोरी से ऑब्जेक्ट को कैसे हटा सकते हैं?

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

इस मामले में इसका मतलब है कि आप उस वस्तु को नहीं निकाल पाएंगे क्योंकि आपने regexएक varबयान के माध्यम से चर बनाया है , और यदि आप ऐसा करते हैं:

delete regex; //False

इसका परिणाम यह होगा false, जिसका अर्थ है कि आपके हटाए गए कथन को निष्पादित नहीं किया गया है जैसा कि आप उम्मीद करते हैं। लेकिन अगर आपने उस चर को पहले नहीं बनाया था, और आपके पास केवल myOtherObject["regex"]आपके मौजूदा मौजूदा संदर्भ के रूप में था , तो आप इसे हटाकर ऐसा कर सकते थे:

myOtherObject["regex"] = null;
delete myOtherObject["regex"];

दूसरे शब्दों में, जैसे ही आपके ऑब्जेक्ट में कोई संदर्भ नहीं छोड़ा जाता है, वैसे ही एक जावास्क्रिप्ट ऑब्जेक्ट मारा जाता है।

---

अपडेट: @AgentME को धन्यवाद:

हटाने से पहले किसी संपत्ति को शून्य करने के लिए सेट करना कुछ भी पूरा नहीं करता है (जब तक कि ऑब्जेक्ट को ऑब्जेक्ट द्वारा सील नहीं किया गया हो और हटाए जाने में विफल हो। यह आमतौर पर ऐसा नहीं है जब तक कि आप विशेष रूप से कोशिश न करें)।

अधिक जानकारी प्राप्त करने के लिए Object.seal: Object.seal ()

Comments

आप गलत हैं - केवल ऑब्जेक्ट्स को जावास्क्रिप्ट में संदर्भ द्वारा पारित किया जाता है, इसलिए यदि myJSONObject.regexमान एक स्ट्रिंग है और आप इसे किसी अन्य ऑब्जेक्ट पर असाइन करते हैं, तो अन्य ऑब्जेक्ट में इस मान की एक प्रति है।

— मिशैल पेरोलाकोव्स्की 16

आप सही हैं और यह एक उद्धरण है: "एक ही वस्तु के अपने अन्य संदर्भों के बारे में सावधान रहना।"

— मेहरान हटामी

Answer 9

ECMAScript 2015 (या ES6) बिल्ट-इन रिफ्लेक्ट ऑब्जेक्ट के साथ आया था । लक्ष्य वस्तु और संपत्ति कुंजी के मापदंडों के रूप में Reflect.deleteProperty () फ़ंक्शन को कॉल करके ऑब्जेक्ट संपत्ति को हटाना संभव है :

Reflect.deleteProperty(myJSONObject, 'regex');

जो इसके बराबर है:

delete myJSONObject['regex'];

लेकिन यदि ऑब्जेक्ट की संपत्ति कॉन्फ़िगर करने योग्य नहीं है, तो इसे न तो डिलीटप्रॉपरेटी फ़ंक्शन के साथ हटाया जा सकता है और न ही ऑपरेटर को हटाया जा सकता है:

let obj = Object.freeze({ prop: "value" });
let success = Reflect.deleteProperty(obj, "prop");
console.log(success); // false
console.log(obj.prop); // value

ऑब्जेक्ट.फ़्रीज़ () ऑब्जेक्ट के सभी गुणों को कॉन्फ़िगर करने योग्य नहीं बनाता है (अन्य चीजों के अलावा)। deletePropertyफ़ंक्शन (साथ ही हटाए गए ऑपरेटर ) रिटर्न falseतब देता है जब यह किसी भी गुण को हटाने की कोशिश करता है। यदि संपत्ति कॉन्फ़िगर करने योग्य है true, तो वह वापस आती है , भले ही संपत्ति मौजूद न हो।

के बीच अंतर है deleteऔर deletePropertyसख्त मोड का उपयोग करते समय:

"use strict";

let obj = Object.freeze({ prop: "value" });
Reflect.deleteProperty(obj, "prop"); // false
delete obj["prop"];
// TypeError: property "prop" is non-configurable and can't be deleted

Comments

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

— madox2

Answer 10

मान लीजिए कि आपके पास एक वस्तु है जो इस तरह दिखती है:

var Hogwarts = {
    staff : [
        'Argus Filch',
        'Filius Flitwick',
        'Gilderoy Lockhart',
        'Minerva McGonagall',
        'Poppy Pomfrey',
        ...
    ],
    students : [
        'Hannah Abbott',
        'Katie Bell',
        'Susan Bones',
        'Terry Boot',
        'Lavender Brown',
        ...
    ]
};

ऑब्जेक्ट प्रॉपर्टी हटाना

यदि आप संपूर्ण staffसरणी का उपयोग करना चाहते हैं , तो ऐसा करने का उचित तरीका है:

delete Hogwarts.staff;

वैकल्पिक रूप से, आप यह भी कर सकते हैं:

delete Hogwarts['staff'];

इसी तरह, पूरे छात्रों को हटाने से कॉल करके delete Hogwarts.students;या किया जाएगा delete Hogwarts['students'];।

एक सरणी सूचकांक को हटाना

अब, यदि आप किसी एकल स्टाफ सदस्य या छात्र को हटाना चाहते हैं, तो प्रक्रिया थोड़ी भिन्न है, क्योंकि दोनों गुण स्वयं को गिरफ्तार कर रहे हैं।

यदि आप अपने स्टाफ सदस्य का सूचकांक जानते हैं, तो आप बस यह कर सकते हैं:

Hogwarts.staff.splice(3, 1);

यदि आप सूचकांक नहीं जानते हैं, तो आपको एक सूचकांक खोज भी करनी होगी:

Hogwarts.staff.splice(Hogwarts.staff.indexOf('Minerva McGonnagall') - 1, 1);

---

ध्यान दें

जब आप तकनीकी रूप से deleteएक सरणी के लिए उपयोग कर सकते हैं , तो इसका उपयोग करने Hogwarts.staff.lengthपर बाद में उदाहरण के लिए कॉल करने पर गलत परिणाम प्राप्त होंगे । दूसरे शब्दों में, deleteतत्व को हटा देगा, लेकिन यह lengthसंपत्ति के मूल्य को अपडेट नहीं करेगा । का उपयोग deleteकरना भी आपके अनुक्रमण को गड़बड़ कर देगा।

इसलिए, किसी ऑब्जेक्ट से मान हटाते समय, हमेशा पहले विचार करें कि क्या आप ऑब्जेक्ट प्रॉपर्टीज के साथ काम कर रहे हैं या क्या आप एरे वैल्यूज़ के साथ काम कर रहे हैं, और उसके आधार पर उपयुक्त रणनीति चुनें।

यदि आप इसके साथ प्रयोग करना चाहते हैं, तो आप इस फिडल को शुरुआती बिंदु के रूप में उपयोग कर सकते हैं ।

Comments

मुझे लगता है कि आपको हमेशा spliceइसके बजाय एक सरणी पर उपयोग करना चाहिए delete।

— जोएल ट्रुगर

@JoelTrauger: यही तो मैं कह रहा हूं ;-)

— जॉन सैल्जर्स

हाँ। मेरी टिप्पणी है कि deleteयह भी एक बात नहीं होनी चाहिए। यह spliceवही है जो ओपी देख रहा था।

— जोएल ट्रुगर

@JoelTrauger: जैसा कि मैंने समझाने की कोशिश की, deleteका उपयोग ऑब्जेक्ट गुणों के लिए और spliceसरणी तत्वों के लिए किया जाना चाहिए ।

— जॉन सलेगर्स

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

— जैक जिफिन

Answer 11

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

(विनाशकारी + प्रसार ऑपरेटर)

const myObject = {
    regex: "^http://.*",
    b: 2,
    c: 3
};
const { regex, ...noRegex } = myObject;
console.log(noRegex); // => { b: 2, c: 3 }

Comments

मुझे नहीं लगता कि यह एक ईएस 6 फीचर है, लेकिन एक जो केवल ईएस 9 में शामिल था।

— 20

इसलिए वास्तव में आप ES6 का उपयोग नहीं कर रहे हैं, जैसा कि आप लिखते हैं, लेकिन ES9 ... ;-)

— trincot

यह किसी प्रॉपर्टी से किसी प्रॉपर्टी को हटा नहीं रहा है बल्कि उस प्रॉपर्टी के बिना एक नई ऑब्जेक्ट बना रहा है।

— जोर्डी नेबॉट

Answer 12

मैं व्यक्तिगत रूप से वस्तु और सरणी हेरफेर के लिए अंडरस्कोर.जेएस या लॉडश का उपयोग करता हूं :

myObject = _.omit(myObject, 'regex');

Answer 13

हटाने ऑपरेटर ऐसा करने के लिए सबसे अच्छा तरीका है।

दिखाने के लिए एक जीवंत उदाहरण:

var foo = {bar: 'bar'};
delete foo.bar;
console.log('bar' in foo); // Logs false, because bar was deleted from foo.

Comments

यह ध्यान देने योग्य हो सकता है कि कचरा संग्रह केdelete संबंध में ऑपरेटर का उपयोग स्वस्थ होने के बावजूद , यह अप्रत्याशित रूप से धीमा हो सकता है , उसी कारण से किसी भी छोटे हिस्से में नहीं।

— जॉन वीज़

Answer 14

संपत्ति के बिना ऑब्जेक्ट क्लोन करने के लिए:

उदाहरण के लिए:

let object = { a: 1, b: 2, c: 3 };   

और हमें 'a' को डिलीट करना होगा।

1. स्पष्ट सहारा कुंजी के साथ:

const { a, ...rest } = object;
object = rest;

2. चर चर कुंजी के साथ:

const propKey = 'a';
const { [propKey]: propValue, ...rest } = object;
object = rest;

3. कूल तीर समारोह:

const removePropery = (propKey, { [propKey]: propValue, ...rest }) => rest;

object = removePropery('a', object);

4. कई गुणों के लिए

const removeProperties = (object, ...keys) => Object.entries(object).reduce((prev, [key, value]) => ({...prev, ...(!keys.includes(key) && { [key]: value }) }), {})

प्रयोग

object = removeProperties(object, 'a', 'b') // result => { c: 3 }

या

    const propsToRemove = ['a', 'b']
    object = removeProperties(object, ...propsToRemove) // result => { c: 3 }

Comments

चालाक तीर समारोह!

— JSilv

Answer 15

डिलीट मेथड का उपयोग करना सबसे अच्छा तरीका है कि, एमडीएन विवरण के अनुसार, डिलीट ऑपरेटर किसी ऑब्जेक्ट से प्रॉपर्टी को हटा देता है। तो आप बस लिख सकते हैं:

delete myObject.regex;
// OR
delete myObject['regex'];

डिलीट ऑपरेटर किसी दिए गए प्रॉपर्टी को किसी ऑब्जेक्ट से हटा देता है। सफल विलोपन पर, यह सही लौटेगा, अन्यथा गलत लौटाया जाएगा। हालांकि, निम्नलिखित परिदृश्यों पर विचार करना महत्वपूर्ण है:

• यदि आप जिस संपत्ति को हटाने की कोशिश कर रहे हैं, वह मौजूद नहीं है, तो हटाने का कोई प्रभाव नहीं पड़ेगा और यह सच हो जाएगा

• यदि समान नाम वाली कोई संपत्ति ऑब्जेक्ट की प्रोटोटाइप श्रृंखला पर मौजूद है, तो, हटाने के बाद, ऑब्जेक्ट प्रोटोटाइप चेन से संपत्ति का उपयोग करेगा (दूसरे शब्दों में, हटाएं केवल स्वयं के गुणों पर प्रभाव पड़ता है)।

• Var के साथ घोषित किसी भी संपत्ति को वैश्विक दायरे या किसी फ़ंक्शन के दायरे से हटाया नहीं जा सकता है।

• जैसे, वैश्विक कार्यक्षेत्र में कोई भी फ़ंक्शन हटा नहीं सकता है (चाहे यह फ़ंक्शन परिभाषा या फ़ंक्शन (अभिव्यक्ति) से भाग हो।

• ऐसे कार्य जो किसी ऑब्जेक्ट का हिस्सा हैं (
  वैश्विक स्कोप के अलावा ) डिलीट के साथ हटाए जा सकते हैं।

• लेट या कास्ट के साथ घोषित किसी भी संपत्ति को उस दायरे से नहीं हटाया जा सकता है जिसके भीतर उन्हें परिभाषित किया गया था। गैर-विन्यास योग्य गुण नहीं निकाले जा सकते। इसमें मैथ, एरे, ऑब्जेक्ट जैसी बिल्ट-इन ऑब्जेक्ट्स के गुण शामिल हैं और जो ऑब्जेक्ट के रूप में नॉन-कंफिगरेबल के रूप में बनाए गए हैं, जैसे Object.defineProperty ()।

निम्नलिखित स्निपेट एक और सरल उदाहरण देता है:

var Employee = {
      age: 28,
      name: 'Alireza',
      designation: 'developer'
    }
    
    console.log(delete Employee.name);   // returns true
    console.log(delete Employee.age);    // returns true
    
    // When trying to delete a property that does 
    // not exist, true is returned 
    console.log(delete Employee.salary); // returns true

अधिक जानकारी के लिए और अधिक उदाहरण देखने के लिए, नीचे दिए गए लिंक पर जाएँ:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete

Answer 16

एक और समाधान, का उपयोग कर Array#reduce।

var myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*"
};

myObject = Object.keys(myObject).reduce(function(obj, key) {
  if (key != "regex") {           //key you want to remove
    obj[key] = myObject[key];
  }
  return obj;
}, {});

console.log(myObject);

हालाँकि, यह मूल ऑब्जेक्ट को म्यूट कर देगा । यदि आप निर्दिष्ट कुंजी के बिना एक नया ऑब्जेक्ट बनाना चाहते हैं , तो बस कम फ़ंक्शन को एक नए चर में असाइन करें, जैसे:

(ES6)

const myObject = {
  ircEvent: 'PRIVMSG',
  method: 'newURI',
  regex: '^http://.*',
};

const myNewObject = Object.keys(myObject).reduce((obj, key) => {
  key !== 'regex' ? obj[key] = myObject[key] : null;
  return obj;
}, {});

console.log(myNewObject);

Answer 17

यह पोस्ट बहुत पुरानी है और मुझे यह बहुत मददगार लगती है इसलिए मैंने निर्णय लिया कि मैंने किसी और के द्वारा इस पोस्ट को देखे जाने की स्थिति में लिखा हुआ अनसेट फंक्शन को साझा करने का निर्णय लिया और यह सोचा कि यह इतना सरल क्यों नहीं है क्योंकि यह PHP अनसेट फंक्शन में है।

इस नए unsetफ़ंक्शन को लिखने का कारण , इस हैशमैप में अन्य सभी चर का सूचकांक रखना है। निम्नलिखित उदाहरण को देखें, और देखें कि हैश_मैप से मान निकालने के बाद "test2" का सूचकांक कैसे नहीं बदला।

function unset(unsetKey, unsetArr, resort){
  var tempArr = unsetArr;
  var unsetArr = {};
  delete tempArr[unsetKey];
  if(resort){
    j = -1;
  }
  for(i in tempArr){
    if(typeof(tempArr[i]) !== 'undefined'){
      if(resort){
        j++;
      }else{
        j = i;
      }
      unsetArr[j] = tempArr[i];
    }
  }
  return unsetArr;
}

var unsetArr = ['test','deletedString','test2'];

console.log(unset('1',unsetArr,true)); // output Object {0: "test", 1: "test2"}
console.log(unset('1',unsetArr,false)); // output Object {0: "test", 2: "test2"}

Answer 18

यहाँ बहुत सारे अच्छे उत्तर हैं, लेकिन मैं सिर्फ इसमें झंकार करना चाहता हूं कि जावास्क्रिप्ट में एक संपत्ति को हटाने के लिए डिलीट का उपयोग करते समय, अक्सर यह जांचने के लिए बुद्धिमान होता है कि क्या संपत्ति त्रुटियों को रोकने के लिए मौजूद है।

उदाहरण के लिए

var obj = {"property":"value", "property2":"value"};

if (obj && obj.hasOwnProperty("property2")) {
  delete obj.property2;
} else {
  //error handling
}

जावास्क्रिप्ट की गतिशील प्रकृति के कारण अक्सर ऐसे मामले होते हैं जहां आप बस यह नहीं जानते हैं कि संपत्ति मौजूद है या नहीं। जाँच करना कि क्या obj से पहले मौजूद है && यह भी सुनिश्चित करता है कि किसी अपरिभाषित वस्तु पर hasOwnProperty () फ़ंक्शन को कॉल करने के कारण आपको कोई त्रुटि नहीं है।

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

Comments

यदि बार मौजूद नहीं है, तो भी foo.bar कार्य हटाएं, इसलिए आपका परीक्षण बहुत अधिक है, IMHO।

— फीलो

@PhiLho जो इस बात पर निर्भर करता है कि आप जावास्क्रिप्ट कहां चला रहे हैं। Node.js में मेरा मानना ​​है कि इससे आपका सर्वर क्रैश हो सकता है।

— विलेम

delete foo.bar;केवल एक अपवाद फेंकता है अगर फू गलत है, या यदि आप सख्त मोड में हैं और फू एक अपुष्ट बार संपत्ति के साथ एक वस्तु है।

— मैकिल

मुझे यह याद नहीं है कि मुझे इससे क्या समस्या है, लेकिन मुझे लगता है कि समस्या तब सामने आ सकती है जब फू खुद मौजूद नहीं है और आप इसे हटाने की कोशिश कर रहे हैं।

— विलेम

हाँ, आपको परीक्षण करना होगा कि क्या फू मौजूद है, अन्यथा foo.bar अपवाद को फेंक देगा, लेकिन आपको इसे हटाने से पहले बार के लिए अस्तित्व की जांच करने की आवश्यकता नहीं है। यह मेरी टिप्पणी का "बहुत अधिक" हिस्सा है। :-)

— फीलो

Answer 19

का उपयोग करते हुए ramda # dissoc आप विशेषता के बिना एक नई वस्तु मिल जाएगा regex:

const newObject = R.dissoc('regex', myObject);
// newObject !== myObject

आप एक ही प्रभाव को प्राप्त करने के लिए अन्य कार्यों का भी उपयोग कर सकते हैं - ओटिट, पिक, ...

Answer 20

निम्न विधि का प्रयास करें। के लिए Objectसंपत्ति मान असाइन करें undefined। फिर stringifyवस्तु और parse।

 var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};

myObject.regex = undefined;
myObject = JSON.parse(JSON.stringify(myObject));

console.log(myObject);

Comments

इसके अलावाJSON.parse(JSON.stringify({ ...myObject, regex: undefined }))

— noisypixy

Answer 21

यदि आप किसी संपत्ति को ऑब्जेक्ट में गहराई से हटाना चाहते हैं, तो आप दूसरे के रूप में संपत्ति के लिए पथ के साथ निम्न पुनरावर्ती फ़ंक्शन का उपयोग कर सकते हैं:

var deepObjectRemove = function(obj, path_to_key){
    if(path_to_key.length === 1){
        delete obj[path_to_key[0]];
        return true;
    }else{
        if(obj[path_to_key[0]])
            return deepObjectRemove(obj[path_to_key[0]], path_to_key.slice(1));
        else
            return false;
    }
};

उदाहरण:

var a = {
    level1:{
        level2:{
            level3: {
                level4: "yolo"
            }
        }
    }
};

deepObjectRemove(a, ["level1", "level2", "level3"]);
console.log(a);

//Prints {level1: {level2: {}}}

Comments

यह फ़ंक्शन एक आकर्षण की तरह काम करता है, लेकिन हमें सही और सही रिटर्न की आवश्यकता क्यों है? कोड का मेरा संस्करण: codepen.io/anon/pen/rwbppY । क्या मेरा संस्करण किसी भी मामले में विफल होगा?

— जूसियल

@ witty2017 यह विफल नहीं होगा। जिस स्थान पर मैंने फ़ंक्शन का उपयोग किया है, उसे यह जांचने की भी आवश्यकता है कि संपत्ति पहले से मौजूद है या नहीं। यदि संपत्ति मौजूद नहीं है, तो यह गलत होगा। यदि यह संपत्ति पाता है और इसे हटा देता है, तो यह सच हो जाएगा।

— आयुष जीप

Answer 22

आप बस deleteकीवर्ड का उपयोग करके किसी ऑब्जेक्ट की किसी भी संपत्ति को हटा सकते हैं ।

उदाहरण के लिए:

var obj = {key1:"val1",key2:"val2",key3:"val3"}

किसी भी संपत्ति को निकालने के लिए, इस तरह key1से deleteकीवर्ड का उपयोग करें:

delete obj.key1

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

delete obj[key1]

Ref: एमडीएन ।

Answer 23

Object.assign () और Object.keys () और Array.map ()

const obj = {
    "Filters":[
        {
            "FilterType":"between",
            "Field":"BasicInformationRow.A0",
            "MaxValue":"2017-10-01",
            "MinValue":"2017-09-01",
            "Value":"Filters value"
        }
    ]
};

let new_obj1 = Object.assign({}, obj.Filters[0]);
let new_obj2 = Object.assign({}, obj.Filters[0]);

/*

// old version

let shaped_obj1 = Object.keys(new_obj1).map(
    (key, index) => {
        switch (key) {
            case "MaxValue":
                delete new_obj1["MaxValue"];
                break;
            case "MinValue":
                delete new_obj1["MinValue"];
                break;
        }
        return new_obj1;
    }
)[0];


let shaped_obj2 = Object.keys(new_obj2).map(
    (key, index) => {
        if(key === "Value"){
            delete new_obj2["Value"];
        }
        return new_obj2;
    }
)[0];


*/


// new version!

let shaped_obj1 = Object.keys(new_obj1).forEach(
    (key, index) => {
        switch (key) {
            case "MaxValue":
                delete new_obj1["MaxValue"];
                break;
            case "MinValue":
                delete new_obj1["MinValue"];
                break;
            default:
                break;
        }
    }
);

let shaped_obj2 = Object.keys(new_obj2).forEach(
    (key, index) => {
        if(key === "Value"){
            delete new_obj2["Value"];
        }
    }
);

Answer 24

डैन का दावा है कि 'डिलीट' बहुत धीमी है और उसने जो बेंचमार्क पोस्ट किया था उस पर संदेह किया गया था। इसलिए मैंने अपने आप को Chrome 59 में परीक्षण किया। ऐसा लगता है कि 'हटाना' लगभग 30 गुना धीमा है:

var iterationsTotal = 10000000;  // 10 million
var o;
var t1 = Date.now(),t2;
for (let i=0; i<iterationsTotal; i++) {
   o = {a:1,b:2,c:3,d:4,e:5};
   delete o.a; delete o.b; delete o.c; delete o.d; delete o.e;
}
console.log ((t2=Date.now())-t1);  // 6135
for (let i=0; i<iterationsTotal; i++) {
   o = {a:1,b:2,c:3,d:4,e:5};
   o.a = o.b = o.c = o.d = o.e = undefined;
}
console.log (Date.now()-t2);  // 205

ध्यान दें कि मैंने दूसरे ऑपरेशन के कारण होने वाले प्रभाव को कम करने के लिए एक लूप चक्र में एक से अधिक 'डिलीट' ऑपरेशन किए थे।

Answer 25

"regex"संपत्ति के बिना एक नई वस्तु बनाने पर विचार करें क्योंकि मूल वस्तु को हमेशा आपके कार्यक्रम के अन्य भागों द्वारा संदर्भित किया जा सकता है। इस प्रकार आपको इसमें हेरफेर करने से बचना चाहिए।

const myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};

const { regex, ...newMyObject } = myObject;

console.log(newMyObject);

Comments

SyntaxError: Unexpected token '...'. Expected a property name.?

— Krzysztof Przygoda

इसे आधुनिक ब्राउज़र जैसे फ़ायरफ़ॉक्स, क्रोमियम या सफारी के साथ आज़माएँ। और मुझे उम्मीद है कि यह एज के साथ भी काम करेगा।

— विचारक

एक विकल्प के रूप में, यदि आपके ग्राहक आपको पुराने ब्राउज़रों का समर्थन करने के लिए मजबूर करते हैं, तो आप टाइपस्क्रिप्ट का उपयोग करने पर विचार कर सकते हैं जो आपके कोड को विरासत सिंटैक्स में ट्रांसप्लेस करता है (+ आपको स्थैतिक प्रकार की सुरक्षा का लाभ देता है)।

— विचारक

Answer 26

जावास्क्रिप्ट में संपत्ति निकालना

इस पृष्ठ पर कई अलग-अलग विकल्प प्रस्तुत किए गए हैं, इसलिए नहीं कि अधिकांश विकल्प गलत हैं- या क्योंकि उत्तर डुप्लिकेट हैं- बल्कि इसलिए कि उपयुक्त तकनीक उस स्थिति पर निर्भर करती है, जिसमें आप और / या आपके द्वारा किए गए कार्यों के लक्ष्य हैं टीम पूरी करने की कोशिश कर रही है। उत्तर देने के लिए आप बिना सोचे समझे सवाल करें:

1. ECMAScript का वह संस्करण जिसे आप लक्षित कर रहे हैं
2. आप जिस प्रकार के ऑब्जेक्ट को हटाना चाहते हैं, उस प्रकार की प्रॉपर्टी और जिस प्रकार के प्रॉपर्टी के नाम आप को छोड़ना होगा (स्ट्रिंग्स केवल? सिंबल्स? वीक रेफरेंस)। )
3. प्रोग्रामिंग लोकाचार / पैटर्न आप और आपकी टीम का उपयोग करते हैं। क्या आप कार्यात्मक दृष्टिकोण का पक्ष लेते हैं और म्यूटेशन आपकी टीम पर है, या आप वाइल्ड वेस्ट म्यूटेटिव ऑब्जेक्ट-ओरिएंटेड तकनीकों को नियुक्त करते हैं?
4. क्या आप इसे शुद्ध जावास्क्रिप्ट में प्राप्त करना चाहते हैं या आप तृतीय-पक्ष पुस्तकालय का उपयोग करने के लिए तैयार हैं या सक्षम हैं?

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

उत्परिवर्ती वस्तु संपत्ति का विलोपन, असुरक्षित

यह श्रेणी ऑब्जेक्ट शाब्दिक या ऑब्जेक्ट इंस्टेंस पर परिचालन के लिए है जब आप मूल संदर्भ का उपयोग करना / जारी रखना चाहते हैं और अपने कोड में स्टेटलेस फंक्शनल सिद्धांतों का उपयोग नहीं कर रहे हैं। इस श्रेणी में वाक्य रचना का एक उदाहरण:

'use strict'
const iLikeMutatingStuffDontI = { myNameIs: 'KIDDDDD!', [Symbol.for('amICool')]: true }
delete iLikeMutatingStuffDontI[Symbol.for('amICool')] // true
Object.defineProperty({ myNameIs: 'KIDDDDD!', 'amICool', { value: true, configurable: false })
delete iLikeMutatingStuffDontI['amICool'] // throws

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

आराम-आधारित स्ट्रिंग संपत्ति छूट

यह श्रेणी नए ECMAScript फ्लेवर्स में सादे ऑब्जेक्ट या एरे इंस्टेंस पर काम करने के लिए है जब एक गैर-म्यूटेटिव दृष्टिकोण वांछित है और आपको सिंबल कीज़ के लिए खाते की आवश्यकता नहीं है:

const foo = { name: 'KIDDDDD!', [Symbol.for('isCool')]: true }
const { name, ...coolio } = foo // coolio doesn't have "name"
const { isCool, ...coolio2 } = foo // coolio2 has everything from `foo` because `isCool` doesn't account for Symbols :(

म्यूटेटिव ऑब्जेक्ट प्रॉपर्टी विलोपन, सुरक्षित

यह श्रेणी ऑब्जेक्ट शाब्दिक या ऑब्जेक्ट इंस्टेंसेस पर काम करने के लिए है, जब आप अपुष्ट गुणों पर फेंके जा रहे अपवादों की रक्षा करते हुए मूल संदर्भ का उपयोग करना / बनाए रखना चाहते हैं:

'use strict'
const iLikeMutatingStuffDontI = { myNameIs: 'KIDDDDD!', [Symbol.for('amICool')]: true }
Reflect.deleteProperty(iLikeMutatingStuffDontI, Symbol.for('amICool')) // true
Object.defineProperty({ myNameIs: 'KIDDDDD!', 'amICool', { value: true, configurable: false })
Reflect.deleteProperty(iLikeMutatingStuffDontI, 'amICool') // false

इसके अलावा, ऑब्जेक्ट्स-इन-प्लेस को स्थिर नहीं करते हुए, आप Reflect.deletePropertyआंशिक अनुप्रयोग और अन्य कार्यात्मक तकनीकों को करने के लिए कार्यात्मक प्रकृति का उपयोग कर सकते हैं जो deleteबयानों के साथ संभव नहीं हैं ।

सिंटेक्स-आधारित स्ट्रिंग गुण चूक

यह श्रेणी नए ECMAScript फ्लेवर्स में सादे ऑब्जेक्ट या एरे इंस्टेंस पर काम करने के लिए है जब एक गैर-म्यूटेटिव दृष्टिकोण वांछित है और आपको सिंबल कीज़ के लिए खाते की आवश्यकता नहीं है:

const foo = { name: 'KIDDDDD!', [Symbol.for('isCool')]: true }
const { name, ...coolio } = foo // coolio doesn't have "name"
const { isCool, ...coolio2 } = foo // coolio2 has everything from `foo` because `isCool` doesn't account for Symbols :(

लाइब्रेरी-आधारित संपत्ति की चूक

यह श्रेणी आम तौर पर अधिक कार्यात्मक लचीलेपन की अनुमति देती है, जिसमें प्रतीक के लिए लेखांकन और एक बयान में एक से अधिक संपत्ति को छोड़ना शामिल है:

const o = require("lodash.omit")
const foo = { [Symbol.for('a')]: 'abc', b: 'b', c: 'c' }
const bar = o(foo, 'a') // "'a' undefined"
const baz = o(foo, [ Symbol.for('a'), 'b' ]) // Symbol supported, more than one prop at a time, "Symbol.for('a') undefined"

Comments

var keyname = "कीनेम"; myObject को हटाएं [keyname];

— विकाश चौहान

Answer 27

const myObject = {
        "ircEvent": "PRIVMSG",
        "method": "newURI",
        "regex": "^http://.*"
    };

const { regex, ...other } = myObject;

console.log(myObject)
console.log(regex)
console.log(other)

Comments

@CoddWrench क्षमा करें, मैंने उस उत्तर को देखने पर ध्यान नहीं दिया। मैं देखने के तुरंत बाद इसका जवाब देता हूं delete myObject.regex;।

— ज़ियांग

Answer 28

आप आराम ऑपरेटर के साथ ES6 विनाशकारी का उपयोग कर सकते हैं।

बाकी ऑपरेटर के साथ संयोजन में विनाशकारी का उपयोग करके गुणों को हटाया जा सकता है । आपके उदाहरण में रेगेक्स को नष्ट (नजरअंदाज) कर दिया जाता है और बाकी गुणों को बाकी के रूप में वापस कर दिया जाता है।

const noRegex = ({ regex, ...rest }) => rest;
const myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*"
};

console.log(noRegex(myObjext)) //=> {  "ircEvent": "PRIVMSG","method": "newURI" }

या आप गतिशील रूप से इस तरह के गुणों को बाहर कर सकते हैं,

const myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*"
};
const removeProperty = prop => ({ [prop]: _, ...rest }) => rest

const removeRegex = removeProperty('regex') //=> {  "ircEvent": "PRIVMSG","method":"newURI" }
const removeMethod = removeProperty('method') //=> {  "ircEvent": "PRIVMSG", "regex":"^http://.*" }

Answer 29

हम निम्नलिखित का उपयोग करके किसी भी ऑब्जेक्ट को जावास्क्रिप्ट ऑब्जेक्ट से हटा सकते हैं:

1. ऑब्जेक्ट हटाएं
2. ऑब्जेक्ट हटाएं ['संपत्ति']

उदाहरण:

var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};

console.log(myObject);

delete myObject.regex;
console.log('=================');
console.log(myObject);
delete myObject['method'];
console.log('=================');
console.log(myObject);

Answer 30

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

delete myObject['key'];