Wie kann ich ein JavaScript-Objekt bis auf einen Schlüssel klonen?

Ich habe ein flaches JS-Objekt:

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

Ich möchte das Objekt bis auf ein Element klonen:

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

Was ist der einfachste Weg, dies zu tun (wenn möglich lieber es6 / 7 zu verwenden)?

Wenn Sie Babel verwenden , können Sie die folgende Syntax verwenden, um die Eigenschaft b von x in die Variable b zu kopieren und die restlichen Eigenschaften in die Variable y zu kopieren :

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

und es wird umgesetzt in:

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

oder wenn Sie akzeptieren, dass Eigentum undefiniert ist:

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

Um Ilya Palkins Antwort zu ergänzen: Sie können sogar Schlüssel dynamisch entfernen:

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 in Babel REPL

Quelle:

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

Für diejenigen, die ES6 nicht verwenden können, können Sie lodashoder verwenden underscore.

_.omit(x, 'b')

Oder ramda.

R.omit('b', x)

Ich benutze diesen ESNext One Liner

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

Wenn Sie eine Allzweckfunktion benötigen:

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)

Sie können eine einfache Hilfsfunktion dafür schreiben. Lodash hat eine ähnliche Funktion mit dem gleichen Namen: weglassen

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}

Beachten Sie außerdem, dass es schneller als Object.assign ist und löschen Sie dann: http://jsperf.com/omit-key

Vielleicht so etwas:

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

Ist das gut genug Oder kann man nicht ckopieren?

Verwenden der Objektzerstörung

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, es scheint, als würden Sie auf Referenzprobleme stoßen, wenn Sie versuchen, ein Objekt zu kopieren und dann eine Eigenschaft zu löschen. Irgendwo müssen Sie primitive Variablen zuweisen, damit Javascript einen neuen Wert erzeugt.

Einfacher Trick (kann schrecklich sein), den ich benutzt habe, war dieser

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

Hier ist eine Option zum Weglassen dynamischer Schlüssel, von denen ich glaube, dass sie noch nicht erwähnt wurden:

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

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

removeMewird als voreingenommen removedKeyund ignoriert. newObjwird { 2: 2, 3: 3, 4: 4 }. Beachten Sie, dass der entfernte Schlüssel nicht vorhanden ist und der Wert nicht nur auf gesetzt wurde undefined.

EINFACHSTER WEG

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

Lodash weglassen

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

Sie können dazu auch den Spread-Operator verwenden

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

Die oben genannten Lösungen mit Strukturierung leiden unter der Tatsache, dass Sie eine verwendete Variable haben, was zu Beschwerden von ESLint führen kann, wenn Sie diese verwenden.

Also hier sind meine Lösungen:

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

Auf den meisten Plattformen (außer IE, sofern nicht Babel verwendet wird) können Sie außerdem Folgendes tun:

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

Wie wäre es damit:

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

Wenn Sie mit einer großen Variablen arbeiten, möchten Sie sie nicht kopieren und dann löschen, da dies ineffizient wäre.

Eine einfache for-Schleife mit einer hasOwnProperty-Prüfung sollte funktionieren und ist viel anpassungsfähiger für zukünftige Anforderungen:

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

Was ist damit? Ich habe dieses Muster nie gefunden, aber ich habe nur versucht, eine oder mehrere Eigenschaften auszuschließen, ohne ein zusätzliches Objekt erstellen zu müssen. Dies scheint den Job zu erledigen, aber es gibt einige Nebenwirkungen, die ich nicht sehen kann. Sicher ist nicht sehr lesbar.

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

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

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

Ich habe es so gemacht, als Beispiel von meinem Redux-Reduzierer:

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

Mit anderen Worten:

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

Ich habe es kürzlich ganz einfach gemacht:

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

Verwenden Sie einfach den Spread-Operator , um die unerwünschte Eigenschaft zu trennen:

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

... und object.assign , um nur den ' Rest'-Teil zu übernehmen:

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