මම පහත පරිදි වස්තුවක් නිර්මාණය කළ බව පවසන්න:

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

පහත සඳහන් පරිදි regexනව දේ සමඟ අවසන් කිරීම සඳහා දේපල ඉවත් කිරීමට හොඳම ක්‍රමය myObjectකුමක්ද?

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

මෙවැනි:

delete myObject.regex;
// or,
delete myObject['regex'];
// or,
var prop = "regex";
delete myObject[prop];

නිරූපණය

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

console.log(myObject);

ඒ ගැන වැඩි කියවීම උනන්දු කිසිවෙකු සඳහා, අටළු පමාණය පරිශීලක kangax ගැන ඇදහිය නොහැකි තරම් ගැඹුරු බ්ලොග් ලියා ඇත delete, ඔවුන්ගේ බ්ලොග් ප්රකාශයක් delete අවබෝධ . එය බෙහෙවින් නිර්දේශ කෙරේ.

ජාවාස්ක්‍රිප්ට් හි ඇති වස්තු යතුරු සහ අගයන් අතර සිතියම් ලෙස සිතිය හැකිය. 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

මෙය ෆයර්ෆොක්ස් සහ ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් වල ක්‍රියාත්මක වන අතර එය අනෙක් සියල්ලටම ක්‍රියාත්මක වේ.

මෙම 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ජාවාස්ක්‍රිප්ට් හි සී සහ සී ++ හි මූල පදයට වඩා වෙනස් ශ්‍රිතයක් ඇත: එය මතකය කෙලින්ම නිදහස් නොකරයි. ඒ වෙනුවට, එහි එකම අරමුණ වන්නේ වස්තූන්ගෙන් ගුණාංග ඉවත් කිරීමයි.

අරා සඳහා, දර්ශකයකට අනුරූප වන දේපලක් මකා දැමීම, විරල අරාවක් නිර්මාණය කරයි (එනම්, එහි “සිදුරක්” සහිත අරාවක්). බොහෝ බ්‍රව්සර් මෙම අස්ථානගත දර්ශක "හිස්" ලෙස නිරූපණය කරයි.

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.

අරාව # භේදය (ආරම්භ කරන්න [, මකන්න [, අයිතමය 1 [, අයිතමය 2 [, ...]]])

Array#spliceඅරාව විකෘති කර ඉවත් කරන ලද ඕනෑම දර්ශක නැවත ලබා දෙයි. deleteCountඅංග දර්ශකය ඉවත් කර start, සහ item1, item2... itemNදර්ශකය සිට අරාව ඇතුල් වේ start. deleteCountමඟ හැරී ඇත්නම්, ආරම්භක ඉන්ඩෙක්ස් හි මූලද්‍රව්‍ය අරාවේ අවසානය දක්වා ඉවත් කරනු ලැබේ.

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, ප්‍රති result ලය හිස් අරාවකි.

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අරාවකින් අවසාන මූලද්‍රව්‍යය ඉවත් කර එම මූලද්‍රව්‍යය නැවත ලබා දෙයි. මෙම මෙහෙයුම අරාවේ දිග වෙනස් කරයි.

පැරණි ප්‍රශ්නය, නවීන පිළිතුර. වස්තු විනාශ කිරීම භාවිතා කිරීම, aECMAScript 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)

එය අවශ්‍ය ඕනෑම කෙනෙකුට ...

මෙම ත්‍රෙඩ් එකේ o කෝන් පිළිතුර සම්පූර්ණ කිරීම සඳහා, ඔබට පැතිරෙන සින්ටැක්ස් භාවිතයෙන් ගතික විචල්‍යය ඉවත් කිරීමට අවශ්‍ය නම්, ඔබට එය එසේ කළ හැකිය:

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.

දීර් AN පිළිතුර - වස්තුවකින්
දේපලක් ඉවත් කිරීමට පොදු ක්‍රම කිහිපයක් තිබේ.
සෑම කෙනෙකුම තමන්ගේම වාසි සහ අවාසි ඇත ( මෙම කාර්ය සාධනය සංසන්දනය පරීක්ෂා කරන්න ):

ක්‍රියාකරු මකන්න
කියවිය හැකි හා කෙටි, කෙසේ වෙතත්, ඔබ එහි ක්‍රියාකාරිත්වය ප්‍රශස්ත කර නොමැති බැවින් ඔබ විශාල වස්තු සංඛ්‍යාවක් මත ක්‍රියා කරන්නේ නම් එය හොඳම තේරීම නොවනු ඇත.

delete obj[key];

Reassignment
2X වඩා වඩා වේගයෙන්deleteදේපල වේ කෙසේ වෙතත්,නොමකා දමන ලද හා ශාඛාවයි කළ හැක.

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

පැතිරීමේ ක්‍රියාකරු පවත්නා වස්තුව විකෘති නොකර ඕනෑම ගුණාංගයක් හැර අළුත් වස්තුවක් ආපසු ලබා දීමට
මෙමES6ක්‍රියාකරු අපට ඉඩ දෙයි. අවාසිය නම්, එය ඉහත සඳහන් කළ දේට වඩා නරක ක්‍රියාකාරිත්වයක් ඇති අතර වරකට බොහෝ දේපල ඉවත් කිරීමට අවශ්‍ය වූ විට එය භාවිතා කිරීමට යෝජනා නොකිරීමයි.

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

තවත් විකල්පයක් වන්නේ Underscore.js භාවිතා කිරීමයි පුස්තකාලය .

එය _.pick()සහ_.omit() වස්තුවේ පිටපතක් ආපසු යන දෙකම සහ මුල් වස්තුව සෘජුවම වෙනස් කරන්නේ නැහැ. ප්‍රති object ලය මුල් වස්තුවට පැවරීම කළ යුත්තේ උපක්‍රමයයි (පෙන්වා නැත).

යොමුව: සබැඳිය _.pick (වස්තුව, * යතුරු)

සුදු ලැයිස්තුගත කර ඇති යතුරු සඳහා (හෝ වලංගු යතුරු පෙළක්) පමණක් අගයන් ඇති ලෙස පෙරහන් කර ඇති වස්තුවක පිටපතක් ආපසු එවන්න.

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

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

යොමුව: සබැඳිය _.omit (වස්තුව, * යතුරු)

අසාදු ලේඛණ යතුරු (හෝ යතුරු පෙළ) මඟ හැරීම සඳහා පෙරහන් කළ වස්තුවක පිටපතක් ආපසු එවන්න.

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

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

අරා සඳහා, ඒ _.filter()හා _.reject()සමාන ආකාරයකින් භාවිතා කළ හැකිය.

ඔබේ ප්‍රශ්න මාතෘකාව තුළ ඔබ භාවිතා කර ඇති පදය Remove a property from a JavaScript objectවිවිධ ආකාරවලින් අර්ථ දැක්විය හැකිය. එකක් නම් එය සම්පූර්ණ මතකය සඳහා ඉවත් කිරීම සහ වස්තු යතුරු ලැයිස්තුව හෝ අනෙක එය ඔබේ වස්තුවෙන් ඉවත් කිරීමයි. එය වෙනත් පිළිතුරු වල සඳහන් කර ඇති පරිදි, deleteප්‍රධාන පදය ප්‍රධාන කොටසයි. ඔබේ වස්තුව මෙයට සමාන යැයි අපි කියමු:

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

ඔබ එසේ කරන්නේ නම්:

console.log(Object.keys(myJSONObject));

ප්‍රති result ලය වනුයේ:

["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

ප්‍රති result ලය වනුයේ false, එයින් අදහස් වන්නේ ඔබ මකාදැමීමේ ප්‍රකාශය ඔබ අපේක්ෂා කළ පරිදි ක්‍රියාත්මක කර නොමැති බවයි. නමුත් ඔබ මීට පෙර එම විචල්‍යය නිර්මාණය කර නොතිබුනේ නම් සහ ඔබ සතුව තිබුනේ myOtherObject["regex"]ඔබේ අවසන් වරට සඳහන් කර තිබුනේ නම් පමණි , ඔබට මෙය කළ හැක්කේ මෙය ඉවත් කිරීමෙන් පමණි:

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

වෙනත් වචන වලින් කිවහොත්, ඔබේ කේතයේ කිසිදු සඳහනක් නොමැති විට ජාවාස්ක්‍රිප්ට් වස්තුවක් එම වස්තුව වෙත යොමු වේ.

යාවත්කාලීන කිරීම: @AgentME ට ස්තූතියි:

දේපලක් මකා දැමීමට පෙර එය අහෝසි කිරීමෙන් කිසිවක් ඉටු නොවේ.

වැඩි විස්තර සඳහා Object.seal: Object.seal ()

සම්මතයන් 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

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පසුකාලීනව උදාහරණයක් ලෙස ඇමතීමේදී වැරදි ප්‍රති results ල ලැබෙනු ඇත. වෙනත් වචන වලින් කිවහොත්, deleteමූලද්‍රව්‍යය ඉවත් කරනු ඇත, නමුත් එය lengthදේපලවල වටිනාකම යාවත්කාලීන නොකරයි . භාවිතා deleteකිරීම ඔබේ සුචිගත කිරීම අවුල් කරයි.

එබැවින්, වස්තුවකින් අගයන් මකාදැමීමේදී, ඔබ මුලින්ම ගනුදෙනු කරන්නේ වස්තු ගුණාංග සමඟද නැතහොත් ඔබ අරාවෙහි අගයන් සමඟද යන්න සලකා බලන්න, ඒ මත පදනම්ව සුදුසු උපාය මාර්ග තෝරා ගන්න.

ඔබට මෙය අත්හදා බැලීමට අවශ්‍ය නම්, ඔබට මෙම ෆිදෙල් ආරම්භක ස්ථානයක් ලෙස භාවිතා කළ හැකිය .

ES6 භාවිතා කිරීම:

(විනාශ කිරීම + පැතිරීමේ ක්‍රියාකරු)

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

වස්තු සහ අරාව හැසිරවීම සඳහා මම පුද්ගලිකව Underscore.js හෝ Lodash භාවිතා කරමි :

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

මෙම delete ක්රියාකරු එසේ කිරීමට හොඳම ක්රමය වේ.

පෙන්වීමට සජීවී උදාහරණයක්:

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

දේපල නොමැතිව වස්තුව ක්ලෝන කිරීමට:

උදාහරණයක් වශයෙන්:

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.Cool ඊතල ශ්‍රිතය 😎:

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

object = removePropery('a', object);

4. බහු ගුණාංග සඳහා

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 }

භාවිතා delete ක්රමය MDN විස්තර අනුව එම delete ක්රියාකරු වස්තුවක් සිට දේපල ඉවත් ඒක කරන්න හොඳම ක්රමය වේ. එබැවින් ඔබට සරලව ලිවිය හැකිය:

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

මකාදැමීමේ ක්‍රියාකරු විසින් ලබා දී ඇති දේපලක් වස්තුවකින් ඉවත් කරයි. සාර්ථක මකාදැමීමකදී, එය සත්‍ය වනු ඇත, නැතිනම් අසත්‍යය නැවත ලැබෙනු ඇත. කෙසේ වෙතත්, පහත දැක්වෙන අවස්ථා සලකා බැලීම වැදගත් ය:

• ඔබ මකා දැමීමට උත්සාහ කරන දේපල නොපවතී නම්, මකාදැමීමෙන් කිසිදු බලපෑමක් සිදු නොවන අතර එය සත්‍ය වනු ඇත

• එකම නමක් ඇති දේපලක් වස්තුවේ මූලාකෘති දාමයේ තිබේ නම්, මකාදැමීමෙන් පසු, වස්තුව මූලාකෘති දාමයෙන් දේපල භාවිතා කරනු ඇත (වෙනත් වචන වලින් කිවහොත්, මකාදැමීම ස්වකීය ගුණාංග කෙරෙහි පමණක් බලපායි).

• Var සමඟ ප්‍රකාශිත ඕනෑම දේපලක් ගෝලීය විෂය පථයෙන් හෝ ශ්‍රිතයේ විෂය පථයෙන් මකා දැමිය නොහැක.

• එනිසා, මකාදැමීමට ගෝලීය විෂය පථයේ කිසිදු කාර්යයක් මකා දැමිය නොහැක (මෙය ශ්‍රිත අර්ථ දැක්වීමක කොටසක් හෝ ශ්‍රිතයක් (ප්‍රකාශනයක්) වේවා.

• වස්තුවක කොටසක් වන කාර්යයන් (
  ගෝලීය විෂය පථයට අමතරව) මකාදැමීමෙන් මකා දැමිය හැකිය.

• ඉඩ හෝ නියමය සමඟ ප්‍රකාශිත ඕනෑම දේපලක් ඒවා අර්ථ දක්වා ඇති විෂය පථයෙන් මකා දැමිය නොහැක. වින්‍යාසගත කළ නොහැකි ගුණාංග ඉවත් කළ නොහැක. ගණිතය, අරාව, වස්තුව වැනි සාදන ලද වස්තූන්ගේ ගුණාංග සහ 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

තවත් විසඳුමක්, භාවිතා කිරීම 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);

මෙම පෝස්ට් ඉතා පැරණි වන අතර එය ඉතා ප්‍රයෝජනවත් බව මට පෙනේ, එබැවින් වෙනත් අයෙකු මෙම පෝස්ට් එක දැක එය PHP සැකසූ ක්‍රියාකාරිත්වයේ තරම් සරල නොවන්නේ මන්දැයි සිතූ විට මා විසින් ලියන ලද සැකසූ ශ්‍රිතය බෙදා ගැනීමට තීරණය කළෙමි.

මෙම නව unsetශ්‍රිතය ලිවීමට හේතුව , අනෙක් සියලුම විචල්‍යයන්ගේ දර්ශකය මෙම hash_map හි තබා ගැනීමයි. පහත උදාහරණය දෙස බලන්න, සහ hash_map වෙතින් අගයක් ඉවත් කිරීමෙන් පසු "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 () ශ්‍රිතය ඇමතීම නිසා ඔබ දෝෂයක් ඇති නොවන බවට වග බලා ගනී.

මෙය ඔබගේ විශේෂිත භාවිතයට එකතු නොකළේ නම් කණගාටුයි, නමුත් මෙය වස්තූන් සහ ඒවායේ ගුණාංග කළමනාකරණය කිරීමේදී අනුවර්තනය වීමට හොඳ නිර්මාණයක් යැයි මම විශ්වාස කරමි.

Ramda # dissoc භාවිතා කිරීමෙන් ඔබට ගුණාංගයක් නොමැතිව නව වස්තුවක් ලැබෙනු ඇත regex:

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

එකම බලපෑමක් ලබා ගැනීම සඳහා ඔබට වෙනත් කාර්යයන් ද භාවිතා කළ හැකිය - අතහරින්න, තෝරන්න, ...

පහත දැක්වෙන ක්‍රමය උත්සාහ කරන්න. Objectදේපල වටිනාකම පවරන්න undefined. එවිට stringifyවස්තුව සහ parse.

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

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

console.log(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]

Ref: MDN .

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

'මකන්න' යන ඩෑන් ගේ ප්‍රකාශය ඉතා මන්දගාමී වන අතර ඔහු පළ කළ මිණුම් ලකුණ සැක සහිත ය. ඒ නිසා මම ක්‍රෝම් 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

අනෙක් මෙහෙයුම් නිසා ඇතිවන බලපෑම අවම කිරීම සඳහා මම එක් ලූප චක්‍රයක් තුළ 'මකාදැමීමේ' මෙහෙයුම් එකකට වඩා සිදු කර ඇති බව සලකන්න.

"regex"දේපල නොමැතිව නව වස්තුවක් නිර්මාණය කිරීම ගැන සලකා බලන්න, මන්ද මුල් වස්තුව සැමවිටම ඔබේ වැඩසටහනේ වෙනත් කොටස් මගින් යොමු කළ හැකි බැවිනි. මේ අනුව ඔබ එය හැසිරවීමෙන් වැළකී සිටිය යුතුය.

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

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

console.log(newMyObject);

JavaScript හි දේපල ඉවත් කිරීම

මෙම පිටුවේ විවිධ විකල්පයන් ඉදිරිපත් කර ඇත, බොහෝ විකල්පයන් වැරදි නිසා හෝ පිළිතුරු අනුපිටපත් නිසා නොව - නමුත් සුදුසු තාක්‍ෂණය රඳා පවතින්නේ ඔබ සිටින තත්වය සහ ඔබ සහ / හෝ ඔබ කරන කාර්යයන් වල අරමුණු මත ය. කණ්ඩායම ඉටු කිරීමට උත්සාහ කරයි. ඔබේ ප්‍රශ්නයට නිසැකවම පිළිතුරු දීමට යමෙකු දැනගත යුතුය:

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සහ අරා දර්ශක ප්රථම නිදහස් කර ගැනීම සඳහා හැර JavaScript සෑම අනුවාදය නූල් හා ක්රියා කිරීමට අමතරව. කෙසේ වෙතත්, එය විකෘති වන අතර එය සමහර ක්‍රමලේඛන මූලධර්ම උල්ලං and නය කරන අතර කාර්ය සාධන ඇඟවුම් ද ඇත. වින්‍යාසගත කළ නොහැකි ගුණාංග දැඩි ප්‍රකාරයේදී භාවිතා කරන විට එය නොදැනුවත්වම ව්‍යතිරේකයන්ට හේතු විය හැක .

විවේකය මත පදනම් වූ නූල් දේපල මඟ හැරීම

මෙම කාණ්ඩය විකෘති නොවන ප්‍රවේශයක් අපේක්ෂා කරන විට නව 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"

ඔබට විවේක ක්‍රියාකරු සමඟ 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://.*" }

පහත දැක්වෙන දේ භාවිතා කිරීමෙන් අපට ජාවාස්ක්‍රිප්ට් වස්තුවකින් ඕනෑම දේපලක් ඉවත් කළ හැකිය:

1. object.property මකන්න
2. වස්තුව මකන්න ['දේපල']

උදාහරණයක්:

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

console.log(myObject);

delete myObject.regex;
console.log('=================');
console.log(myObject);
delete myObject['method'];
console.log('=================');
console.log(myObject);

මේක උත්සාහ කරන්න

delete myObject['key'];