是否可以在销毁另一个对象时分配一个对象（在销毁时使用默认值）

Question

My end goal is to be able to assign a new object using the spread operator from an object that is destructured while assigning default values (if they don't exist).

It looks like this may not be possible how I'd like it. Here's my expectations and attempts:

 //Expected beginning object const a1 = { key1: "test1", key2: "test2", }; //Expected end result const b1 = { key1: "test1", key2: "test2", key3: { nestedKey1: "nestedVal1", }, }; //Expected beginning object const a2 = { key1: "test1", key2: "test2", key3: { nestedKey1: "actualValue", } } //Expected end result const b2 = { key1: "test1", key2: "test2", key3: { nestedKey1: "actualValue", }, }; 

Snippet 1: Does not assign default values.

 const a = { key1: "test1", key2: "test2", } const {...b} = { key1, key2, key3: { nestedKey1: nestedKey1 = "nestedVal1", } = {}, key4 = 'someDefault' } = a console.log(b); // does not have key3, or key4 console.log(key4); //this exists as a const, key3 does not 

Snippet 2: Functional, but can become problematic if multiple levels of nesting are required.

 const a = { key1: "test1", key2: "test2", } let { key1, key2, key3: { nestedKey1: nestedKey1 = "nestedVal1", } = {}, } = a const key3 = a.key3 || {}; // is it possible to include this in the destructuring? Specifically in the destructuring which defines the default. const b = { key1, key2, key3: { ...key3, nestedKey1, } } console.log(b); 

Snippet 2 (showing that nested objects aren't overwritten)

 const a = { key1: "test1", key2: "test2", key3: { someOtherKey: "itWorks", } } let { key1, key2, key3: { nestedKey1: nestedKey1 = "nestedVal1", } = {}, } = a const key3 = a.key3 || {}; const b2 = { key1, key2, key3: { ...key3, nestedKey1, } } console.log(b2); 

Answer 1

Your confusion arises from the similarity of destructuring syntax to that of object declaration syntax.

This is object declaration:

const a = {
  key1: "test1",
  key2: "test2",
}

This is destructuring

const { key1, key2 } = a

console.log(key1)  // => test1
console.log(key2)  // => test2

Next, you need to remember that assignment operator = is right associative in JavaScript. So something like

let a = b = 1

means assign value 1 to b , then to a .

Next, if you spread all values into a single var, you're essentially doing a simple assignment with a fancy ES6 syntax. So:

const {...b} = a
// is same as
const b = a

Combining the above 3 effects, what you get is effectively a multiple assignment:

const {...b} = a  
const {key1, key2} = a

Multiple assignment can be confusing and there are linting rules to prevent such issues: https://eslint.org/docs/rules/no-multi-assign

So the answer to your question is simply, No! :)

It'd need at least 2 lines to do so - one to collect props with defaults while destructuring, and another to create the next object with those props.