सवाल मैं जावास्क्रिप्ट ऑब्जेक्ट से किसी प्रॉपर्टी को कैसे हटा सकता हूं?


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

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

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

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

4910
2017-10-16 10:57


मूल


यहां एक बेंचमार्क खोजें जो "हटाएं" बनाम "अपरिभाषित" बनाम "शून्य" की तुलना करता है jsben.ch/#/BWMiw - EscapeNetscape
developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/... - titusfx


जवाब:


इस कदर:

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);

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


6839
2017-10-16 10:58



चेक किया गया, यह "myJSONObject ['regex'] को हटाएं" के साथ भी काम करता है; " देख: developer.mozilla.org/en/Core_JavaScript_1.5_Reference/... - johnstok
उपर्युक्त "समझ हटाने" लिंक पर अवलोकनों में से एक का एक सारांश यह है कि, चूंकि आप एक चर को हटा नहीं सकते हैं, लेकिन केवल ऑब्जेक्ट गुणों को हटा सकते हैं, इसलिए आप "संदर्भ द्वारा" ऑब्जेक्ट प्रॉपर्टी को हटा नहीं सकते हैं - var value = obj [ 'सहारा']; मूल्य हटाएं // काम नहीं करता है - George Jempty
तो यह वास्तव में इसे हटा नहीं है? यह अभी अपरिभाषित हो जाता है, लेकिन कुंजी अभी भी मौजूद है? क्या मैं कुछ भूल रहा हूँ? - Doug Molineux
@ पेट नंबर, यह इसे हटा देता है। दिया हुआ: 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 */ - nickf
@ChristopherPfohl मेरे लिए काम करता है। जैसे मैंने कहा, यह वास्तव में काफी गहराई से है, इसलिए संक्षेप में थोड़ा मुश्किल है। उपर्युक्त उत्तर में मूल प्रतिक्रिया लगभग सभी मामलों के लिए पर्याप्त है, ब्लॉग किनारे के कुछ मामलों में जाता है और उन मामलों के कारण मौजूद हैं। - nickf


ऑपरेटर delete अप्रत्याशित रूप से धीमा है!

की ओर देखने के लिए बेंचमार्क

हटाएं ऑब्जेक्ट के गुणों को बिना किसी बचे हुए निकालने का एकमात्र सही तरीका है, लेकिन यह काम करता है ~ 100 गुना धीमा, इसकी "वैकल्पिक" सेटिंग की तुलना में object[key] = undefined

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

कब उपयोग करना चाहिए delete और जब मूल्य निर्धारित करें undefined ?

एक वस्तु को कुंजी-मूल्य जोड़े के सेट के रूप में देखा जा सकता है। जिसे मैं 'मूल्य' कहता हूं वह एक मूल या अन्य वस्तु का संदर्भ है, जो उस 'कुंजी' से जुड़ा हुआ है।

उपयोग delete, जब आप परिणाम ऑब्जेक्ट को उस कोड पर पास कर रहे हैं जिस पर आपके पास नियंत्रण नहीं है (या जब आप अपनी टीम या स्वयं के बारे में निश्चित नहीं हैं)।

यह हैशपैप से कुंजी हटा देता है

 var obj = {
     field: 1     
 };
 delete obj.field;

सेटिंग का प्रयोग करें undefined, जब आप प्रदर्शन की परवाह करते हैं। यह आपके कोड को गंभीर बढ़ावा दे सकता है।

हैशप में अपनी जगह पर कुंजी बनी हुई है, केवल मूल्य के साथ प्रतिस्थापित किया गया है undefined। वह समझलो for..in लूप अभी भी उस कुंजी पर फिर से चालू हो जाएगा।

 var obj = {
     field: 1     
 };
 obj.field = undefined;

इस विधि का प्रयोग, सभी नहीं संपत्ति अस्तित्व का निर्धारण करने के तरीके उम्मीद के रूप में काम करेंगे।

हालांकि, यह कोड:

object.field === undefined

दोनों तरीकों के लिए समान रूप से व्यवहार करेंगे।

टेस्ट

संक्षेप में, संपत्ति अस्तित्व को निर्धारित करने के तरीकों के बारे में अंतर, और इसके बारे में हैं for..in पाश।

 console.log('* -> "Takes prototype inheritance into consideration, that means it lookups all over prototype chain too."');

 console.log(obj.field === undefined, 'obj.field === undefined', 'You get "undefined" value when querying for "field" in object-hashmap. *');

 console.log(obj["field"] === undefined, 'obj["field"] === undefined', 'Just another way to query (equivalent). *');

 console.log(typeof obj.field === "undefined", 'typeof obj.field === "undefined"', 'Get the value attached to "field" key, and check it\'s type is "undefined". *');

 console.log("field" in obj, '"field" in obj', 'This statement returns true if "field" key exists in the hashmap. False otherwise. *');

 console.log(obj.hasOwnProperty("field"), 'obj.hasOwnProperty("field")', 'This statement returns true if \'field\' key exists in the hashmap. The ONLY way NOT to lookup for property in the prototype chain!');
 //Object.keys().indexOf() is an overkill that runs much slower :)

 var counter = 0,
     key;
 for (key in obj) {
     counter++;
 }
 console.assert(counter === 0, 'counter === 0', '"field" is not iterated using "for .. in" loop. *');

मेमोरी लीक से सावधान रहें!

प्रयोग करते समय obj[prop] = undefined करने से तेज है delete obj[prop], एक और महत्वपूर्ण विचार यह है कि obj[prop] = undefined हमेशा उपयुक्त नहीं हो सकता है। delete obj[prop] हटा देगा prop से obj और इसे स्मृति से मिटा देता है जबकि obj[prop] = undefined बस का मूल्य निर्धारित करता है prop सेवा मेरे undefined जो छोड़ देता है prop अभी भी स्मृति में। इसलिए, परिस्थितियों में जहां कई चाबियां बनाई जा रही हैं और हटाई जा रही हैं obj[prop] = undefined महंगा मेमोरी सुलह को मजबूर कर सकता है (पृष्ठ को फ्रीज करने के कारण) और संभावित रूप से आउट-ऑफ-मेमोरी त्रुटि। निम्नलिखित कोड की जांच करें।

"use strict";
var theNodeList=[], i, current, numberOfNodes=65536, body=document.body, nodeRecords=[];
for (i = 0; i !== numberOfNodes; i++) {
    nodeRecords[i] = [];
    current = theNodeList[i] = document.createElement("div");
    current.textContent = i;
    document.body.appendChild( current );
}
var lastTime = -1;
requestAnimationFrame(function recordUpdates(){
    var currentTime = Math.round( performance.now()*1000 )
    for (i = 0; i !== numberOfNodes; i++) {
        if (lastTime !== -1) {
            // the previously collected data is no longer in use
            /*************************************************/
            /****/ nodeRecords[i][lastTime] = undefined; /****/
            /*************************************************/
        }
        nodeRecords[i][currentTime] = theNodeList[i].outerHTML;
    }
    lastTime = currentTime;
    requestAnimationFrame( recordUpdates );
});

उपरोक्त कोड में, बस कर रहे हैं nodeRecords[i][lastTime] = undefined; प्रत्येक एनीमेशन फ्रेम के कारण एक विशाल स्मृति रिसाव का कारण बन जाएगा। प्रत्येक फ्रेम, सभी 65536 डीओएम तत्व एक और 65536 व्यक्तिगत स्लॉट ले लेंगे, लेकिन पिछले 65536 स्लॉट केवल अपरिभाषित किए जाएंगे जो उन्हें स्मृति में लटकते हैं। आगे बढ़ें, उपरोक्त कोड को कंसोल में चलाने का प्रयास करें और स्वयं को देखें। आउट-ऑफ-मेमोरी त्रुटि को मजबूर करने के बाद, उस कोड के निम्न संस्करण को छोड़कर इसे फिर से चलाने का प्रयास करें deleteइसके बजाय ऑपरेटर।

"use strict";
var theNodeList=[], i, current, numberOfNodes=65536, body=document.body, nodeRecords=[];
for (i = 0; i !== numberOfNodes; i++) {
    nodeRecords[i] = [];
    current = theNodeList[i] = document.createElement("div");
    current.textContent = i;
    document.body.appendChild( current );
}
var lastTime = -1;
requestAnimationFrame(function recordUpdates(){
    var currentTime = Math.round( performance.now()*1000 )
    for (i = 0; i !== numberOfNodes; i++) {
        if (lastTime !== -1) {
            // the previously collected data is no longer in use
            /********************************************/
            /****/ delete nodeRecords[i][lastTime]; /****/
            /********************************************/
        }
        nodeRecords[i][currentTime] = theNodeList[i].outerHTML;
    }
    lastTime = currentTime;
    requestAnimationFrame( recordUpdates );
});

उपर्युक्त कोड स्निपेट में देखा गया है, इसके लिए कुछ दुर्लभ उपयुक्त उपयोग मामले हैं delete ऑपरेटर। हालांकि, इस समस्या के बारे में चिंता मत करो। यह केवल लंबी उम्र के वस्तुओं के साथ एक समस्या बन जाएगा जो उन्हें लगातार नई कुंजी मिलती है। किसी अन्य मामले में (जो वास्तविक दुनिया प्रोग्रामिंग में लगभग हर मामले है), यह उपयोग करने के लिए सबसे उपयुक्त है obj[prop] = undefined। इस खंड का मुख्य उद्देश्य यह आपके ध्यान में लाने के लिए है ताकि दुर्लभ मौका यह हो कि यह आपके कोड में एक समस्या बन जाए, तो आप समस्या को और आसानी से समझ सकते हैं और इस प्रकार अपने कोड को खोजने के लिए घंटों को बर्बाद नहीं करना पड़ेगा और इस समस्या को समझें।

हमेशा सेट न करें undefined

जावास्क्रिप्ट का एक पहलू जो विचार करना महत्वपूर्ण है वह बहुरूपता है। पॉलिमॉर्फिज्म तब होता है जब नीचे दिखाए गए समान वैरिएबल / स्लॉट-इन-ए-ऑब्जेक्ट को अलग-अलग प्रकार निर्दिष्ट करते हैं।

var foo = "str";
foo = 100;          // variable foo is now labeled polymorphic by the browser
var bar = ["Some", "example"];
bar[2] = "text";    // bar is a monomorphic array here because all its entries have the
                    // same type: string primitive
bar[1] = undefined; // bar is now a polymorphic array

हालांकि, पॉलिमॉर्फिक सरणी के साथ दो प्रमुख अपरिवर्तनीय समस्याएं हैं:

  1. वे धीमी और स्मृति अक्षम हैं। किसी विशेष अनुक्रमणिका तक पहुंचने के दौरान, सरणी के लिए वैश्विक प्रकार प्राप्त करने के बजाय, ब्राउज़र को इसके बजाय प्रति-अनुक्रमणिका आधार पर प्रकार प्राप्त करना होता है जिससे प्रत्येक अनुक्रमणिका इसके प्रकार के अतिरिक्त मेटाडेटा को संग्रहीत करती है।
  2. एक बार polymorphic, हमेशा polymorphic। जब एक सरणी polymorphic बनाया जाता है, वेबकिट ब्राउज़र में polymorphism पूर्ववत नहीं किया जा सकता है। इसलिए, भले ही आप गैर-पॉलीमोर्फिक होने के लिए एक पॉलिमॉर्फिक सरणी को पुनर्स्थापित करते हैं, फिर भी यह ब्राउज़र द्वारा पॉलिमॉर्फिक सरणी के रूप में संग्रहीत किया जाएगा।

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

लेकिन, एक दवा यात्रा समानता कैसे संबंधित है delete ऑपरेशन? उत्तर उपरोक्त स्निपेट में कोड की अंतिम पंक्ति को घेरता है। इस प्रकार इसे मोड़ के साथ, इस बार पुन: निष्पादित करने दें।

var bar = ["Some", "example"];
bar[2] = "text";    // bar is not a polymorphic array here because all its entries have the
                    // same type: string primitive
bar[1] = "";        // bar is still a monomorphic array
bar[1] = undefined; // bar is now a polymorphic array

ध्यान से देखें। bar[1] = "" जबकि polymorphism को मजबूर नहीं करता है bar[1] = undefined कर देता है। इसलिए, किसी को हमेशा, जब भी संभव हो, उनके ऑब्जेक्ट्स के लिए संबंधित प्रकार का उपयोग करना चाहिए ताकि गलती से पॉलिमॉर्फिज्म का कारण न हो। ऐसा एक व्यक्ति निम्नलिखित सूची का उपयोग उन्हें सामान्य संदर्भ के रूप में उपयोग करने के लिए कर सकता है। हालांकि, कृपया नीचे दिए गए विचारों का स्पष्ट रूप से उपयोग न करें। इसके बजाय, अपने कोड के लिए जो कुछ भी अच्छा काम करता है उसका उपयोग करें।

  • बूलियन आदिम में टाइप किए गए सरणी / चर का उपयोग करते समय, या तो उपयोग करें false या undefined खाली मूल्य के रूप में। अनावश्यक बहुरूपता से परहेज करना अच्छा है, अपने सभी कोड को स्पष्ट रूप से मना करने के लिए फिर से लिखना संभवतः वास्तव में प्रदर्शन में कमी का परिणाम होगा। आम निर्णय का प्रयोग करें!
  • संख्या आदिम टाइप किए गए सरणी / चर का उपयोग करते समय, उपयोग करें 0 खाली मूल्य के रूप में। ध्यान दें कि आंतरिक रूप से, दो प्रकार की संख्याएं हैं: तेज़ पूर्णांक (2147483647 से -2147483648 समावेशी) और धीमी गति से चलने वाली बिंदु युगल (इसके अलावा कुछ भी NaN तथा Infinity)। जब एक पूर्णांक को डबल पर स्थानांतरित किया जाता है, तो उसे पूर्णांक में वापस प्रचारित नहीं किया जा सकता है।
  • स्ट्रिंग आदिम पर टाइप किए गए सरणी / चर का उपयोग करते समय, उपयोग करें "" खाली मूल्य के रूप में।
  • एक प्रतीक का उपयोग करते समय, प्रतीक्षा करें, आप एक प्रतीक का उपयोग क्यों कर रहे हैं?!? प्रदर्शन के लिए प्रतीक बुजु जुजू हैं। प्रतीकों का उपयोग करने के लिए प्रोग्राम किए गए सब कुछ को प्रतीकों का उपयोग न करने के लिए पुन: प्रोग्राम किया जा सकता है, जिसके परिणामस्वरूप प्रतीकों के बिना एक तेज कोड होता है। प्रतीक वास्तव में केवल सुपर अक्षम मात्रा मेटा-चीनी हैं।
  • किसी और चीज का उपयोग करते समय, उपयोग करें null

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


705
2018-02-12 17:48



एक संपत्ति को अनिर्धारित करने के लिए असाइन किया गया है, फिर भी किसी ऑब्जेक्ट की संपत्ति है, इसलिए इसे जीसी द्वारा हटाया नहीं जाएगा, जब तक कि आपका अंतिम पैराग्राफ गलत न हो। - Lance
मैं यहां जीसी के विषय को छूने में गलत था। जीसी के लिए दोनों विधियों का एक ही परिणाम है: वे कुंजी से जुड़े मूल्य को हटा देते हैं। यदि वह मान किसी अन्य वस्तु का अंतिम संदर्भ था, तो उस वस्तु को साफ़ कर दिया जाएगा। - Dan
एक संपत्ति को अनिर्धारित करने के लिए असाइन किया गया है, फिर भी किसी ऑब्जेक्ट की संपत्ति है, इसलिए इसे जीसी द्वारा नहीं हटाया जाएगा जीसी गुणों के बारे में कुछ भी प्रबंधित नहीं करता है। यह मूल्य एकत्र करता है और हटा देता है। जब तक कुछ भी मूल्य (ऑब्जेक्ट, स्ट्रिंग इत्यादि) का संदर्भ नहीं देता है, तब तक जीसी इसे स्मृति से हटा देता है। - meandre
बीटीडब्लू, यह जांचने के लिए दोहरी समस्या है कि जावास्क्रिप्ट ऑब्जेक्ट पर कोई संपत्ति मौजूद है या नहीं। का उपयोग करते हुए में ऑपरेटर भरोसेमंद लेकिन धीमी है। जांचें कि संपत्ति नहीं है या नहीं अपरिभाषित "सही जवाब नहीं है" लेकिन यह एक तेज़ तरीका है। चेक - rdllopes
क्या यह उत्तर अभी भी प्रासंगिक है? jsperf वर्तमान में नीचे है, लेकिन यह बेंचमार्क ऐसा लगता है कि गति अंतर केवल 25% है, जो कहीं भी नहीं है बंद करे को "~ 100 गुना धीमा" इस जवाब में। - Cerbrus


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

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

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


193
2017-10-16 11:03



एक अभिव्यक्ति का उपयोग कर एक ही सरणी से एकाधिक गुणों को हटाने का कोई तरीका है - Aakriti.G
एक साथ कई गुणों को हटाने की कोशिश करते समय, क्या यह एक नई वस्तु को रीमेप करना बेहतर नहीं होगा? - jasonscript


2018-07-21 अपडेट करें: लंबे समय तक, मुझे इस जवाब के बारे में शर्मिंदा महसूस हुआ है, इसलिए मुझे लगता है कि यह समय है कि मैं इसे थोड़ा सा स्पर्श करता हूं। इस उत्तर के अनावश्यक रूप से लंबे और घिरे हिस्सों को पढ़ने में तेजी लाने में सहायता के लिए बस थोड़ी सी टिप्पणी, स्पष्टीकरण और स्वरूपण।


लघु संस्करण

सवाल का वास्तविक जवाब

जैसा कि अन्य ने कहा है, आप इसका उपयोग कर सकते हैं delete

obj // {"foo": "bar"}
delete obj["foo"]
obj // {}
obj["foo"] // undefined

ऐरे समकक्ष

नहीं delete एक सरणी से उपयोग Array.prototype.splice बजाय।

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

लंबा संस्करण

जावास्क्रिप्ट एक ओओपी भाषा है, इसलिए सब कुछ एक वस्तु है, सहित सरणियों। इस प्रकार, मुझे एक विशेष चेतावनी को इंगित करना आवश्यक लगता है।

सरणी पुरानी वस्तुओं के विपरीत, सरणी में delete के रूप में कचरे के पीछे छोड़ देता है null, सरणी में एक "छेद" बनाना।

var array = [1, 2, 3, 4];
delete array[2];
/* Expected result --> [1, 2, 4]
 * Actual result   --> [1, 2, null, 4]
 */

जैसा कि आप देख सकते हैं, delete हमेशा एक काम की उम्मीद नहीं कर सकता है। मान ओवरराइट किया गया है, लेकिन स्मृति को पुन: आवंटित नहीं किया गया है। यानी, array[4] को स्थानांतरित नहीं किया गया है array[3]। जो इसके विपरीत है Array.prototype.unshift, जो सरणी की शुरुआत में एक तत्व डालता है और सबकुछ ऊपर ले जाता है (array[0] हो जाता है array[1], आदि।)

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

बेशक, यह किया मुझे आश्चर्य। क्योंकि मैंने इसे "नल कचरा" के खिलाफ अपने क्रूसेड को औचित्य देने के लिए लिखा था:

खतरों और समस्याओं को अनदेखा करना null, और अंतरिक्ष बर्बाद हो गया है, अगर सरणी सटीक होना चाहिए तो यह समस्याग्रस्त हो सकता है।

जो छुटकारा पाने के लिए एक भयानक औचित्य है nulls--null अगर केवल अनुचित तरीके से उपयोग किया जाता है तो केवल खतरनाक होता है, और इसका "परिशुद्धता" से कोई लेना-देना नहीं है। असली कारण आपको नहीं करना चाहिए delete एक सरणी से है क्योंकि कचरे से भरे और गंदे डेटा संरचनाओं को छोड़कर मैला और बग-प्रोन है।

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

... यह बेवकूफ है, मुझे पता है।

प्रदूषित और लंबे हवादार पीडीपी -11 परिदृश्य

उदाहरण के लिए, मान लें कि आप एक वेबपैप बना रहे हैं जो एक स्ट्रिंग में 'टैब' के लिए उपयोग की जाने वाली सरणी को स्टोर करने के लिए JSON-serialization का उपयोग करता है (इस मामले में, localStorage)। आइए यह भी कहें कि कोड स्क्रीन पर ड्राइंग करते समय सरणी के सदस्यों के संख्यात्मक सूचकांक को "शीर्षक" में उपयोग करता है। "शीर्षक" को संग्रहीत करने के बजाय आप ऐसा क्यों कर रहे हैं? इसलिये... कारणों

ठीक है, आइए बस यह कहें कि आप इसके अनुरोध पर स्मृति को सहेजने की कोशिश कर रहे हैं एक उपयोगकर्ता जो 1 9 60 के चल रहे यूनिक्स से पीडीपी -11 मिनीकंप्यूटर चलाता है, और अपने स्वयं के एलीक्स-आधारित, जावास्क्रिप्ट-अनुरूप, लाइन-प्रिंटर-अनुकूल ब्राउज़र लिखा क्योंकि X11 है सवाल से बाहर

उपयोग करके, बढ़ते बेवकूफ किनारे-मामले परिदृश्य delete कहा सरणी पर परिणाम होगा null सरणी को प्रदूषित करना, और शायद बाद में ऐप में बग का कारण बनना। और यदि आप की जांच करें null, यह सीधे संख्याओं को छोड़ देगा जिसके परिणामस्वरूप टैब प्रस्तुत किए जा रहे हैं [1] [2] [4] [5] ...

if (array[index] == null)
    continue;
else
    title = (index + 1).toString();
/* 0 -> "1"
 * 1 -> "2"
 * 2 -> (nothing)
 * 3 -> "4"
 */

हाँ, यह निश्चित रूप से आप नहीं चाहते थे।

अब तुम सकता है जैसे दूसरा इटरेटर रखें j, जब सरणी से मान्य मान पढ़े जाते हैं तो केवल वृद्धि के लिए। लेकिन वह बिल्कुल हल नहीं करेगा null मुद्दा, और आपको अभी भी इसे खुश करना होगा ट्रोल पीडीपी -11 उपयोगकर्ता। हां, बस उसका कंप्यूटर नहीं है उस अंतिम पूर्णांक को पकड़ने के लिए पर्याप्त स्मृति है (पूछें कि वह एक चर-चौड़ाई सरणी को संभालने का प्रबंधन कैसे करता है ...)

तो, वह आपको क्रोध में एक ईमेल भेजता है:

Hey, your webapp broke my browser! I checked my localStorage database after your stupid code made my browser segfault, and this is what I found:

>"tabs:['Hello World', 'foo bar baz', null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, ... ]"

After clearing my precious data, it segfaulted again, and I did a backtrace, and what do I find? WHAT DO I FIND!? YOU USE TOO MANY VARIABLES!

>var i = index;
>var j = 1;

Grr, I am angry now.
-Troll Davidson

अभी के बारे में, आप अपने बुद्धि के अंत में हैं। यह लड़का आपके ऐप के बारे में नॉन-स्टॉप की शिकायत कर रहा है, और आप उसे चुप रहने और बेहतर कंप्यूटर पाने के लिए बताना चाहते हैं।

समाधान: Array.prototype.splice

सौभाग्य से, सरणी कर सूचकांक हटाने और स्मृति को पुन: आवंटित करने के लिए एक विशेष विधि है: Array.prototype.splice()। आप इस तरह कुछ लिख सकते हैं:

Array.prototype.remove = function(index){
  this.splice(index,1);
}
...
array = [1, 2, 3, 4];
array.remove(2);
// Result -> [1, 2, 4]

और इसी तरह, आपने श्री पीडीपी -11 को प्रसन्न किया है। हुर्रे! (मैं अभी भी उसे बता दूंगा, हालांकि ...)

Array.prototype.splice बनाम Array.prototype.slice

मुझे लगता है कि इन दो समान नामित कार्यों के बीच अंतर को इंगित करना महत्वपूर्ण है, क्योंकि वे दोनों बहुत उपयोगी हैं।

Array.prototype.splice (शुरू, एन)

.splice() सरणी को बदलता है, और हटाए गए सूचकांक देता है। सरणी सूचकांक से शुरू की जाती है, start, तथा n तत्वों को काटा जाता है। यदि n निर्दिष्ट नहीं है, तो पूरे सरणी के बाद start कटा हुआ है (n = array.length - start)।

let a = [5,4,3,2,1];
let chunk = a.splice(2,2);

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

chunk; // [3,2]
a;     // [5,4,1]

Array.prototype.slice (प्रारंभ, अंत)

.slice() गैर विनाशकारी है और संकेतित सूचकांक युक्त एक नया सरणी देता है start सेवा मेरे end। अगर end अनिर्दिष्ट छोड़ दिया गया है, व्यवहार वही है .splice() (end = array.length)। कुछ कारणों से व्यवहार थोड़ा मुश्किल है, end 0 के बजाय 1 से इंडेक्स। मुझे नहीं पता कि यह ऐसा क्यों करता है, लेकिन ऐसा ही है। इसके अलावा यदि end <= startपरिणाम एक खाली सरणी है।

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

// a             [5,4,3,2,1]
// start          0 1 2 - -
// end, for...    - - - - -
//   chunks[0]  0 - - - - -   
//   chunks[1]    1 2 - - -
//   chunks[2]    1 2 3 - -
//   chunks[3]    1 2 3 4 5

chunks; // [ [], [], [3], [3,2,1] ]
a;      // [5,4,3,2,1]

वास्तव में यह नहीं हो रहा है कि क्या हो रहा है, लेकिन इस तरह से सोचना आसान है। एमडीएन के मुताबिक, वास्तव में क्या हो रहा है:

// a             [5,4,3,2,1]
// start          0 1 2 - - -
// end, for...    - - - - - -
//   chunks[0]    0 - - - - -
//   chunks[1]    0 1 2 - - -
//   chunks[2]    0 1(2)3 - -
//   chunks[3]    0 1(2 3 4)5

द्वारा निर्दिष्ट सूचकांक end टुकड़ा से बाहर रखा गया है। संश्लेषित सूचकांक इंगित करता है कि कटा हुआ क्या होता है। किसी भी तरह से, व्यवहार अंतर्ज्ञानी नहीं है और यह एक-एक-एक त्रुटियों के निष्पक्ष हिस्से को उत्पन्न करने के लिए बाध्य है, इसलिए आपको एक रैपर फ़ंक्शन को अधिक बारीकी से व्यवहार के अनुकरण के लिए उपयोगी लग सकता है .splice():

function ez_slice(array, start = 0, n = null){
    if(!Array.isArray(array) || !is_number(start))
        return null;

    if(is_number(n))
        return array.slice(start, start + n);

    if(n === null)
        return array.slice(start);

    return null;
}

ez_slice([5,4,3,2,1], 2, 1) // [3]
ez_slice([5,4,3,2,1], 2)    // [3,2,1]

/* Fun fact: isNaN is unreliable.
 * [NaN, [], {}, 0, 1, Infinity, undefined, null, "Hi"].filter(isNaN)
 * [NaN, {}, undefined, "Hi"]
 *
 * What we want is...
 *
 * [NaN, [], {}, 0, 1, Infinity, undefined, null, "Hi"].filter(is_nan)
 * [NaN]
 */
function is_nan(num){
    return typeof num === "number"
        && num !== num;
}

function is_number(num){
    return !is_nan(num)
        && typeof num === "number"
        && isFinite(num);
}

ध्यान दें कि रैपर फ़ंक्शन को प्रकारों के बारे में बहुत सख्त होने के लिए डिज़ाइन किया गया है, और वापस आ जाएगा null अगर कुछ बंद है। इसमें एक स्ट्रिंग जैसे डालने शामिल हैं "3"। यह प्रोग्रामर को अपने प्रकार के बारे में मेहनती होने के लिए छोड़ दिया जाता है। यह अच्छा प्रोग्रामिंग अभ्यास को प्रोत्साहित करना है।

के बारे में अद्यतन करें is_array()

यह इस (अब हटाए गए) स्निपेट के संबंध में है:

function is_array(array){
    return array !== null
        && typeof array === "object"
        && typeof array.length !== "undefined"
        && array.__proto__ === Array.prototype;
}

इसलिए जब यह निकलता है, वास्तव में यह बताने के लिए एक अंतर्निहित तरीका है कि कोई सरणी वास्तव में एक सरणी है, और वह है Array.isArray(), ईसीएमएस्क्रिप्ट 5 (दिसंबर 200 9) में पेश किया गया। मुझे यह देखने के दौरान यह पता चला कि ऑब्जेक्ट्स से सरणी कहने के बारे में कोई सवाल पूछ रहा है या नहीं, यह देखने के लिए कि मेरे से बेहतर समाधान था या नहीं, अगर कोई नहीं था तो मेरा जोड़ना। इसलिए, यदि आप ईसीएमए 5 की तुलना में जावास्क्रिप्ट का एक संस्करण उपयोग कर रहे हैं, तो आपका पॉलीफिल है। हालांकि, मैं दृढ़ता से मेरा उपयोग करने की सलाह देते हैं is_array() फ़ंक्शन, जावास्क्रिप्ट के पुराने संस्करणों का समर्थन करने के लिए जारी रखने का मतलब है कि उन्हें लागू करने वाले पुराने ब्राउज़र का समर्थन करना जारी रखना, जिसका अर्थ है असुरक्षित सॉफ़्टवेयर के उपयोग को प्रोत्साहित करना और उपयोगकर्ताओं को मैलवेयर के लिए जोखिम में डाल देना। तो कृपया, उपयोग करें Array.isArray()। उपयोग let तथा const। भाषा में जोड़े गए नए फीचर्स का प्रयोग करें। नहीं विक्रेता उपसर्ग का उपयोग करें। हटाना आपकी वेबसाइट से आईई पॉलीफिल बकवास। उस एक्सएचटीएमएल को हटाएं <!CDATA[[... बकवास भी - हम 2014 में एचटीएमएल 5 में वापस चले गए। जितनी जल्दी सभी पुराने / गूढ़ ब्राउज़र के लिए समर्थन वापस लेते हैं, जितनी जल्दी ब्राउज़र विक्रेता वास्तव में वेब मानक का पालन करेंगे और नई तकनीक को गले लगाएंगे, और जितनी जल्दी हम आगे बढ़ सकते हैं एक और अधिक सुरक्षित वेब।


134
2017-09-18 00:56



इस delete कीवर्ड, हालांकि, अधिक सुविधाजनक है, लॉल - Braden Best
यह दृष्टिकोण मूल ऑब्जेक्ट को संशोधित नहीं करता है जिसे अभी भी कहीं और संदर्भित किया जा सकता है। यह कैसे उपयोग किया जा सकता है इसके आधार पर यह समस्या हो सकती है या नहीं हो सकती है लेकिन यह ध्यान में रखना कुछ है। - Tamas Czinege
@ बी 1 के म्यूजिक यहां एक ऐरे से तत्व को हटाने का तरीका है: ब्याह - wulftone
@ वाल्फ्टोन नोप, जो सरणी को विभाजित करता है और मूल्य को हटाने के लिए कुछ भी नहीं करता है। मैं वास्तव में एक सरणी से हटाने का सबसे अच्छा तरीका सोचता हूं जहां हटाए जाने के लिए विशिष्ट मानों की आवश्यकता होती है delete और इसे साफ़ करने के लिए एक कचरा संग्रह समारोह बनाते हैं। - Braden Best
मैं नहीं देखता splice आपके संपादन में, लेकिन remove होना चाहिए Array.prototype.remove = function(index) { this.splice(index, 1); }; - Ry-♦


पुराना सवाल, आधुनिक जवाब। ऑब्जेक्ट विनाशकारी का उपयोग करना, ए ECMAScript 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);

92
2017-11-08 18:02



हो सकता है क्योंकि लक्ष्य किसी ऑब्जेक्ट से किसी संपत्ति को निकालना है, संपत्ति के बिना नया नहीं बनाना ... हालांकि, आपका समाधान मेरा पसंदीदा है, क्योंकि मैं अपरिवर्तनीय तरीका पसंद करता हूं। - Vingt_centimes
सवाल "के साथ समाप्त करने के लिए कहा नया myObject "। - Koen.
इसके अनुसार kangax.github.io/compat-table/esnext, ऑब्जेक्ट बाकी गुणों को ES6 के लिए अंतिम रूप दिया नहीं गया है, शून्य ब्राउज़र कार्यान्वयन हैं, और केवल बेबेल समर्थन प्रदान करता है। - Justin C
यह वास्तव में अवांछित प्रोप के बिना नए ऑब्जेक्ट असाइनमेंट के लिए एक मीठा एक-लाइनर है, और पहले से ही Node.js 8। * / 9. * के साथ समर्थित है --harmony: node.green/... - Damaged Organic
2018 में यह स्वीकार्य उत्तर होना चाहिए :) - Yulian


एक और विकल्प का उपयोग करना है Underscore.js पुस्तकालय।

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

संदर्भ: संपर्क  _.pick (वस्तु, * कुंजी)

ऑब्जेक्ट की प्रतिलिपि लौटाएं, केवल फ़िल्टर के लिए फ़िल्टर करें श्वेतसूची कुंजी (या मान्य कुंजी की सरणी)।

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() इसी तरह इस्तेमाल किया जा सकता है।


67
2018-05-24 18:53



ध्यान रखें कि यदि आपकी ऑब्जेक्ट की चाबियाँ संख्याएं हैं, तो आपको इसकी आवश्यकता हो सकती है _.omit(collection, key.toString()) - Jordan Arseno
आपने विकिपीडिया से क्यों लिंक किया, न कि underscorejs.org? - E730
@ ई ​​730 अच्छा सवाल। मुझे नहीं पता कि संपादकों में से एक ने इसे विकिपीडिया.org/wiki/Underscore.js पर इंगित करने के लिए क्यों बदल दिया। मैंने इसे वापस underscorejs.org में बदल दिया। - Thaddeus Albers
हम्मम्म .... अंडरस्कोर ~ 100x धीमा है delete obj[prop] जो ~ 100x धीमी है obj[prop] = undefined। - Jack Giffin


शब्द जिसे आपने अपने प्रश्न शीर्षक में उपयोग किया है 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 ()


34
2018-02-12 06:29



आप गलत हैं - केवल वस्तुएं जावास्क्रिप्ट में संदर्भ द्वारा पारित की जाती हैं, इसलिए यदि myJSONObject.regexमान एक स्ट्रिंग है और आप इसे किसी अन्य ऑब्जेक्ट को असाइन करते हैं, अन्य ऑब्जेक्ट में इस मान की एक प्रति है। - Michał Perłakowski
आप सही हैं और यह एक उद्धरण है: "एक ही वस्तु के अपने अन्य संदर्भों के बारे में सावधान रहना।" - Mehran Hatami


मान लें कि आपके पास ऐसा ऑब्जेक्ट है जो इस तरह दिखता है:

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 आपके अनुक्रमण को भी गड़बड़ कर देगा।

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

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


30
2018-02-21 18:09



मुझे लगता है कि आपको हमेशा उपयोग करना चाहिए splice इसके बजाय एक सरणी पर delete। - Joel Trauger
@ जोएल ट्राउगर: यही वह है जो मैं कह रहा हूं ;-) - John Slegers
हाँ। मेरी टिप्पणी यह ​​है कि delete एक चीज़ भी नहीं होनी चाहिए। आईटी इस splice ओपी क्या देख रहा था। - Joel Trauger
@ जोएल ट्राउगर: जैसा कि मैंने व्याख्या करने की कोशिश की, delete वस्तु गुणों के लिए इस्तेमाल किया जाना चाहिए और splice सरणी तत्वों के लिए। - John Slegers
Splice वास्तव में धीमी है। इसके बजाए इसका इस्तेमाल किया जाना चाहिए delete सरणी पर, यह चारों ओर केंद्रित केंद्र बनाने के लिए सबसे बुद्धिमान होगा। - Jack Giffin


ईसीएमएस्क्रिप्ट 2015 (या ईएस 6) अंतर्निर्मित के साथ आया था प्रतिबिंबित वस्तु। कॉल करके ऑब्जेक्ट प्रॉपर्टी को हटाना संभव है 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

Object.freeze () वस्तु के सभी गुण कॉन्फ़िगर करने योग्य नहीं हैं (अन्य चीजों के अलावा)। 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

29
2018-01-10 16:36



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


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

दिखाने के लिए एक लाइव उदाहरण:

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

22
2018-04-28 05:14



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


मैं व्यक्तिगत रूप से उपयोग करता हूं Underscore.js ऑब्जेक्ट और सरणी हेरफेर के लिए:

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

20
2018-01-22 02:29