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] में स्थानांतरित नहीं करता है।

JavaScript में अलग-अलग बिल्ट-इन फ़ंक्शंस विरल सरणियों को अलग-अलग तरीके से हैंडल करते हैं।

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

• एक पारंपरिक for लूप इंडेक्स पर मान के लिए undefined लौटाएगा।

• Symbol.iterator का उपयोग करने वाला कोई भी तरीका इंडेक्स पर मान के लिए undefined लौटाएगा।

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

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

ऐरे # ब्याह (शुरू करें [, डिलीटकाउंट [, आइटम 1 [, आइटम 2 [, ...]]]])

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

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

आप इसे Babel try-out संपादक में कार्य करते हुए देख सकते हैं।

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

एक ही वेरिएबल को पुन: असाइन करने के लिए, एक let का उपयोग करें:

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

स्प्रेड सिंटैक्स (ES6)

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

const key = 'a';

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

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

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

विस्तारित उत्तर

किसी वस्तु से किसी गुण को निकालने के कुछ सामान्य तरीके हैं।
प्रत्येक के अपने फायदे और नुकसान हैं (इस प्रदर्शन तुलना की जांच करें ए>):

ऑपरेटर हटाएं

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

delete obj[key];

पुन: असाइनमेंट

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

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

स्प्रेड ऑपरेटर

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

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

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

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

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

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

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

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

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

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

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

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

console.log(newMyObject);

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

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

1. ईसीएमएस्क्रिप्ट का वह संस्करण जिसे आप लक्षित कर रहे हैं
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 और सरणी अनुक्रमणिका का समर्थन करता है और पहली रिलीज़ को छोड़कर जावास्क्रिप्ट के हर संस्करण में काम करता है। हालांकि, यह परिवर्तनशील है जो कुछ प्रोग्रामिंग सिद्धांतों का उल्लंघन करता है और प्रदर्शन प्रभाव पड़ता है। नॉन-कॉन्फ़िगर करने योग्य सख्त मोड में गुण ।

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

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

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 स्टेटमेंट के साथ संभव नहीं हैं।

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

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

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"

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

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

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

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

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

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

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

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

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

आप समान प्रभाव प्राप्त करने के लिए अन्य कार्यों का भी उपयोग कर सकते हैं - छोड़ें, चुनें, ...

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

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

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

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

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

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

delete obj.key1

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

delete obj[key1]

संदर्भ: MDN।

ऑब्जेक्ट.असाइन () और ऑब्जेक्ट.की () और ऐरे.मैप ()

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

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

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

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

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

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

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

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

ये कोशिश करें

delete myObject['key'];

हैलो आप इसे एक तरह से सरल कोशिश कर सकते हैं

var obj = [];

obj.key1 = {name: "John", room: 1234};
obj.key2 = {name: "Jim", room: 1234};

delete(obj.key1);

@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 }

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

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)

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}

मैंने Lodash "unset" का इस्तेमाल किसी नेस्टेड ऑब्जेक्ट के लिए भी किया है। . केवल इसे संपत्ति कुंजी का पथ प्राप्त करने के लिए छोटे तर्क लिखने की आवश्यकता है जो छोड़ें विधि द्वारा अपेक्षित है।

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. फिर बस Lodash unset विधि का उपयोग करके वस्तु से संपत्ति को हटा दें।

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

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

ऑब्जेक्ट को बदले बिना कोई प्रॉपर्टी निकालें

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

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

यहां प्रविष्टि को आसानी से निकालने का ES6 तरीका है:

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

const removeItem = 'regex';

const { [removeItem]: remove, ...rest } = myObject;

console.log(remove); // "^http://.*"
console.log(rest); // Object { ircEvent: "PRIVMSG", method: "newURI" }

आइए इसे सरल रखें, बिंदु तक:

बस उस विशिष्ट गुण/फ़ील्ड को = अपरिभाषित . के बराबर सेट करें

var myObject = {
    'i': "How are you?",
    'am': "Dear",
    'fine': "Hello"
};

myObject.am = undefined;

console.log(myObject);

किसी वस्तु को हटाने के दो तरीके

1. के लिए ... में . का उपयोग कर रहे हैं

    function deleteUser(key) {
   
        const newUsers = {};
        for (const uid in users) {
            if (uid !== key) {
                newUsers[uid] = users[uid];
            }
   
        return newUsers
    }
   

या

delete users[key]

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

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

संदर्भ: लिंक _.pick(object, *keys)

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

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

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

संदर्भ: लिंक _.omit(object, *keys)

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

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

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

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

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

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

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

और हमें a को हटाना होगा।

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

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

2. एक चर प्रोप कुंजी के साथ:

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

3. एक बढ़िया तीर फ़ंक्शन 😎:

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

4. एकाधिक संपत्तियों . के लिए

   const removeProperties = (object, ...keys) => (keys.length ? removeProperties(removeProperty(keys.pop(), object), ...keys) : object);
   

उपयोग

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

या

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

आपने अपने प्रश्न शीर्षक में जिस शब्द का प्रयोग किया है, एक जावास्क्रिप्ट ऑब्जेक्ट से एक संपत्ति निकालें, कुछ अलग तरीकों से व्याख्या की जा सकती है। एक यह है कि इसे पूरी मेमोरी के लिए हटा दिया जाए और ऑब्जेक्ट कीज़ की सूची या दूसरा इसे केवल अपने ऑब्जेक्ट से हटा दिया जाए। जैसा कि कुछ अन्य उत्तरों में उल्लेख किया गया है, 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 कथनों का उपयोग करने से बनाई गई वस्तु को हटाने से रोका जा सकेगा।

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

delete regex; //False

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

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

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

अपडेट करें:

@AgentME को धन्यवाद:

किसी संपत्ति को हटाने से पहले उसे शून्य पर सेट करना कुछ भी पूरा नहीं करता है (जब तक कि ऑब्जेक्ट को ऑब्जेक्ट द्वारा सील नहीं किया गया हो।

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

ECMAScript 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 फ़ंक्शन (साथ ही डिलीट ऑपरेटर) रिटर्न 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

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

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

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

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

मैं व्यक्तिगत रूप से Underscore.js या Lodash:

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

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

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

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

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

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

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

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

• कार्य जो किसी वस्तु का हिस्सा हैं (इसके अलावा
  ग्लोबल स्कोप) को डिलीट करके डिलीट किया जा सकता है।

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

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

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

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

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

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

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

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

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

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

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)

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