Comment puis-je cloner un objet JavaScript à l'exception d'une clé?

J'ai un objet JS plat:

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

Je veux cloner l'objet à l'exception d'un élément:

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

Quelle est la façon la plus simple de le faire (préférant utiliser es6 / 7 si possible)?

Si vous utilisez Babel, vous pouvez utiliser la syntaxe suivante pour copier la propriété b de x dans la variable b, puis copier le reste des propriétés dans la variable y :

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

et il sera transposé en:

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

ou si vous acceptez que la propriété ne soit pas définie:

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

Pour ajouter à la réponse d'Ilya Palkin: vous pouvez même supprimer dynamiquement des clés:

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

Démo dans Babel REPL

La source:

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

Pour ceux qui ne peuvent pas utiliser ES6, vous pouvez utiliser lodashou underscore.

_.omit(x, 'b')

Ou ramda.

R.omit('b', x)

J'utilise cette doublure ESNext one

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

Si vous avez besoin d'une fonction à usage général:

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)

Vous pouvez lui écrire une fonction d'assistance simple. Lodash a une fonction similaire avec le même nom: omettre

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}

Notez également qu'il est plus rapide que Object.assign et supprimez ensuite: http://jsperf.com/omit-key

Peut-être quelque chose comme ça:

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

Est-ce assez bon? Ou ne pouvez-vous pas créellement les copier?

Utilisation de la déstructuration d'objets

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}

Hé, vous semblez rencontrer des problèmes lorsque vous essayez de copier un objet, puis de supprimer une propriété. Quelque part, vous devez attribuer des variables primitives afin que javascript crée une nouvelle valeur.

Truc simple (peut-être horrible) que j'ai utilisé était-ce

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

Voici une option pour omettre les clés dynamiques qui, je crois, n'a pas encore été mentionnée:

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

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

removeMeest aliasé removedKeyet ignoré. newObjdevient { 2: 2, 3: 3, 4: 4 }. Notez que la clé supprimée n'existe pas, la valeur n'était pas simplement définie sur undefined.

PLUS FACILE

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

Lodash omettent

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

Vous pouvez également utiliser l'opérateur d'étalement pour ce faire

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

Les solutions ci-dessus utilisant la structuration souffrent du fait que vous avez une variable utilisée, ce qui peut provoquer des plaintes d'ESLint si vous l'utilisez.

Voici donc mes solutions:

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

Sur la plupart des plateformes (sauf IE sauf si vous utilisez Babel), vous pouvez également faire:

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

Que dis-tu de ça:

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

Si vous avez affaire à une énorme variable, vous ne voulez pas la copier puis la supprimer, car cela serait inefficace.

Une simple boucle for avec un contrôle hasOwnProperty devrait fonctionner, et elle est beaucoup plus adaptable aux besoins futurs:

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

Et ça? Je n'ai jamais trouvé ce bagout mais j'essayais simplement d'exclure une ou plusieurs propriétés sans avoir besoin de créer un objet supplémentaire. Cela semble faire l'affaire, mais il y a des effets secondaires que je ne peux pas voir. Pour sûr, ce n'est pas très lisible.

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

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

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

Je l'ai fait de cette façon, comme un exemple de mon réducteur Redux:

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

En d'autres termes:

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

Je l'ai fait récemment de cette manière très simple:

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

en utilisant simplement l' opérateur spread pour séparer la propriété indésirable:

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

... et object.assign pour ne prendre que la partie "reste":

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