ว่าฉันสร้างวัตถุดังนี้

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

สำหรับทุกคนที่สนใจในการอ่านเพิ่มเติมเกี่ยวกับการใช้งานมากเกิน Stack kangaxได้เขียนบล็อกโพสต์อย่างไม่น่าเชื่อในเชิงลึกเกี่ยวกับdeleteคำสั่งเกี่ยวกับบล็อกของพวกเขาทำความเข้าใจลบ ขอแนะนำอย่างยิ่ง

วัตถุใน JavaScript ถือได้ว่าเป็นแผนที่ระหว่างปุ่มและค่า deleteผู้ประกอบการใช้ในการลบคีย์เหล่านี้เป็นที่รู้จักกันทั่วไปว่าเป็นคุณสมบัติของวัตถุหนึ่งที่เวลา

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

deleteผู้ประกอบการไม่หน่วยความจำฟรีไม่ได้โดยตรงและมันแตกต่างจากเพียงแค่การกำหนดค่าของnullหรือundefinedคุณสมบัติในว่าทรัพย์สินที่ตัวเองจะถูกลบออกจากวัตถุ โปรดทราบว่าหากค่าของคุณสมบัติที่ถูกลบเป็นประเภทการอ้างอิง (วัตถุ) และอีกส่วนหนึ่งของโปรแกรมของคุณยังคงมีการอ้างอิงไปยังวัตถุนั้นแน่นอนว่าวัตถุนั้นจะไม่ถูกเก็บรวบรวมขยะจนกว่าจะมีการอ้างอิงทั้งหมดที่มี หายไป.

delete จะทำงานกับคุณสมบัติที่ descriptor ทำเครื่องหมายว่าสามารถกำหนดค่าได้

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

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

สิ่งนี้ใช้ได้ใน Firefox และ Internet Explorer และฉันคิดว่ามันใช้ได้กับทุกคน

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ใน JavaScript มีฟังก์ชั่นที่แตกต่างจากคำหลักใน 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

Array # splice (เริ่ม [, 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.prototypeArray#slice

Array # slice ([start [, end]])

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

แก้ไข:

หากต้องการมอบหมายตัวแปรเดียวกันให้ใช้let:

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

สเปรดไวยากรณ์ (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 }

* fooจะเป็นตัวแปรใหม่ที่มีค่าa(ซึ่งก็คือ 1)

คำตอบที่ขยายออกไป 😇
มีวิธีทั่วไปสองสามวิธีในการลบคุณสมบัติออกจากวัตถุ
แต่ละคนมีข้อดีและข้อเสียของตัวเอง (ตรวจสอบการเปรียบเทียบประสิทธิภาพ ):

Delete Operator สามารถ
อ่านได้และย่ออย่างไรก็ตามมันอาจไม่ใช่ตัวเลือกที่ดีที่สุดหากคุณใช้งานกับวัตถุจำนวนมากเนื่องจากประสิทธิภาพของมันไม่ได้รับการปรับให้เหมาะสม

delete obj[key];

การโอนสิทธิ
มากกว่า 2 เท่าเร็วกว่าdeleteอย่างไรก็ตามคุณสมบัติจะไม่ถูกลบและสามารถทำซ้ำได้

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

ผู้ประกอบการแพร่กระจายตัวดำเนินการ
นี้ES6ช่วยให้เราสามารถส่งคืนวัตถุใหม่เอี่ยมยกเว้นคุณสมบัติใด ๆ โดยไม่ต้องกลายพันธุ์วัตถุที่มีอยู่ ข้อเสียคือมันมีประสิทธิภาพที่แย่กว่าข้างต้นและไม่แนะนำให้ใช้เมื่อคุณต้องการลบคุณสมบัติหลาย ๆ อย่างในเวลาเดียวกัน

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

อีกทางเลือกหนึ่งคือการใช้ไลบรารีUnderscore.js

โปรดทราบว่า_.pick()และ_.omit()ทั้งสองส่งคืนสำเนาของวัตถุและไม่แก้ไขวัตถุต้นฉบับโดยตรง การกำหนดผลลัพธ์ให้กับวัตถุดั้งเดิมควรทำการหลอกลวง (ไม่แสดง)

การอ้างอิง: ลิงค์ _.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));

ผลลัพธ์จะเป็น:

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

กล่าวอีกนัยหนึ่งวัตถุ JavaScript จะถูกฆ่าทันทีที่ไม่มีการอ้างอิงเหลืออยู่ในรหัสของคุณซึ่งชี้ไปที่วัตถุนั้น

อัปเดต: ขอบคุณ @AgentME:

การตั้งค่าคุณสมบัติเป็นโมฆะก่อนที่จะลบมันจะไม่ทำสิ่งใดให้สำเร็จ (เว้นแต่ว่าวัตถุนั้นถูกผนึกโดย Object.seal และการลบล้มเหลวซึ่งโดยปกติจะไม่ใช่กรณีเว้นแต่คุณจะพยายามเป็นพิเศษ)

วิธีรับข้อมูลเพิ่มเติมเกี่ยวกับObject.seal: Object.seal ()

ECMAScript 2015 (หรือ ES6) มาพร้อมกับวัตถุReflectในตัว เป็นไปได้ที่จะลบคุณสมบัติของวัตถุโดยเรียกฟังก์ชัน Reflect.deleteProperty ()พร้อมกับวัตถุเป้าหมายและรหัสคุณสมบัติเป็นพารามิเตอร์:

Reflect.deleteProperty(myJSONObject, 'regex');

ซึ่งเทียบเท่ากับ:

delete myJSONObject['regex'];

แต่ถ้าคุณสมบัติของวัตถุนั้นไม่สามารถกำหนดค่าได้จะไม่สามารถลบได้ด้วยฟังก์ชั่น deleteProperty หรือตัวดำเนินการลบ:

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จะทำให้การจัดทำดัชนีของคุณยุ่งเหยิง

ดังนั้นเมื่อลบค่าออกจากวัตถุก่อนอื่นให้พิจารณาว่าคุณกำลังจัดการกับคุณสมบัติของวัตถุหรือไม่ว่าคุณกำลังจัดการกับค่าอาร์เรย์และเลือกกลยุทธ์ที่เหมาะสมตามนั้น

หากคุณต้องการทดลองสิ่งนี้คุณสามารถใช้ซอนี้เป็นจุดเริ่มต้น

ใช้ 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');

ตัวดำเนินการลบเป็นวิธีที่ดีที่สุด

ตัวอย่างสดที่จะแสดง:

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. ด้วยคีย์ prop ชัดเจน:

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

2. กับตัวแปรที่สำคัญ prop:

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

3. ฟังก์ชั่นลูกศรเย็น😎:

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 }

การใช้วิธีการลบเป็นวิธีที่ดีที่สุดในการทำตามคำอธิบาย MDN ตัวดำเนินการลบจะลบคุณสมบัติออกจากวัตถุ ดังนั้นคุณสามารถเขียน:

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

ตัวดำเนินการลบจะลบคุณสมบัติที่กำหนดออกจากวัตถุ เมื่อลบสำเร็จจะส่งคืนจริงและจะส่งคืนค่าเท็จ อย่างไรก็ตามมันเป็นสิ่งสำคัญที่จะต้องพิจารณาสถานการณ์สมมติต่อไปนี้:

• หากคุณสมบัติที่คุณพยายามลบไม่มีอยู่การลบจะไม่มีผลใด ๆ และจะคืนค่าจริง

• หากมีคุณสมบัติที่มีชื่อเดียวกันอยู่บนโซ่ต้นแบบของวัตถุหลังจากลบแล้ววัตถุจะใช้คุณสมบัติจากโซ่ต้นแบบ (กล่าวอีกนัยหนึ่งคือการลบจะมีผลกับคุณสมบัติของตัวเองเท่านั้น)

• คุณสมบัติใด ๆ ที่ประกาศด้วย var ไม่สามารถลบได้จากขอบเขตส่วนกลางหรือจากขอบเขตของฟังก์ชัน

• ดังนั้นการลบไม่สามารถลบฟังก์ชั่นใด ๆ ในขอบเขตส่วนกลาง (ไม่ว่าจะเป็นส่วนหนึ่งของการกำหนดฟังก์ชั่นหรือฟังก์ชั่น (การแสดงออก)

• ฟังก์ชันที่เป็นส่วนหนึ่งของวัตถุ (นอกเหนือจาก
  ขอบเขตส่วนกลาง) สามารถลบได้ด้วยการลบ

• คุณสมบัติใด ๆ ที่ประกาศพร้อมกับอนุญาตหรือ const ไม่สามารถลบออกจากขอบเขตที่กำหนดไว้ได้ ไม่สามารถลบคุณสมบัติที่ไม่สามารถกำหนดค่าได้ ซึ่งรวมถึงคุณสมบัติของวัตถุในตัวเช่น 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

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

โพสต์นี้เก่ามากและฉันคิดว่ามันมีประโยชน์มากดังนั้นฉันจึงตัดสินใจที่จะแบ่งปันฟังก์ชั่น unset ที่ฉันเขียนไว้ในกรณีที่มีคนอื่นเห็นโพสต์นี้และคิดว่าทำไมมันไม่ง่ายอย่างนั้นใน PHP unset

เหตุผลในการเขียนunsetฟังก์ชั่นใหม่นี้คือการเก็บดัชนีของตัวแปรอื่น ๆ ทั้งหมดใน hash_map นี้ ดูตัวอย่างต่อไปนี้และดูว่าดัชนีของ "test2" ไม่เปลี่ยนแปลงหลังจากลบค่าออกจาก hash_map

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

มีคำตอบที่ดีมากมายที่นี่ แต่ฉันต้องการที่จะพูดสอดเมื่อใช้การลบเพื่อลบคุณสมบัติใน JavaScript มันมักจะฉลาดตรวจสอบก่อนว่าคุณสมบัติที่มีอยู่เพื่อป้องกันข้อผิดพลาด

เช่น

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

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

เนื่องจากลักษณะแบบไดนามิกของ JavaScript มักจะมีกรณีที่คุณไม่ทราบว่ามีคุณสมบัติหรือไม่ การตรวจสอบว่ามี obj อยู่ก่อนหน้า && และอย่าลืมข้อผิดพลาดเนื่องจากการเรียกใช้ฟังก์ชัน hasOwnProperty () บนวัตถุที่ไม่ได้กำหนด

ขออภัยหากนี่ไม่ได้เพิ่มในกรณีการใช้งานเฉพาะของคุณ แต่ฉันเชื่อว่านี่เป็นการออกแบบที่ดีที่จะปรับเมื่อจัดการวัตถุและคุณสมบัติของพวกเขา

การใช้ramda # dissocคุณจะได้รับวัตถุใหม่โดยไม่มีแอตทริบิวต์regex:

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

นอกจากนี้คุณยังสามารถใช้ฟังก์ชั่นอื่น ๆ เพื่อให้ได้เอฟเฟกต์เดียวกัน - ละเว้น, เลือก, ...

ลองวิธีต่อไปนี้ กำหนดค่าคุณสมบัติการObject undefinedจากนั้นวัตถุและstringifyparse

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

การยืนยันของแดนว่า 'ลบ' ช้ามากและเป็นมาตรฐานที่เขาโพสต์สงสัย ดังนั้นฉันจึงทำการทดสอบด้วยตนเองใน 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

โปรดทราบว่าฉันดำเนินการ 'ลบ' มากกว่าหนึ่งครั้งในหนึ่งวงรอบเพื่อลดผลกระทบที่เกิดจากการดำเนินการอื่น ๆ

พิจารณาสร้างวัตถุใหม่โดยไม่มี"regex"คุณสมบัติเนื่องจากวัตถุต้นฉบับสามารถอ้างอิงได้โดยส่วนอื่น ๆ ของโปรแกรมของคุณ ดังนั้นคุณควรหลีกเลี่ยงการจัดการมัน

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

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

console.log(newMyObject);

การลบคุณสมบัติใน JavaScript

มีตัวเลือกต่าง ๆ มากมายที่นำเสนอในหน้านี้ไม่ใช่เพราะตัวเลือกส่วนใหญ่ผิด - หรือเพราะคำตอบซ้ำกัน - แต่เนื่องจากเทคนิคที่เหมาะสมขึ้นอยู่กับสถานการณ์ที่คุณอยู่และเป้าหมายของงานที่คุณและ / หรือคุณ ทีมกำลังพยายามเติมเต็ม ในการตอบคำถามของคุณอย่างแจ่มแจ้งคุณจำเป็นต้องรู้:

1. เวอร์ชันของ ECMAScript ที่คุณกำหนดเป้าหมาย
2. ช่วงของประเภทวัตถุที่คุณต้องการลบคุณสมบัติและประเภทของชื่อคุณสมบัติที่คุณต้องสามารถตัดออกได้ (สตริงเท่านั้นสัญลักษณ์สัญลักษณ์ที่อ่อนแอการอ้างอิงที่แมปจากออบเจกต์เหล่านี้เป็นพอยน์เตอร์ประเภทคุณสมบัติทั้งหมดใน JavaScript เป็นเวลาหลายปีแล้ว )
3. จริยธรรมการเขียนโปรแกรม / รูปแบบที่คุณและทีมของคุณใช้ คุณชอบแนวทางการทำงานและการกลายพันธุ์ที่มี verboten ในทีมของคุณหรือคุณใช้เทคนิคเชิงวัตถุกลายพันธุ์ตะวันตก?
4. คุณกำลังมองหาเพื่อให้ได้สิ่งนี้ใน JavaScript ที่บริสุทธิ์หรือคุณเต็มใจและสามารถใช้ห้องสมุดบุคคลที่สามได้หรือไม่?

เมื่อตอบคำถามทั้งสี่ข้อแล้วจะมี "การลบคุณสมบัติ" สี่หมวดหมู่ใน JavaScript เพื่อเลือกจากเพื่อให้บรรลุเป้าหมายของคุณ พวกเขาคือ:

การลบคุณสมบัติวัตถุแบบรวมไม่ปลอดภัย

หมวดหมู่นี้ใช้สำหรับการดำเนินการกับวัตถุตัวอักษรหรืออินสแตนซ์ของวัตถุเมื่อคุณต้องการเก็บ / ดำเนินการต่อเพื่อใช้การอ้างอิงดั้งเดิมและไม่ได้ใช้หลักการทำงานที่ไร้สัญชาติในรหัสของคุณ ตัวอย่างส่วนของไวยากรณ์ในหมวดหมู่นี้:

'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 ยกเว้นรุ่นแรก อย่างไรก็ตามมันเป็นการเปลี่ยนแปลงซึ่งละเมิดหลักการเขียนโปรแกรมบางอย่างและมีผลกระทบต่อประสิทธิภาพ นอกจากนี้ยังสามารถส่งผลให้เกิดข้อยกเว้น uncaught เมื่อใช้กับคุณสมบัติที่ไม่สามารถกำหนดค่าได้ในโหมดที่เข้มงวด

การละเว้นคุณสมบัติสตริงแบบอิงส่วนที่เหลือ

หมวดหมู่นี้ใช้สำหรับการทำงานกับวัตถุธรรมดาหรืออินสแตนซ์ของอาร์เรย์ในรสชาติ 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 :(

การละเว้นคุณสมบัติตามไลบรารี

โดยทั่วไปหมวดหมู่นี้จะช่วยให้มีความยืดหยุ่นในการใช้งานมากขึ้นรวมถึงการบัญชีสำหรับ 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 กับผู้ควบคุมเครื่องได้

คุณสมบัติสามารถลบออกได้โดยใช้destructuringร่วมกับผู้ประกอบการส่วนที่เหลือ ในตัวอย่าง regex ของคุณถูกทำลาย (ละเว้น) และคุณสมบัติที่เหลือจะถูกส่งคืนเป็นที่พัก

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'];