Làm cách nào tôi có thể sao chép một đối tượng JavaScript ngoại trừ một khóa?

Tôi có một đối tượng JS phẳng:

{a: 1, b: 2, c: 3, ..., z:26}

Tôi muốn sao chép đối tượng ngoại trừ một yếu tố:

{a: 1, c: 3, ..., z:26}

Cách dễ nhất để làm điều này (thích sử dụng es6 / 7 nếu có thể)?

Nếu bạn sử dụng Babel, bạn có thể sử dụng cú pháp sau để sao chép thuộc tính b từ x vào biến b và sau đó sao chép phần còn lại của thuộc tính vào biến y :

let x = {a: 1, b: 2, c: 3, z:26};
let {b, ...y} = x;

và nó sẽ được dịch vào:

"use strict";

function _objectWithoutProperties(obj, keys) {
  var target = {};
  for (var i in obj) {
    if (keys.indexOf(i) >= 0) continue;
    if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
    target[i] = obj[i];
  }
  return target;
}

var x = { a: 1, b: 2, c: 3, z: 26 };
var b = x.b;

var y = _objectWithoutProperties(x, ["b"]);

var clone = Object.assign({}, {a: 1, b: 2, c: 3});
delete clone.b;

hoặc nếu bạn chấp nhận tài sản không xác định:

var clone = Object.assign({}, {a: 1, b: 2, c: 3}, {b: undefined});

Để thêm vào câu trả lời của Ilya Palkin: bạn thậm chí có thể tự động xóa các phím:

const x = {a: 1, b: 2, c: 3, z:26};

const objectWithoutKey = (object, key) => {
  const {[key]: deletedKey, ...otherKeys} = object;
  return otherKeys;
}

console.log(objectWithoutKey(x, 'b')); // {a: 1, c: 3, z:26}
console.log(x); // {a: 1, b: 2, c: 3, z:26};

Bản demo trong Babel REPL

Nguồn:

• https://twitter.com/ydkjs/status/699845396084846592

Đối với những người không thể sử dụng ES6, bạn có thể sử dụng lodashhoặc underscore.

_.omit(x, 'b')

Hoặc ramda.

R.omit('b', x)

Tôi sử dụng ESNext một lớp lót này

const obj = { a: 1, b: 2, c: 3, d: 4 }
const clone = (({ b, c, ...o }) => o)(obj) // remove b and c
console.log(clone)

Nếu bạn cần một chức năng mục đích chung:

function omit(obj, props) {
  props = props instanceof Array ? props : [props]
  return eval(`(({${props.join(',')}, ...o}) => o)(obj)`)
}

// usage
const obj = { a: 1, b: 2, c: 3, d: 4 }
const clone = omit(obj, ['b', 'c'])
console.log(clone)

Bạn có thể viết một hàm trợ giúp đơn giản cho nó. Lodash có chức năng tương tự có cùng tên: bỏ qua

function omit(obj, omitKey) {
  return Object.keys(obj).reduce((result, key) => {
    if(key !== omitKey) {
       result[key] = obj[key];
    }
    return result;
  }, {});
}

omit({a: 1, b: 2, c: 3}, 'c')  // {a: 1, b: 2}

Ngoài ra, lưu ý rằng nó nhanh hơn Object.assign và xóa sau đó: http://jsperf.com/omit-key

Có lẽ một cái gì đó như thế này:

var copy = Object.assign({}, {a: 1, b: 2, c: 3})
delete copy.c;

Điều này có đủ tốt không? Hoặc cthực sự không thể được sao chép?

Sử dụng phá hủy đối tượng

const omit = (prop, { [prop]: _, ...rest }) => rest;
const obj = { a: 1, b: 2, c: 3 };
const objWithoutA = omit('a', obj);
console.log(objWithoutA); // {b: 2, c: 3}

Hey có vẻ như bạn chạy vào tham chiếu các vấn đề khi bạn đang cố sao chép một đối tượng sau đó xóa một thuộc tính. Ở đâu đó bạn phải gán các biến nguyên thủy để javascript tạo ra một giá trị mới.

Thủ thuật đơn giản (có thể là khủng khiếp) Tôi đã sử dụng là

var obj = {"key1":"value1","key2":"value2","key3":"value3"};

// assign it as a new variable for javascript to cache
var copy = JSON.stringify(obj);
// reconstitute as an object
copy = JSON.parse(copy);
// now you can safely run delete on the copy with completely new values
delete copy.key2

console.log(obj)
// output: {key1: "value1", key2: "value2", key3: "value3"}
console.log(copy)
// output: {key1: "value1", key3: "value3"}

Đây là một tùy chọn để bỏ qua các khóa động mà tôi tin rằng chưa được đề cập:

const obj = { 1: 1, 2: 2, 3: 3, 4: 4 };
const removeMe = 1;

const { [removeMe]: removedKey, ...newObj } = obj;

removeMeđược đặt bí danh là removedKeyvà bỏ qua. newObjtrở thành { 2: 2, 3: 3, 4: 4 }. Lưu ý rằng khóa đã xóa không tồn tại, giá trị không chỉ được đặt thành undefined.

CÁCH DỄ DÀNG NHẤT

const allAlphabets = {a: 1, b: 2, c: 3, ..., z:26};
const { b, ...allExceptOne } = allAlphabets;
console.log(allExceptOne);   // {a: 1, c: 3, ..., z:26}

Bỏ qua

let source = //{a: 1, b: 2, c: 3, ..., z:26}
let copySansProperty = _.omit(source, 'b');
// {a: 1, c: 3, ..., z:26}

Bạn cũng có thể sử dụng toán tử lây lan để làm điều này

const source = { a: 1, b: 2, c: 3, z: 26 }
const copy = { ...source, ...{ b: undefined } } // { a: 1, c: 3, z: 26 }

Các giải pháp trên sử dụng cấu trúc bị ảnh hưởng bởi thực tế là bạn có một biến được sử dụng, điều này có thể gây ra khiếu nại từ ESLint nếu bạn đang sử dụng biến đó.

Vì vậy, đây là giải pháp của tôi:

const src = { a: 1, b: 2 }
const result = Object.keys(src)
  .reduce((acc, k) => k === 'b' ? acc : { ...acc, [k]: src[k] }, {})

Trên hầu hết các nền tảng (trừ IE trừ khi sử dụng Babel), bạn cũng có thể thực hiện:

const src = { a: 1, b: 2 }
const result = Object.fromEntries(
  Object.entries(src).filter(k => k !== 'b'))

Còn cái này thì sao:

let clone = Object.assign({}, value);
delete clone.unwantedKey;

Nếu bạn đang xử lý một biến lớn, bạn không muốn sao chép nó và sau đó xóa nó, vì điều này sẽ không hiệu quả.

Một vòng lặp đơn giản với kiểm tra hasOwnProperty sẽ hoạt động và nó thích ứng hơn nhiều với các nhu cầu trong tương lai:

for(var key in someObject) {
        if(someObject.hasOwnProperty(key) && key != 'undesiredkey') {
                copyOfObject[key] = someObject[key];
        }
}

Cái này thì sao? Tôi không bao giờ tìm thấy cái này xung quanh nhưng tôi chỉ cố gắng loại trừ một hoặc nhiều thuộc tính mà không cần tạo thêm một đối tượng. Điều này dường như để thực hiện công việc nhưng có một số tác dụng phụ tôi không thể nhìn thấy. Để chắc chắn là không dễ đọc.

const postData = {
   token: 'secret-token',
   publicKey: 'public is safe',
   somethingElse: true,
};

const a = {
   ...(({token, ...rest} = postData) => (rest))(),
}

/**
a: {
   publicKey: 'public is safe',
   somethingElse: true,
}
*/

Tôi đã hoàn thành nó theo cách này, như một ví dụ từ bộ giảm tốc Redux của tôi:

 const clone = { ...state };
 delete clone[action.id];
 return clone;

Nói cách khác:

const clone = { ...originalObject } // note: original object is not altered
delete clone[unwantedKey]           // or use clone.unwantedKey or any other applicable syntax
return clone                        // the original object without the unwanted key

Gần đây tôi đã làm điều này rất đơn giản:

const obj = {a: 1, b: 2, ..., z:26};

chỉ sử dụng toán tử trải để phân tách thuộc tính không mong muốn:

const {b, ...rest} = obj;

... Và object.assign chỉ lấy phần 'phần còn lại':

const newObj = Object.assign({}, {...rest});

const x = {obj1: 1, pass: 2, obj2: 3, obj3:26};

const objectWithoutKey = (object, key) => {
  const {[key]: deletedKey, ...otherKeys} = object;
  return otherKeys;
}

console.log(objectWithoutKey(x, 'pass'));