Nói rằng tôi tạo một đối tượng như sau:

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

Cách tốt nhất để loại bỏ tài sản regexđể kết thúc với mới myObjectnhư sau là gì?

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

Như thế này:

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

Bản giới thiệu

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

console.log(myObject);

Đối với bất kỳ ai muốn đọc thêm về nó, kangax người dùng Stack Overflow đã viết một bài đăng blog cực kỳ sâu sắc về deletetuyên bố trên blog của họ, Hiểu về xóa . Nó rất được khuyến khích.

Các đối tượng trong JavaScript có thể được coi là bản đồ giữa các khóa và giá trị. Các deletenhà điều hành được sử dụng để loại bỏ các phím này, thường được gọi là thuộc tính đối tượng, cùng một lúc.

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

Các deletenhà điều hành không trực tiếp bộ nhớ miễn phí, và nó khác với chỉ đơn giản là gán giá trị của nullhoặc undefinedđến một bất động sản, trong đó tài sản riêng của mình được lấy ra từ các đối tượng. Lưu ý rằng nếu giá trị của thuộc tính bị xóa là loại tham chiếu (một đối tượng) và một phần khác trong chương trình của bạn vẫn giữ tham chiếu đến đối tượng đó, thì đối tượng đó, tất nhiên, sẽ không được thu thập rác cho đến khi tất cả các tham chiếu đến nó có biến mất.

delete sẽ chỉ hoạt động trên các thuộc tính mà bộ mô tả đánh dấu chúng là cấu hình.

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

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

Điều này hoạt động trong Firefox và Internet Explorer và tôi nghĩ rằng nó hoạt động trong tất cả những người khác.

Các deletenhà điều hành được sử dụng để loại bỏ các thuộc tính từ các đối tượng.

const obj = { foo: "bar" }
delete obj.foo
obj.hasOwnProperty("foo") // false

Lưu ý rằng, đối với mảng, điều này không giống như loại bỏ một phần tử . Để loại bỏ một phần tử khỏi một mảng, sử dụng Array#splicehoặc Array#pop. Ví dụ:

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

Chi tiết

deletetrong JavaScript có một chức năng khác với từ khóa trong C và C ++: nó không trực tiếp giải phóng bộ nhớ. Thay vào đó, mục đích duy nhất của nó là loại bỏ các thuộc tính khỏi các đối tượng.

Đối với mảng, xóa một thuộc tính tương ứng với một chỉ mục, sẽ tạo ra một mảng thưa thớt (tức là một mảng có "lỗ" trong đó). Hầu hết các trình duyệt đại diện cho các chỉ số mảng bị thiếu này là "trống".

var array = [0, 1, 2, 3]
delete array[2] // [0, 1, empty, 3]

Lưu ý rằng deletekhông di chuyển array[3]vào array[2].

Các hàm dựng sẵn khác nhau trong JavaScript xử lý các mảng thưa thớt khác nhau.

• for...in sẽ bỏ qua chỉ số trống hoàn toàn.

• Một forvòng lặp truyền thống sẽ trả về undefinedgiá trị tại chỉ mục.

• Bất kỳ phương pháp sử dụng Symbol.iteratorsẽ trả về undefinedgiá trị tại chỉ mục.

• forEach, mapvà reduceđơn giản là sẽ bỏ qua chỉ số còn thiếu.

Vì vậy, deletetoán tử không nên được sử dụng cho trường hợp sử dụng chung để loại bỏ các phần tử khỏi một mảng. Mảng có một phương pháp chuyên dụng để loại bỏ các phần tử và phân bổ lại bộ nhớ: Array#splice()và Array#pop.

Mảng # splice (bắt đầu [, xóaCount [, item1 [, item2 [, ...]]]])

Array#splicelàm thay đổi mảng và trả về bất kỳ chỉ số bị loại bỏ nào. deleteCountcác phần tử được xóa khỏi chỉ mục startvà item1, item2... itemNđược chèn vào mảng từ chỉ mục start. Nếu deleteCountđược bỏ qua thì các phần tử từ start Index sẽ bị xóa đến cuối mảng.

let a = [0,1,2,3,4]
a.splice(2,2) // returns the removed elements [2,3]
// ...and `a` is now [0,1,4]

Ngoài ra còn có một tên tương tự, nhưng khác nhau, chức năng trên Array.prototype: Array#slice.

Mảng # lát ([bắt đầu [, kết thúc]])

Array#slicekhông phá hủy và trả về một mảng mới chứa các chỉ mục được chỉ định từ startđến end. Nếu endkhông được chỉ định, nó mặc định đến cuối mảng. Nếu endlà dương, nó chỉ định chỉ số không bao gồm dựa trên số 0 dừng lại ở. Nếu endâm, nó chỉ định chỉ mục dừng lại bằng cách đếm ngược từ cuối mảng (ví dụ: -1 sẽ bỏ qua chỉ mục cuối cùng). Nếu end <= start, kết quả là một mảng trống.

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]

Mảng # pop

Array#popxóa phần tử cuối cùng khỏi một mảng và trả về phần tử đó. Thao tác này thay đổi độ dài của mảng.

Câu hỏi cũ, câu trả lời hiện đại. Sử dụng tính năng hủy đối tượng, một tính năng ECMAScript 6 , đơn giản như:

const { a, ...rest } = { a: 1, b: 2, c: 3 };

Hoặc với mẫu câu hỏi:

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

Bạn có thể thấy nó hoạt động trong trình chỉnh sửa dùng thử Babel.

Biên tập:

Để gán lại cho cùng một biến, sử dụng a let:

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

Cú pháp lây lan (ES6)

Cho bất cứ ai cần nó ...

Để hoàn thành câu trả lời @Koen trong chuỗi này, trong trường hợp bạn muốn loại bỏ biến động bằng cú pháp trải rộng, bạn có thể làm như vậy:

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

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

* foosẽ là một biến mới có giá trị là a(là 1).

ĐÁP EXTENDED 😇
Có vài cách phổ biến để loại bỏ một tài sản từ một đối tượng.
Mỗi cái đều có ưu và nhược điểm riêng ( kiểm tra so sánh hiệu suất này ):

Xóa toán tử có thể
đọc và ngắn, tuy nhiên, nó có thể không phải là lựa chọn tốt nhất nếu bạn đang hoạt động trên một số lượng lớn đối tượng vì hiệu suất của nó không được tối ưu hóa.

delete obj[key];

Tái chỉ định
Nhanh hơn 2 lần so vớidelete, tuy nhiên thuộc tínhkhôngbị xóa và có thể được lặp lại.

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

Toán tử trải rộng Toán tử
nàyES6cho phép chúng ta trả về một đối tượng hoàn toàn mới, không bao gồm bất kỳ thuộc tính nào, mà không làm thay đổi đối tượng hiện có. Nhược điểm là nó có hiệu suất kém hơn ở trên và không được đề xuất sử dụng khi bạn cần loại bỏ nhiều thuộc tính cùng một lúc.

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

Một cách khác là sử dụng thư viện Underscore.js .

Lưu ý rằng _.pick()và _.omit()cả hai trả về một bản sao của đối tượng và không trực tiếp sửa đổi đối tượng ban đầu. Gán kết quả cho đối tượng ban đầu nên thực hiện thủ thuật (không hiển thị).

Tham khảo: link _.pick (đối tượng, phím *)

Trả về một bản sao của đối tượng, được lọc để chỉ có các giá trị cho các khóa được liệt kê trong danh sách trắng (hoặc mảng các khóa hợp lệ).

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

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

Tham khảo: liên kết _.omit (đối tượng, * phím)

Trả về một bản sao của đối tượng, được lọc để bỏ qua các phím được liệt kê trong danh sách đen (hoặc mảng các phím).

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

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

Đối với mảng, _.filter()và _.reject()có thể được sử dụng theo cách tương tự.

Thuật ngữ bạn đã sử dụng trong tiêu đề câu hỏi của bạn Remove a property from a JavaScript object, có thể được hiểu theo một số cách khác nhau. Một là loại bỏ nó cho toàn bộ bộ nhớ và danh sách các khóa đối tượng hoặc cái còn lại chỉ là xóa nó khỏi đối tượng của bạn. Như đã được đề cập trong một số câu trả lời khác, deletetừ khóa là phần chính. Giả sử bạn có đối tượng của mình như:

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

Nếu bạn làm:

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

kết quả sẽ là:

["ircEvent", "method", "regex"]

Bạn có thể xóa khóa cụ thể đó khỏi các khóa đối tượng của mình như:

delete myJSONObject["regex"];

Sau đó, khóa đối tượng của bạn sử dụng Object.keys(myJSONObject)sẽ là:

["ircEvent", "method"]

Nhưng vấn đề là nếu bạn quan tâm đến bộ nhớ và bạn muốn xóa toàn bộ đối tượng khỏi bộ nhớ, bạn nên đặt nó thành null trước khi xóa khóa:

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

Điểm quan trọng khác ở đây là cẩn thận về các tham chiếu khác của bạn đến cùng một đối tượng. Chẳng hạn, nếu bạn tạo một biến như:

var regex = myJSONObject["regex"];

Hoặc thêm nó dưới dạng một con trỏ mới vào một đối tượng khác như:

var myOtherObject = {};
myOtherObject["regex"] = myJSONObject["regex"];

Sau đó, ngay cả khi bạn xóa nó khỏi đối tượng của mình myJSONObject, đối tượng cụ thể đó sẽ không bị xóa khỏi bộ nhớ, vì regexbiến và myOtherObject["regex"]vẫn có giá trị của chúng. Vậy thì làm thế nào chúng ta có thể loại bỏ đối tượng khỏi bộ nhớ cho chắc chắn?

Câu trả lời sẽ là xóa tất cả các tham chiếu bạn có trong mã của mình, chỉ vào chính đối tượng đó và cũng không sử dụng các varcâu lệnh để tạo các tham chiếu mới cho đối tượng đó . Điểm cuối cùng này liên quan đến các varcâu lệnh, là một trong những vấn đề quan trọng nhất mà chúng ta thường phải đối mặt, bởi vì sử dụng các varcâu lệnh sẽ ngăn không cho đối tượng được tạo ra bị xóa.

Điều đó có nghĩa là trong trường hợp này bạn sẽ không thể xóa đối tượng đó vì bạn đã tạo regexbiến thông qua một varcâu lệnh và nếu bạn thực hiện:

delete regex; //False

Kết quả sẽ có falsenghĩa là câu lệnh xóa của bạn chưa được thực thi như bạn mong đợi. Nhưng nếu bạn chưa tạo biến đó trước đó và bạn chỉ có myOtherObject["regex"]tham chiếu cuối cùng của mình, bạn có thể thực hiện việc này chỉ bằng cách xóa nó như sau:

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

Nói cách khác, một đối tượng JavaScript sẽ bị giết ngay khi không còn tham chiếu nào trong mã của bạn trỏ đến đối tượng đó.

Cập nhật: Cảm ơn @AgentME:

Đặt thuộc tính thành null trước khi xóa nó sẽ không thực hiện được bất cứ điều gì (trừ khi đối tượng đã bị Object.seal niêm phong và việc xóa không thành công. Đó thường không phải là trường hợp trừ khi bạn cố gắng cụ thể).

Để có thêm thông tin về Object.seal: Object.seal ()

ECMAScript 2015 (hoặc ES6) đi kèm với đối tượng Reflect tích hợp . Có thể xóa thuộc tính đối tượng bằng cách gọi hàm Reflect.deleteProperty () với đối tượng đích và khóa thuộc tính làm tham số:

Reflect.deleteProperty(myJSONObject, 'regex');

tương đương với:

delete myJSONObject['regex'];

Nhưng nếu thuộc tính của đối tượng không thể cấu hình được thì không thể xóa cả chức năng erProperty cũng như xóa toán tử:

let obj = Object.freeze({ prop: "value" });
let success = Reflect.deleteProperty(obj, "prop");
console.log(success); // false
console.log(obj.prop); // value

Object.freeze () làm cho tất cả các thuộc tính của đối tượng không thể cấu hình (bên cạnh những thứ khác). deletePropertyHàm (cũng như xóa toán tử ) trả về falsekhi cố gắng xóa bất kỳ thuộc tính nào của nó. Nếu thuộc tính là cấu hình, nó trả về true, ngay cả khi thuộc tính không tồn tại.

Sự khác biệt giữa deletevà deletePropertylà khi sử dụng chế độ nghiêm ngặt:

"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

Giả sử bạn có một đối tượng trông như thế này:

var Hogwarts = {
    staff : [
        'Argus Filch',
        'Filius Flitwick',
        'Gilderoy Lockhart',
        'Minerva McGonagall',
        'Poppy Pomfrey',
        ...
    ],
    students : [
        'Hannah Abbott',
        'Katie Bell',
        'Susan Bones',
        'Terry Boot',
        'Lavender Brown',
        ...
    ]
};

Xóa một thuộc tính đối tượng

Nếu bạn muốn sử dụng toàn bộ staffmảng, cách thích hợp để làm điều này, sẽ là làm điều này:

delete Hogwarts.staff;

Ngoài ra, bạn cũng có thể làm điều này:

delete Hogwarts['staff'];

Tương tự, loại bỏ toàn bộ mảng sinh viên sẽ được thực hiện bằng cách gọi delete Hogwarts.students;hoặc delete Hogwarts['students'];.

Xóa một chỉ mục mảng

Bây giờ, nếu bạn muốn loại bỏ một nhân viên hoặc học sinh, quy trình này hơi khác một chút, vì cả hai thuộc tính đều là mảng.

Nếu bạn biết chỉ số của nhân viên của mình, bạn chỉ cần làm điều này:

Hogwarts.staff.splice(3, 1);

Nếu bạn không biết chỉ mục, bạn cũng sẽ phải thực hiện tìm kiếm chỉ mục:

Hogwarts.staff.splice(Hogwarts.staff.indexOf('Minerva McGonnagall') - 1, 1);

Ghi chú

Mặc dù về mặt kỹ thuật bạn có thể sử dụng deletecho một mảng, sử dụng nó sẽ dẫn đến kết quả không chính xác khi gọi ví dụ Hogwarts.staff.lengthsau này. Nói cách khác, deletesẽ loại bỏ phần tử, nhưng nó sẽ không cập nhật giá trị của lengthtài sản. Sử dụng deletecũng sẽ làm rối chỉ mục của bạn.

Vì vậy, khi xóa các giá trị khỏi một đối tượng, trước tiên hãy luôn xem xét liệu bạn đang xử lý các thuộc tính của đối tượng hay liệu bạn đang xử lý các giá trị mảng và chọn chiến lược phù hợp dựa trên đó.

Nếu bạn muốn thử nghiệm điều này, bạn có thể sử dụng Fiddle này làm điểm bắt đầu.

Sử dụng ES6:

(Hủy cấu trúc + Toán tử trải)

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

Cá nhân tôi sử dụng Underscore.js hoặc Lodash cho thao tác đối tượng và mảng:

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

Các nhà điều hành xóa là cách tốt nhất để làm như vậy.

Một ví dụ trực tiếp để hiển thị:

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

Để sao chép đối tượng không có tài sản:

Ví dụ:

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

Và chúng ta cần xóa 'a'.

1.Với khóa prop rõ ràng:

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

2.Với khóa prop biến:

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

3.Cool mũi tên hàm 😎:

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

object = removePropery('a', object);

4. Đối với nhiều thuộc tính

const removeProperties = (object, ...keys) => Object.entries(object).reduce((prev, [key, value]) => ({...prev, ...(!keys.includes(key) && { [key]: value }) }), {})

Sử dụng

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

Hoặc là

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

Sử dụng phương thức xóa là cách tốt nhất để làm điều đó, theo mô tả MDN, toán tử xóa sẽ xóa một thuộc tính khỏi một đối tượng. Vì vậy, bạn có thể chỉ cần viết:

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

Toán tử xóa sẽ xóa một thuộc tính đã cho khỏi một đối tượng. Khi xóa thành công, nó sẽ trả về true, sai khác sẽ được trả về. Tuy nhiên, điều quan trọng là phải xem xét các tình huống sau:

• Nếu thuộc tính mà bạn đang cố xóa không tồn tại, xóa sẽ không có hiệu lực và sẽ trả về đúng

• Nếu một thuộc tính có cùng tên tồn tại trên chuỗi nguyên mẫu của đối tượng, thì sau khi xóa, đối tượng sẽ sử dụng thuộc tính từ chuỗi nguyên mẫu (nói cách khác, xóa chỉ có ảnh hưởng đến các thuộc tính riêng).

• Bất kỳ thuộc tính nào được khai báo với var không thể bị xóa khỏi phạm vi toàn cục hoặc từ phạm vi của hàm.

• Như vậy, xóa không thể xóa bất kỳ chức năng nào trong phạm vi toàn cầu (cho dù đây là một phần từ định nghĩa hàm hoặc hàm (biểu thức).

• Các chức năng là một phần của một đối tượng (ngoài
  phạm vi toàn cầu) có thể bị xóa bằng xóa.

• Bất kỳ thuộc tính nào được khai báo với let hoặc const không thể bị xóa khỏi phạm vi mà chúng được xác định. Thuộc tính không cấu hình có thể được gỡ bỏ. Điều này bao gồm các thuộc tính của các đối tượng tích hợp như Math, Array, Object và các thuộc tính được tạo là không thể cấu hình với các phương thức như Object.defineProperty ().

Đoạn mã sau đây cho một ví dụ đơn giản khác:

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

Để biết thêm thông tin về và xem thêm ví dụ, hãy truy cập liên kết dưới đây:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete

Một giải pháp khác, sử dụng 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);

Tuy nhiên, nó sẽ đột biến đối tượng ban đầu. Nếu bạn muốn tạo một đối tượng mới mà không có khóa được chỉ định, chỉ cần gán hàm giảm cho một biến mới, ví dụ:

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

Bài đăng này rất cũ và tôi thấy nó rất hữu ích vì vậy tôi quyết định chia sẻ hàm unset mà tôi đã viết trong trường hợp người khác nhìn thấy bài đăng này và nghĩ tại sao nó không đơn giản như trong hàm unset PHP.

Lý do để viết unsethàm mới này là để giữ chỉ mục của tất cả các biến khác trong hàm hash_map này. Xem ví dụ sau và xem chỉ số của "test2" không thay đổi như thế nào sau khi xóa giá trị khỏi hàm 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"}

Có rất nhiều câu trả lời hay ở đây nhưng tôi chỉ muốn nói rằng khi sử dụng xóa để xóa một thuộc tính trong JavaScript, trước tiên, nên kiểm tra xem liệu thuộc tính đó có tồn tại để ngăn ngừa lỗi hay không.

Ví dụ

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

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

Do tính chất động của JavaScript, thường có những trường hợp bạn đơn giản không biết liệu tài sản có tồn tại hay không. Kiểm tra xem obj có tồn tại trước && cũng đảm bảo bạn không gặp lỗi do gọi hàm hasOwnProperty () trên một đối tượng không xác định.

Xin lỗi nếu điều này không thêm vào trường hợp sử dụng cụ thể của bạn nhưng tôi tin rằng đây là một thiết kế tốt để thích ứng khi quản lý các đối tượng và thuộc tính của chúng.

Sử dụng ramda # dissoc, bạn sẽ nhận được một đối tượng mới mà không có thuộc tính regex:

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

Bạn cũng có thể sử dụng các chức năng khác để đạt được hiệu quả tương tự - bỏ qua, chọn, ...

Hãy thử phương pháp sau. Gán Objectgiá trị tài sản cho undefined. Sau đó, stringifyđối tượng và parse.

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

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

console.log(myObject);

Nếu bạn muốn xóa một thuộc tính được lồng sâu vào đối tượng thì bạn có thể sử dụng hàm đệ quy sau với đường dẫn đến thuộc tính làm đối số thứ hai:

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

Thí dụ:

var a = {
    level1:{
        level2:{
            level3: {
                level4: "yolo"
            }
        }
    }
};

deepObjectRemove(a, ["level1", "level2", "level3"]);
console.log(a);

//Prints {level1: {level2: {}}}

Bạn có thể chỉ cần xóa bất kỳ thuộc tính của một đối tượng bằng cách sử dụng deletetừ khóa.

Ví dụ:

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

Để xóa bất kỳ thuộc tính nào, giả key1sử, sử dụng deletetừ khóa như thế này:

delete obj.key1

Hoặc bạn cũng có thể sử dụng ký hiệu giống như mảng:

delete obj[key1]

Tham chiếu: 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"];
        }
    }
);

Dan khẳng định rằng 'xóa' là rất chậm và điểm chuẩn mà anh ta đăng tải bị nghi ngờ. Vì vậy, tôi đã tự mình thực hiện thử nghiệm trong Chrome 59. Có vẻ như 'xóa' chậm hơn khoảng 30 lần:

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

Lưu ý rằng tôi đã cố tình thực hiện nhiều hơn một thao tác 'xóa' trong một chu kỳ vòng lặp để giảm thiểu ảnh hưởng do các hoạt động khác gây ra.

Xem xét việc tạo một đối tượng mới mà không có thuộc "regex"tính vì đối tượng ban đầu luôn có thể được tham chiếu bởi các phần khác trong chương trình của bạn. Vì vậy, bạn nên tránh thao tác nó.

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

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

console.log(newMyObject);

Xóa tài sản trong JavaScript

Có rất nhiều tùy chọn khác nhau được trình bày trên trang này, không phải vì hầu hết các tùy chọn đều sai, vì câu trả lời trùng lặp với nhau mà vì kỹ thuật phù hợp phụ thuộc vào tình huống bạn thực hiện và mục tiêu của các nhiệm vụ bạn và / hoặc bạn nhóm đang cố gắng thực hiện. Để trả lời câu hỏi của bạn một cách dứt khoát, người ta cần biết:

1. Phiên bản ECMAScript bạn đang nhắm mục tiêu
2. Phạm vi của các loại đối tượng bạn muốn xóa thuộc tính và loại tên thuộc tính bạn cần có thể bỏ qua (Chỉ chuỗi? Biểu tượng? Tham chiếu yếu được ánh xạ từ các đối tượng tùy ý? Đây đều là các loại con trỏ thuộc tính trong JavaScript trong nhiều năm nay )
3. Các ethos lập trình / mẫu bạn và nhóm của bạn sử dụng. Bạn có thích cách tiếp cận chức năng và đột biến là verboten trong nhóm của bạn, hoặc bạn sử dụng các kỹ thuật hướng đối tượng đột biến ở phía tây hoang dã?
4. Bạn đang muốn đạt được điều này trong JavaScript thuần túy hay bạn có sẵn sàng & có thể sử dụng thư viện của bên thứ 3 không?

Khi bốn câu hỏi đó đã được trả lời, về cơ bản, có bốn loại "loại bỏ thuộc tính" trong JavaScript để đáp ứng mục tiêu của bạn. Họ đang:

Xóa tài sản đối tượng đột biến, không an toàn

Danh mục này dành cho hoạt động trên các đối tượng bằng chữ hoặc đối tượng khi bạn muốn giữ lại / tiếp tục sử dụng tham chiếu ban đầu và không sử dụng các nguyên tắc chức năng không trạng thái trong mã của bạn. Một ví dụ về cú pháp trong thể loại này:

'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

Danh mục này là danh mục loại bỏ tài sản lâu đời nhất, đơn giản nhất và được hỗ trợ rộng rãi nhất. Nó hỗ trợ Symbol& lập chỉ mục mảng ngoài chuỗi và hoạt động trong mọi phiên bản JavaScript ngoại trừ bản phát hành đầu tiên. Tuy nhiên, đó là đột biến vi phạm một số nguyên tắc lập trình và có ý nghĩa về hiệu suất. Nó cũng có thể dẫn đến các ngoại lệ chưa được phát hiện khi được sử dụng trên các thuộc tính không thể cấu hình trong chế độ nghiêm ngặt .

Bỏ sót thuộc tính chuỗi dựa trên phần còn lại

Danh mục này dành cho hoạt động trên các đối tượng hoặc đối tượng mảng đơn giản trong các hương vị ECMAScript mới hơn khi muốn có một phương pháp không đột biến và bạn không cần phải tính đến các khóa Biểu tượng:

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

Xóa tài sản đối tượng đột biến, an toàn

Danh mục này dành cho hoạt động trên các đối tượng bằng chữ hoặc đối tượng khi bạn muốn giữ lại / tiếp tục sử dụng tham chiếu ban đầu trong khi bảo vệ chống lại các ngoại lệ bị ném vào các thuộc tính không thể định cấu hình:

'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

Ngoài ra, trong khi việc đột biến các đối tượng tại chỗ không phải là không trạng thái, bạn có thể sử dụng tính chất chức năng Reflect.deletePropertyđể thực hiện một phần ứng dụng và các kỹ thuật chức năng khác không thể thực hiện được với các deletecâu lệnh.

Bỏ sót thuộc tính chuỗi dựa trên cú pháp

Danh mục này dành cho hoạt động trên các đối tượng hoặc đối tượng mảng đơn giản trong các hương vị ECMAScript mới hơn khi muốn có một phương pháp không đột biến và bạn không cần phải tính đến các khóa Biểu tượng:

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

Bỏ sót tài sản dựa trên thư viện

Danh mục này thường cho phép linh hoạt hơn về chức năng, bao gồm cả việc hạch toán các Biểu tượng & bỏ sót nhiều hơn một thuộc tính trong một tuyên bố:

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"

Bạn có thể sử dụng ES6 phá hủy với toán tử nghỉ.

Các thuộc tính có thể được loại bỏ bằng cách sử dụng hủy kết hợp với toán tử còn lại . Trong ví dụ của bạn regex bị phá hủy (bỏ qua) và phần còn lại của các thuộc tính được trả về dưới dạng phần còn lại.

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

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

Hoặc bạn có thể tự động loại trừ các thuộc tính như thế này,

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://.*" }

Chúng tôi có thể xóa bất kỳ thuộc tính nào khỏi đối tượng javascript bằng cách sử dụng như sau:

1. xóa object.property
2. xóa đối tượng ['property']

thí dụ:

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

Thử cái này

delete myObject['key'];