하나의 키를 제외하고 JavaScript 객체를 어떻게 복제 할 수 있습니까?

플랫 JS 객체가 있습니다.

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

하나의 요소를 제외하고 객체를 복제하고 싶습니다.

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

가장 쉬운 방법은 무엇입니까 (가능한 경우 es6 / 7을 사용하는 것이 바람직 함)?

당신이 사용하는 경우 바벨을 당신은 다음 구문을 사용할 수있는 변수 Y에 속성의 휴식을 복사 한 후 변수 b에 X에서 속성 B를 복사 :

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

그리고 다음으로 번역 됩니다 :

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

또는 정의되지 않은 속성을 수락하는 경우 :

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

Ilya Palkin의 답변에 추가하려면 키를 동적으로 제거 할 수도 있습니다.

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

바벨 REPL 데모

출처:

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

ES6를 사용할 수없는 사람들은 lodash또는 을 사용할 수 있습니다 underscore.

_.omit(x, 'b')

또는 ramda.

R.omit('b', x)

나는이 ESNext 하나의 라이너를 사용

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

범용 기능이 필요한 경우 :

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)

간단한 도우미 함수를 작성할 수 있습니다. Lodash는 같은 이름을 가진 비슷한 기능을 가지고 있습니다 : 생략

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}

또한 Object.assign보다 빠르며 다음을 삭제하십시오. http://jsperf.com/omit-key

아마도 이런 식으로 뭔가 :

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

이것으로 충분합니까? 아니면 c실제로 복사 할 수 없습니까?

객체 파괴 사용

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}

객체를 복사하고 속성을 삭제하려고 할 때 문제를 참조하기 위해 실행되는 것처럼 보입니다. 어딘가에 기본 변수를 할당해야 자바 스크립트가 새로운 가치를 만듭니다.

내가 사용한 간단한 속임수 (끔찍할 수도 있습니다)

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

아직 언급하지 않은 것으로 보이는 동적 키를 생략하는 옵션은 다음과 같습니다.

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

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

removeMe로 별칭이 지정 removedKey되고 무시됩니다. newObj됩니다 { 2: 2, 3: 3, 4: 4 }. 제거 된 키는 존재하지 않으며 값은로 설정되지 않았습니다 undefined.

가장 쉬운 방법

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

로다 쉬 생략

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

스프레드 연산자를 사용하여이를 수행 할 수도 있습니다.

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

구조화를 사용하는 위의 솔루션은 변수를 사용했기 때문에 ESLint에서 불만을 일으킬 수 있다는 사실 때문에 어려움을 겪습니다.

여기 내 해결책이 있습니다.

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

대부분의 플랫폼 (Babel을 사용하지 않는 한 IE 제외)에서 다음을 수행 할 수도 있습니다.

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

이건 어때요:

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

거대한 변수를 다루는 경우 비효율적이므로 변수를 복사 한 다음 삭제하고 싶지 않습니다.

hasOwnProperty 검사가있는 간단한 for-loop가 작동해야하며 향후 요구에 훨씬 더 적합합니다.

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

이건 어때? 나는이 패턴을 찾지 못했지만 추가 객체를 만들 필요없이 하나 이상의 속성을 제외하려고했습니다. 이것은 일을하는 것처럼 보이지만 볼 수없는 부작용이 있습니다. 확실히 읽기 쉽지 않습니다.

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

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

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

내 Redux 감속기의 예와 같이이 방법으로 달성했습니다.

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

다시 말해:

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

나는 최근에 매우 간단한 방법으로 그것을했다 :

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

스프레드 연산자 를 사용 하여 원치 않는 속성을 분리하십시오.

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

... 및 'rest'부분 만 가져 오도록 object.assign :

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