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

Question

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

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

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

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

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अपने ब्लॉग पर दिए गए बयान के बारे में एक अविश्वसनीय रूप से गहन ब्लॉग पोस्ट लिखा है, अंडरस्टैंड डिलीट । यह अत्यधिक अनुशंसित है।

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 केवल उन गुणों पर काम करेंगे जिनके विवरणकर्ता उन्हें विन्यास के रूप में चिह्नित करते हैं।

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ऑपरेटर को किसी सरणी से तत्वों को हटाने के सामान्य उपयोग-मामले के लिए उपयोग नहीं किया जाना चाहिए। तत्वों को हटाने और स्मृति को पुनः प्राप्त करने के लिए एरे के पास एक समर्पित तरीका है: 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किसी सरणी से अंतिम तत्व निकालता है, और उस तत्व को वापस करता है। यह ऑपरेशन सरणी की लंबाई को बदलता है।

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

Answer 6

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

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

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

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;

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()एक समान तरीके से उपयोग किया जा सकता है।

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

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

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

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

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

Answer 11

संपत्ति के बिना वस्तु क्लोन करने के लिए:

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

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

और हमें हटाने की जरूरत है a।

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

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

1. साथ चर प्रोप कुंजी :

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

1. कूल एरो फंक्शन 😎:

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

    object = removePropery('a', object);

1. के लिए कई संपत्तियां

    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 }

Answer 12

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

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

Answer 13

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

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

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

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

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

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

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

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

• लेट या कास्ट के साथ घोषित किसी भी संपत्ति को उस दायरे से नहीं हटाया जा सकता है जिसके भीतर उन्हें परिभाषित किया गया था। गैर-विन्यास योग्य गुण नहीं निकाले जा सकते। इसमें अंतर्निहित ऑब्जेक्ट जैसे Math, Array, Object और ऐसे गुण शामिल हैं जो 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 14

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

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

(ईएस 6)

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 15

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

उदाहरण के लिए

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

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

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

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

Answer 16

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

रम्दा # डिस्को का उपयोग करने पर आपको बिना किसी नई वस्तु के मिल जाएगी regex:

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

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

Answer 18

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

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

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

console.log(myObject);

Answer 19

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

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: {}}}

Answer 20

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

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

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

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"

Answer 22

लॉश का उपयोग करना

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}

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

@johnstock , हम कॉलिंग ऑब्जेक्ट में उपलब्ध किसी भी पारित कुंजी को हटाने के लिए ऑब्जेक्ट में विधि जोड़ने के लिए जावास्क्रिप्ट की प्रोटोटाइप अवधारणा का उपयोग कर सकते हैं।

उपरोक्त उत्तर सराहे जाते हैं।

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

// 1st and direct way 
delete myObject.regex;  // delete myObject["regex"]
console.log(myObject); // { ircEvent: 'PRIVMSG', method: 'newURI' }

 // 2 way -  by using the concept of JavaScript's prototyping concept
Object.prototype.removeFromObjectByKey = function(key) {
     // If key exists, remove it and return true
     if(this[key] !== undefined) {
           delete this[key]
           return true;
     }
     // Else return false
     return false;
}

var isRemoved = myObject.removeFromObjectByKey('method')
console.log(myObject)  // { ircEvent: 'PRIVMSG' }

// More examples
var obj = { a: 45, b: 56, c: 67}
console.log(obj) // { a: 45, b: 56, c: 67 }

// Remove key 'a' from obj
isRemoved = obj.removeFromObjectByKey('a')
console.log(isRemoved); //true
console.log(obj); // { b: 56, c: 67 }

// Remove key 'd' from obj which doesn't exist
var isRemoved = obj.removeFromObjectByKey('d')
console.log(isRemoved); // false
console.log(obj); // { b: 56, c: 67 }

Answer 25

आप नीचे दिए गए तरह फिल्टर का उपयोग कर सकते हैं

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

// way 1

let filter1 = {}
  Object.keys({...myObject}).filter(d => {
  if(d !== 'regex'){
    filter1[d] = myObject[d];
  }
})

console.log(filter1)

// way 2

let filter2 = Object.fromEntries(Object.entries({...myObject}).filter(d => 
d[0] !== 'regex'
))

console.log(filter2)

Answer 26

मैंने नेस्टेड ऑब्जेक्ट के लिए भी ऐसा करने के लिए "अनसेट" का उपयोग किया है .. केवल संपत्ति तर्क की राह पाने के लिए छोटे तर्क लिखने की आवश्यकता है जो कि ओटिट विधि द्वारा अपेक्षित है।

1. विधि जो संपत्ति पथ को सरणी के रूप में लौटाती है

var a = {"bool":{"must":[{"range":{"price_index.final_price":{"gt":"450","lt":"500"}}},{"bool":{"should":[{"term":{"color_value.keyword":"Black"}}]}}]}};

function getPathOfKey(object,key,currentPath, t){
     var currentPath = currentPath || [];

    for(var i in object){
		if(i == key){
        t = currentPath;
      }
      else if(typeof object[i] == "object"){
        currentPath.push(i)
       return getPathOfKey(object[i], key,currentPath)
      }
    }
	t.push(key);
    return t;
}
document.getElementById("output").innerHTML =JSON.stringify(getPathOfKey(a,"price_index.final_price"))

<div id="output"> 

</div>

1. फिर सिर्फ लॉश अनसेट विधि का उपयोग करके संपत्ति को ऑब्जेक्ट से हटा दें।

var unset = require('lodash.unset');
unset(a,getPathOfKey(a,"price_index.final_price"));

Answer 27

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


obj = Object.fromEntries(
    Object.entries(myObject).filter(function (m){
        return m[0] != "regex"/*or whatever key to delete*/
    }
))

console.log(obj)

आप केवल a2dसरणी का उपयोग करके ऑब्जेक्ट की तरह व्यवहार कर सकते हैं Object.entries, और किसी तत्व को निकालने के लिए ब्याह का उपयोग कर सकते हैं जैसा कि आप सामान्य सरणी में करेंगे, या बस ऑब्जेक्ट के माध्यम से फ़िल्टर करेंगे, जैसा कि एक सरणी होगा, और पुनर्निर्मित ऑब्जेक्ट को मूल चर पर वापस असाइन करें

Answer 28

यदि आप मूल वस्तु को संशोधित नहीं करना चाहते हैं।

ऑब्जेक्ट को म्यूट किए बिना कोई गुण निकालें

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

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

let prop = 'regex';
const updatedObject = Object.keys(myObject).reduce((object, key) => {
  if (key !== prop) {
    object[key] = myObject[key]
  }
  return object
}, {})

console.log(updatedObject);