Es6 Structuring Assignment?

The new destructuring assignment features of ES6 are fairly well known now (live copy on Babel's REPL); in the case of variables that already exist: let a, b; // Ex

Solution 1:

The closest I've come up with is to use Object.assign and a temporary object (live copy):

let a = "a", b = "b";             // The variables
let obj = {c: "c"};               // The existing object
Object.assign(obj, {a, b});       //"Structuring" assignment, sort of
console.log(JSON.stringify(obj)); //"{"c":"c","a":"a","b":"b"}

It's fairly simple, but it's a function call and a temporary object.

---

Update:Bergi points out in a comment that there's a strawman proposal(link now dead) for a := operator that will do this, and one of their first use cases is indeed the use case that primarily lead me to this question: Constructors:

// From strawman proposal linked above, doesn't actually exist yet!classPoint {
   constructor(x,y) {
      this := {x,y}  //define and initialize x and y properties of new object//   ^^
   }
}

So given that strawman exists, I suspect for now the assign is going to be the best I can do in ES6. The old wiki with the strawman is offline, and there's nothing about := in the proposals repo.

Solution 2:

Some experimental stuff, building on top of your answer.

If you wanted to get a little cheeky you could emulate the assignment portion of it with a setter. Definitely not practical, but it's a fun way to see what the behaviour might look like on the outside, if maybe you could empty assign o[] =. (Babel)

let a = '1', b = '2';
let o = {z: '26'};

Object.defineProperty(Object.prototype, '', {
  set: function (o) {
    Object.assign(this, o);
  }, configurable: true
});

o[''] = {a, b};

Same issues you face with your answer, actually more, but some food for thought.