I have a flat JS object:
{a: 1, b: 2, c: 3, ..., z:26}
I want to clone the object except for one element:
{a: 1, c: 3, ..., z:26}
What's the easiest way to do this (preferring to use es6/7 if possible)?
This question is related to
javascript
ecmascript-6
ecmascript-harmony
ecmascript-7
You can write a simple helper function for it. Lodash has a similar function with the same name: 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}
Also, note that it is faster than Object.assign and delete then: http://jsperf.com/omit-key
Here are my two cents, on Typescript, slightly derived from @Paul's answer and using reduce instead.
function objectWithoutKey(object: object, keys: string[]) {
return keys.reduce((previousValue, currentValue) => {
// @ts-ignore
const {[currentValue]: undefined, ...clean} = previousValue;
return clean
}, object)
}
// usage
console.log(objectWithoutKey({a: 1, b: 2, c: 3}, ['a', 'b']))
I had an object
that I wanted to remove after utilizing its method. This is what worked for me.
/* Sample data */
let items = [
{
name: 'John',
doc: {
set: async (item) => {/*...sets docs on remote server*/}
}
},{
name: 'Mary',
doc: {
set: async (item) => {/*...sets docs on remote server*/}
}
},{
name: 'Jack',
doc: {
set: async (item) => {/*...sets docs on remote server*/}
}
}
]
/* mapping to promises */
const promises = items.map(({doc, ...item}) => doc.set(item));
// utilized doc and utilized `rest` of the items :)
Good Luck :)
What about this? I never found this patter around but I was just trying to exclude one or more properties without the need of creating an extra object. This seems to do the job but there are some side effects I'm not able to see. For sure is not very readable.
const postData = {
token: 'secret-token',
publicKey: 'public is safe',
somethingElse: true,
};
const a = {
...(({token, ...rest} = postData) => (rest))(),
}
/**
a: {
publicKey: 'public is safe',
somethingElse: true,
}
*/
You also can use spread operator to do this
const source = { a: 1, b: 2, c: 3, z: 26 }
const copy = { ...source, ...{ b: undefined } } // { a: 1, c: 3, z: 26 }
For those who can't use ES6, you can use lodash
or underscore
.
_.omit(x, 'b')
Or ramda
.
R.omit('b', x)
If you're dealing with a huge variable, you don't want to copy it and then delete it, as this would be inefficient.
A simple for-loop with a hasOwnProperty check should work, and it is much more adaptable to future needs :
for(var key in someObject) {
if(someObject.hasOwnProperty(key) && key != 'undesiredkey') {
copyOfObject[key] = someObject[key];
}
}
Maybe something like this:
var copy = Object.assign({}, {a: 1, b: 2, c: 3})
delete copy.c;
Is this good enough? Or can't c
actually get copied?
I use this ESNext one liner
const obj = { a: 1, b: 2, c: 3, d: 4 }_x000D_
const clone = (({ b, c, ...o }) => o)(obj) // remove b and c_x000D_
console.log(clone)
_x000D_
If you need a general purpose function :
function omit(obj, props) {_x000D_
props = props instanceof Array ? props : [props]_x000D_
return eval(`(({${props.join(',')}, ...o}) => o)(obj)`)_x000D_
}_x000D_
_x000D_
// usage_x000D_
const obj = { a: 1, b: 2, c: 3, d: 4 }_x000D_
const clone = omit(obj, ['b', 'c'])_x000D_
console.log(clone)
_x000D_
I accomplished it this way, as an example from my Redux reducer:
const clone = { ...state };
delete clone[action.id];
return clone;
In other words:
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
How about this:
let clone = Object.assign({}, value);
delete clone.unwantedKey;
Using Object Destructuring
const omit = (prop, { [prop]: _, ...rest }) => rest;_x000D_
const obj = { a: 1, b: 2, c: 3 };_x000D_
const objWithoutA = omit('a', obj);_x000D_
console.log(objWithoutA); // {b: 2, c: 3}
_x000D_
To add to Ilya Palkin's answer: you can even dynamically remove keys:
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};
Source:
Here's an option for omitting dynamic keys that I believe has not been mentioned yet:
const obj = { 1: 1, 2: 2, 3: 3, 4: 4 };
const removeMe = 1;
const { [removeMe]: removedKey, ...newObj } = obj;
removeMe
is aliased as removedKey
and ignored. newObj
becomes { 2: 2, 3: 3, 4: 4 }
. Note that the removed key does not exist, the value was not just set to undefined
.
Lodash omit
let source = //{a: 1, b: 2, c: 3, ..., z:26}
let copySansProperty = _.omit(source, 'b');
// {a: 1, c: 3, ..., z:26}
I have one object named: options with some keys
let options = {
userDn: 'somePropertyValue',
username: 'someValue',
userSearchBase: 'someValue',
usernameAttribute: 'uid',
userPassword: 'someValue'
}
I want to log all object excelp userPassword Property because Im testing something, I am using this code:
console.log(Object.keys(options).map(x => x + ': ' + (x === "userPassword" ? '---' : options[x])));
If you want to make it dynamic, just make a function and instead of explicitly putting userPassword you can place the value of the property you want to exclude
var clone = Object.assign({}, {a: 1, b: 2, c: 3});
delete clone.b;
or if you accept property to be undefined:
var clone = Object.assign({}, {a: 1, b: 2, c: 3}, {b: undefined});
Hey seems like you run in to reference issues when you're trying to copy an object then deleting a property. Somewhere you have to assign primitive variables so javascript makes a new value.
Simple trick (may be horrendous) I used was this
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"}
I don't know exactly what you want to use this for, so I'm not sure if this would work for you, but I just did the following and it worked for my use case:
const newObj ={...obj, [key]: undefined}
The solutions above using structuring do suffer from the fact that you have an used variable, which might cause complaints from ESLint if you're using that.
So here are my solutions:
const src = { a: 1, b: 2 }
const result = Object.keys(src)
.reduce((acc, k) => k === 'b' ? acc : { ...acc, [k]: src[k] }, {})
On most platforms (except IE unless using Babel), you could also do:
const src = { a: 1, b: 2 }
const result = Object.fromEntries(
Object.entries(src).filter(k => k !== 'b'))
I recently did it this very simple way:
const obj = {a: 1, b: 2, ..., z:26};
just using spread operator to separate the unwanted property:
const {b, ...rest} = obj;
...and object.assign to take only the 'rest' part:
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'));
Source: Stackoverflow.com