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




javascript-objects object-properties (20)

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

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

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

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

2 (ES6)

जो भी इसे चाहिए ...

इस थ्रेड में @Koen उत्तर को पूरा करने के लिए, यदि आप स्प्रेड सिंटैक्स का उपयोग करके गतिशील चर को हटाना चाहते हैं, तो आप इसे ऐसा कर सकते हैं: 

const key = 'a';

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

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

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


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

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
पढ़ने योग्य और छोटाdeveloper.mozilla.org/en-US/docs/Web/JavaScript/Reference/… , हालांकि यदि आप बड़ी संख्या में ऑब्जेक्ट्स पर काम कर रहे हैं तो यह सबसे अच्छा विकल्प नहीं हो सकता है क्योंकि इसका प्रदर्शन अनुकूलित नहीं है।

delete obj[key];


Reassignment
2X से अधिक तेज हैdelete, हालांकि संपत्ति कोहटायानहींगया है और इसे पुनरावृत्त किया जा सकता है।

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


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

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

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"];
        }
    }
);

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

benchmark ।

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

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

किसी को कब delete जाना चाहिए और जब मान को undefined ?

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

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

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

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

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

हैशपैप में इसकी जगह पर कुंजी बनी हुई है , केवल मूल्य को undefined साथ बदल दिया गया है। समझें, कि for..in लूप अभी भी उस कुंजी पर फिर से 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 का उपयोग करते समय obj[prop] = undefined delete obj[prop] से तेज़ है, एक और महत्वपूर्ण विचार यह है कि obj[prop] = undefined हमेशा उपयुक्त नहीं हो सकता है। delete obj[prop] prop से prop को हटा देता है और इसे स्मृति से मिटा देता है जबकि 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] = "" पॉलिमॉर्फिज्म को मजबूर नहीं करता है जबकि bar[1] = undefined करता है। इसलिए, किसी को हमेशा, जब भी संभव हो, उनके ऑब्जेक्ट्स के लिए संबंधित प्रकार का उपयोग करना चाहिए ताकि गलती से पॉलिमॉर्फिज्म का कारण न हो। ऐसा एक व्यक्ति निम्नलिखित सूची का उपयोग उन्हें सामान्य संदर्भ के रूप में उपयोग करने के लिए कर सकता है। हालांकि, कृपया नीचे दिए गए विचारों का स्पष्ट रूप से उपयोग न करें। इसके बजाय, अपने कोड के लिए जो कुछ भी अच्छा काम करता है उसका उपयोग करें।

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

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

आपके प्रश्न शीर्षक में आपके द्वारा उपयोग की जाने वाली अवधि 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 से हटा myJSONObject , तो उस विशिष्ट ऑब्जेक्ट को स्मृति से हटाया नहीं जाएगा, क्योंकि regex चर और myOtherObject["regex"] पास अभी भी उनके मान हैं। तो हम वस्तु को स्मृति से निश्चित रूप से कैसे हटा सकते हैं?

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

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

delete regex; //False

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

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

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

अद्यतन: @AgentME के ​​लिए धन्यवाद:

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

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

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

Underscore.js लाइब्रेरी का उपयोग करने का एक और विकल्प है।

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

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

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

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

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

संदर्भ: link _.omit (ऑब्जेक्ट, * कुंजी)

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

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

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

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

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

(विनाश + फैलाने वाला ऑपरेटर) 

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

Lodash का उपयोग करना 

import omit from 'lodash/omit';

const prevObject = {test: false, test2: true};
// Removes test2 key from previous object
const nextObject = omit(prevObject, 'test2');

रामदा का प्रयोग करना 

R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}

बहुत आसान: 

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

delete myObject.regex;

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

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

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

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

यह पोस्ट बहुत पुरानी है और मुझे यह बहुत उपयोगी लगता है इसलिए मैंने किसी और को इस पोस्ट को देखने के मामले में लिखा हुआ अनसेट फ़ंक्शन साझा करने का निर्णय लिया और सोचा कि यह 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"}

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

उदाहरण के लिए 

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

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

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

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

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

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

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

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

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

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

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… ऐसा करने के लिए सबसे अच्छा तरीका है।

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

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

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

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

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

console.log(newMyObject);

ईसीएमएस्क्रिप्ट 2015 (या ES6) अंतर्निहित Reflect वस्तु के साथ आया था । पैरामीटर के रूप में लक्ष्य ऑब्जेक्ट और प्रॉपर्टी कुंजी के साथ 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फ़ंक्शन (साथ ही developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… ) लौटाता है 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

एक और समाधान, का उपयोग कर 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);

दान का दावा है कि 'हटाएं' बहुत धीमा है और उसके द्वारा पोस्ट किए गए बेंचमार्क पर संदेह था। इसलिए मैंने स्वयं को क्रोम 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

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

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

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

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

console.log(myObject);




javascript   javascript-objects   object-properties  


object-properties