javascript - objetos - Clonar un objeto js excepto una clave

recorrer array de objetos javascript

Question

Tengo un objeto JS plano:

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

Quiero clonar el objeto excepto un elemento:

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

¿Cuál es la forma más fácil de hacer esto (prefiriendo usar es6 / 7 si es posible)?

Answer 1

¿Qué hay de esto? Nunca encontré este patrón, pero solo estaba tratando de excluir una o más propiedades sin la necesidad de crear un objeto adicional. Esto parece hacer el trabajo, pero hay algunos efectos secundarios que no puedo ver. Por supuesto, no es muy legible.

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

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

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

Answer 2

Esto también debería hacerlo; Estoy bastante seguro de que ''eliminar'' también funciona con matrices asociativas:

var copy = (obj, del)=>{
    delete obj.del;
    return obj;
}

Answer 3

Las soluciones anteriores que usan estructuración adolecen del hecho de que tiene una variable usada, lo que podría causar quejas de ESLint si está usando eso.

Así que aquí están mis soluciones:

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

En la mayoría de las plataformas (excepto IE a menos que use Babel), también puede hacer:

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

Answer 4

Lo logré de esta manera, como un ejemplo de mi reductor Redux:

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

En otras palabras:

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

Answer 5

Lodash omit

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

Answer 6

Oye, parece que te encuentras con problemas de referencia cuando intentas copiar un objeto y luego eliminar una propiedad. En algún lugar debe asignar variables primitivas para que javascript cree un nuevo valor.

Truco simple (puede ser horrible) que usé fue esto

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

Answer 7

Para agregar a la respuesta de Ilya Palkin: incluso puede eliminar claves dinámicamente:

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

Fuente:

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

Answer 8

Para aquellos que no pueden usar ES6, pueden usar lodash o underscore .

_.omit(x, ''b'')

O ramda .

R.omit(''b'', x)

Answer 9

Puede escribir una función auxiliar simple para ello. Lodash tiene una función similar con el mismo nombre: omit

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}

Además, tenga en cuenta que es más rápido que Object.assign y elimine luego: http://jsperf.com/omit-key

Answer 10

Recientemente lo hice de esta manera muy simple:

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

solo usando el operador spread para separar la propiedad no deseada:

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

... y object.assign para tomar solo la parte ''rest'':

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

Answer 11

Si se trata de una gran variable, no desea copiarla y luego eliminarla, ya que esto sería ineficiente.

Un bucle for simple con una comprobación hasOwnProperty debería funcionar, y es mucho más adaptable a las necesidades futuras:

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

Answer 12

Si usa Babel , puede usar la siguiente sintaxis para copiar la propiedad b de x en la variable b y luego copiar el resto de las propiedades en la variable y :

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

y se trasladará a:

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

Answer 13

Tal vez algo como esto:

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

¿Es esto lo suficientemente bueno? ¿O no se puede copiar realmente c ?

Answer 14

También puede usar el operador de propagación para hacer esto

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

Answer 15

Usando Desestructuración de Objetos

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}

Answer 16

Yo uso esta sintaxis ES6 de una sola línea,

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

Answer 17

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

o si acepta que la propiedad no esté definida:

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