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




javascript-objects object-properties (25)

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

delete myObject['key'];

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

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

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

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

ईसीएमएस्क्रिप्ट 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);


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

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

बहुत आसान:

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

delete myObject.regex;

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


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

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

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

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


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

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

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

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


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.

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

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


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

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

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

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

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


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


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

var obj = [];

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

delete(obj.key1);

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

लघु संस्करण

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

जैसा कि अन्य ने कहा है, आप delete सकते हैं।

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

ऐरे समकक्ष

एक सरणी से मत हटाओ। इसके बजाय Array.prototype.splice प्रयोग करें।

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

लंबा संस्करण

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

सरणी में, सादे पुरानी वस्तुओं के विपरीत, कचरे के पीछे कचरे के पीछे पत्तियों को 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] बन जाती है array[1] , आदि)

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

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

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

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

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

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

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

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

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

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

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

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

अब, आप जेई की तरह दूसरा इटरेटर रख सकते हैं, जब सरणी से मान्य मान पढ़े जाते हैं तो केवल वृद्धि होगी। लेकिन यह वास्तव में 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() सरणी को mutates, और हटाए गए सूचकांक देता है। सरणी इंडेक्स से शुरू हो जाती है, start , और n तत्वों को काटा जाता है। यदि n निर्दिष्ट नहीं है, तो start बाद पूरी सरणी n = array.length - 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 होने वाली एक नई सरणी देता है जो start से end । यदि end निर्दिष्ट नहीं छोड़ा गया है, तो व्यवहार .splice() ( end = array.length ) जैसा ही है। व्यवहार कुछ मुश्किल है, क्योंकि किसी कारण से, 0 के बजाय 1 से इंडेक्स end होता है। मुझे नहीं पता कि यह ऐसा क्यों करता है, लेकिन ऐसा ही है। इसके अलावा, यदि 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) में पेश की गई Array.isArray() ) है। मुझे यह देखने के दौरान यह पता चला कि ऑब्जेक्ट्स से सरणी कहने के बारे में कोई सवाल पूछ रहा है या नहीं, यह देखने के लिए कि मेरे से बेहतर समाधान था या नहीं, अगर कोई नहीं था तो मेरा जोड़ना। इसलिए, यदि आप ईसीएमए 5 की तुलना में जावास्क्रिप्ट का एक संस्करण उपयोग कर रहे हैं, तो आपका पॉलीफिल है। हालांकि, मैं अपने is_array() फ़ंक्शन का उपयोग करने के खिलाफ दृढ़ता से अनुशंसा करता हूं, क्योंकि जावास्क्रिप्ट के पुराने संस्करणों का समर्थन करने के लिए जारी रखने के लिए उन पुराने ब्राउज़र का समर्थन करना जारी है, जो असुरक्षित सॉफ़्टवेयर के उपयोग को प्रोत्साहित करते हैं और उपयोगकर्ताओं को मैलवेयर के लिए जोखिम में डालते हैं। तो कृपया, Array.isArray() उपयोग करें। let और const प्रयोग करें। भाषा में जोड़े गए नए फीचर्स का प्रयोग करें। विक्रेता उपसर्ग का उपयोग करें। अपनी वेबसाइट से आईई पॉलीफिल बकवास हटाएं । उस एक्सएचटीएमएल को हटाएं <!CDATA[[... बकवास भी - हम 2014 में एचटीएमएल 5 पर वापस चले गए। जितनी जल्दी सभी पुराने / गूढ़ ब्राउज़र के लिए समर्थन वापस लेते हैं, उतनी ही जल्द ही ब्राउज़र विक्रेता वेब मानक का पालन करेंगे और गले लगाएंगे नई तकनीक, और जितनी जल्दी हम एक और अधिक सुरक्षित वेब पर जा सकते हैं।


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}

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

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

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


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

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

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

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

delete obj.key1

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

delete obj[key1]

रेफरी: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…


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

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

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

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

निम्न विधि आज़माएं। 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);


मुझे ऐसा करने के किसी भी तरीके से अवगत नहीं है, हालांकि पुनरावृत्तियों को न्यूनतम रखने के लिए, आप __count__ के अस्तित्व की जांच करने का प्रयास कर सकते हैं और यदि यह अस्तित्व में नहीं है (यानी फ़ायरफ़ॉक्स नहीं) तो आप ऑब्जेक्ट पर फिर से सक्रिय हो सकते हैं और बाद में उपयोग के लिए इसे परिभाषित करें उदाहरण:

if (myobj.__count__ === undefined) {
  myobj.__count__ = ...
}

इस प्रकार __count__ समर्थन करने वाला कोई भी ब्राउज़र इसका उपयोग करेगा, और पुनरावृत्तियों को केवल उन लोगों के लिए किया जाएगा जो नहीं करते हैं। यदि गिनती बदलती है और आप ऐसा नहीं कर सकते हैं, तो आप इसे हमेशा एक फ़ंक्शन बना सकते हैं:

if (myobj.__count__ === undefined) {
  myobj.__count__ = function() { return ... }
  myobj.__count__.toString = function() { return this(); }
}

इस तरह जब भी आप myobj संदर्भित करते हैं। __count__ फ़ंक्शन आग और पुन: गणना करेगा।





javascript javascript-objects object-properties