Jak sklonować obiekt JavaScript z wyjątkiem jednego klucza?

Mam płaski obiekt JS:

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

Chcę sklonować obiekt z wyjątkiem jednego elementu:

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

Jaki jest najłatwiejszy sposób na zrobienie tego (wolę używać ES6 / 7, jeśli to możliwe)?

Jeśli używasz Babel , możesz użyć następującej składni, aby skopiować właściwość bz x do zmiennej b, a następnie skopiować pozostałe właściwości do zmiennej y :

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

i zostanie przełożony na:

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

lub jeśli akceptujesz własność jako niezdefiniowaną:

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

Aby dodać do odpowiedzi Ilyi Palkin: możesz nawet dynamicznie usuwać klucze:

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

Demo w Babel REPL

Źródło:

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

Dla tych, którzy nie mogą korzystać z ES6, możesz użyć lodashlub underscore.

_.omit(x, 'b')

Lub ramda.

R.omit('b', x)

Używam tej wkładki 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)

Jeśli potrzebujesz funkcji ogólnego przeznaczenia:

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)

Możesz napisać dla niego prostą funkcję pomocniczą. Lodash ma podobną funkcję o tej samej nazwie: pomiń

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}

Pamiętaj też, że jest szybszy niż Object.assign, a następnie usuń: http://jsperf.com/omit-key

Może coś takiego:

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

Czy to wystarczy? A może nie można cgo skopiować?

Korzystanie z destrukcji obiektów

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}

Hej, wygląda na to, że napotykasz problemy, gdy próbujesz skopiować obiekt, a następnie usunąć właściwość. Gdzieś trzeba przypisać prymitywne zmienne, aby javascript tworzył nową wartość.

To była prosta sztuczka (może być przerażająca)

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

Oto opcja pominięcia kluczy dynamicznych, które moim zdaniem nie zostały jeszcze wspomniane:

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

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

removeMejest aliasowany removedKeyi ignorowany. newObjstaje się { 2: 2, 3: 3, 4: 4 }. Zauważ, że usunięty klucz nie istnieje, wartość nie została tylko ustawiona na undefined.

NAJPROSTSZY SPOSÓB

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

Lodash pomiń

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

W tym celu możesz również użyć operatora rozprzestrzeniania

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

Powyższe rozwiązania wykorzystujące strukturalizację cierpią na to, że masz używaną zmienną, co może powodować skargi ze strony ESLint, jeśli z niej korzystasz.

Oto moje rozwiązania:

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

Na większości platform (oprócz IE, chyba że używasz Babel), możesz także:

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

Co powiesz na to:

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

Jeśli masz do czynienia z dużą zmienną, nie chcesz jej kopiować, a następnie usuwać, ponieważ byłoby to nieefektywne.

Prosta pętla for z funkcją hasOwnProperty powinna działać i jest o wiele bardziej przystosowalna do przyszłych potrzeb:

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

A co z tym? Nigdy nie znalazłem tego tupotu, ale próbowałem po prostu wykluczyć jedną lub więcej właściwości bez potrzeby tworzenia dodatkowego obiektu. Wydaje się, że to działa, ale są pewne skutki uboczne, których nie jestem w stanie zobaczyć. Na pewno nie jest bardzo czytelny.

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

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

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

Dokonałem tego w ten sposób, jako przykład z mojego reduktora Redux:

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

Innymi słowy:

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

Ostatnio zrobiłem to w bardzo prosty sposób:

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

wystarczy użyć operatora rozkładania, aby oddzielić niepożądaną właściwość:

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

... i object.ignign, aby wziąć tylko część „odpoczynku”:

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