Bir anahtar dışında bir JavaScript nesnesini nasıl klonlayabilirim?

Düz bir JS nesnesi var:

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

Bir öğe dışında nesneyi klonlamak istiyorum:

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

Bunu yapmanın en kolay yolu nedir (mümkünse es6 / 7 kullanmayı tercih etmek)?

Eğer kullanırsanız Babel size aşağıdaki sözdizimini kullanabilirsiniz değişken y içine özelliklerinin dinlenme kopya ardından değişken b içine x mülk b kopyalayıp :

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

ve şu adrese aktarılacaktır :

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

veya tanımsız olarak mülk kabul ediyorsanız:

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

Ilya Palkin'in cevabına eklemek için: anahtarları dinamik olarak bile kaldırabilirsiniz:

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

Babel REPL'de demo

Kaynak:

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

ES6'yı kullanamayanlar için lodashveya kullanabilirsiniz underscore.

_.omit(x, 'b')

Veya ramda.

R.omit('b', x)

Bu ESNext bir astarını kullanıyorum

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

Genel amaçlı bir işleve ihtiyacınız varsa:

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)

Bunun için basit bir yardımcı işlev yazabilirsiniz. Lodash aynı isimde benzer bir işlevi vardır: ihmali

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}

Ayrıca, Object.assign'dan daha hızlı olduğuna dikkat edin ve silin: http://jsperf.com/omit-key

Belki böyle bir şey:

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

Bu yeterince iyi mi? Yoksa cgerçekten kopyalanamıyor mu?

Nesne Yıkmayı Kullanma

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}

Bir nesneyi kopyalayıp daha sonra bir mülkü silmeye çalışırken başvuru sorunlarına başvurduğunuz anlaşılıyor. Bir yerde javascript yeni bir değer yaratmak için ilkel değişkenler atamanız gerekir.

Basit hile (korkunç olabilir)

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

İşte henüz belirtilmediğine inandığım dinamik anahtarları atlamak için bir seçenek:

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

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

removeMeolarak diğer ad olarak adlandırılır removedKeyve yoksayılır. newObjolur { 2: 2, 3: 3, 4: 4 }. Kaldırılan anahtarın mevcut olmadığını, değerin yalnızca olarak ayarlanmadığını unutmayın undefined.

EN KOLAY YOL

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

Lodash omit

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

Bunu yapmak için forma operatörünü de kullanabilirsiniz

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

Yapılandırmayı kullanan yukarıdaki çözümler, kullanılmış bir değişkeninizin olması gerçeğinden muzdariptir, bu da ESLint'den şikayet ederseniz, bunu kullanırsanız.

İşte benim çözümlerim:

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

Çoğu platformda (Babel kullanmadığı sürece IE hariç) şunları da yapabilirsiniz:

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

Buna ne dersin:

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

Büyük bir değişkenle uğraşıyorsanız, onu kopyalamak ve ardından silmek istemezsiniz, çünkü bu verimsiz olacaktır.

HasOwnProperty denetimine sahip basit bir for-loop çalışmalıdır ve gelecekteki ihtiyaçlara çok daha uyumludur:

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

Peki buna ne dersin? Bu pıtırtı asla bulamadım ama sadece bir veya daha fazla özelliği ekstra bir nesne oluşturmaya gerek kalmadan hariç tutmaya çalışıyordum. Bu işi yapıyor gibi görünüyor ama göremediğim bazı yan etkiler var. Elbette çok okunabilir değil.

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 redüktörünüzden bir örnek olarak bu şekilde başardım:

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

Diğer bir deyişle:

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

Son zamanlarda bunu çok basit bir şekilde yaptım:

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

sadece istenmeyen özelliği ayırmak için forma operatörünü kullanarak :

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

... ve object.assign 'sadece' dinlenme 'kısmını almak için:

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