Nie, destrukcja nie obsługuje wyrażeń członkowskich w stenogramach, a jedynie zwykłe nazwy właściwości w bieżącym czasie. Były rozmowy na temat tego typu na temat esdiscuss, ale żadne propozycje nie trafią do ES6.

Możesz użyć Object.assign jednak-jeśli nie potrzebujesz wszystkich własnych właściwości, nadal możesz zrobić

var foo = …,
    oof = {};
{
    let {x, y} = foo;
    Object.assign(oof, {x, y})
}

IMO jest to najprostszy sposób, aby osiągnąć to, czego szukasz:

let { prop1, prop2, prop3 } = someObject;
let data = { prop1, prop2, prop3 };

  // data === { prop1: someObject.prop1, ... }

Zasadniczo, destrukcja do zmiennych, a następnie użyj skrótu inicjującego, aby utworzyć nowy obiekt. No need for Object.assign

let { prop1, prop2, prop3 } = someObject;
let data = Object.assign(otherObject, { prop1, prop2, prop3 });
    // Makes a new copy, or...
Object.assign(otherObject, { prop1, prop2, prop3 });
    // Merges into otherObject

Kolejny, prawdopodobnie czystszy, sposób na napisanie tego jest:

let { prop1, prop2, prop3 } = someObject;
let newObject = { prop1, prop2, prop3 };

// Merges your selected props into otherObject
Object.assign(otherObject, newObject);

Używam tego do POST żądań, gdzie potrzebuję tylko kilku dyskretnych danych. Ale Zgadzam się, że powinien być jeden liner do tego.

Poza Object.assignistnieje składnia obiekt spread, która jest propozycją etapu 2 dla ECMAScript.

var foo = {
  x: "bar",
  y: "baz"
}

var oof = { z: "z" }

oof =  {...oof, ...foo }

console.log(oof)

/* result 
{
  "x": "bar",
  "y": "baz",
  "z": "z"
}
*/

Ale aby skorzystać z tej funkcji musisz użyć wtyczki stage-2 lub transform-object-rest-spread dla babel. Oto demo na babel z stage-2

Babeljs plugin

Jeśli używasz BabelJS możesz teraz aktywować moją wtyczkę babel-plugin-transform-object-from-destructuring (zobacz pakiet npm dla instalacji i użytkowania).

Miałem ten sam problem opisany w tym wątku i dla mnie było to bardzo wyczerpujące, gdy tworzysz obiekt z destrukcyjnego wyrażenia, zwłaszcza gdy musisz zmienić nazwę, dodać lub usunąć właściwość. Dzięki tej wtyczce utrzymanie takich scenariuszy staje się znacznie łatwiejsze.

Obiekt przykład

let myObject = {
  test1: "stringTest1",
  test2: "stringTest2",
  test3: "stringTest3"
};
let { test1, test3 } = myObject,
  myTest = { test1, test3 };

Można zapisać jako:

let myTest = { test1, test3 } = myObject;

Przykład tablicy

let myArray = ["stringTest1", "stringTest2", "stringTest3"];
let [ test1, , test3 ] = myArray,
  myTest = [ test1, test3 ];

Można zapisać jako:

let myTest = [ test1, , test3 ] = myArray;

To całkowicie możliwe. Tylko nie w jednym oświadczeniu.

var foo = {
    x: "bar",
    y: "baz"
};
var oof = {};
({x: oof.x, y: oof.y} = foo); // {x: "bar", y: "baz"}

(zwróć uwagę na nawias wokół Oświadczenia.) Pamiętaj jednak, że czytelność jest ważniejsza niż kodowanie :).

Źródło: http://exploringjs.com/es6/ch_destructuring.html#sec_assignment-targets

Możesz po prostu użyć restrukturyzacji w ten sposób:

const foo = {x:"a", y:"b"};
const {...oof} = foo; // {x:"a", y:"b"} 

Lub połącz oba obiekty, jeśli oof ma wartości:

const foo = {x:"a", y:"b"};
let oof = {z:"c"}
oof = Object.assign({}, oof, foo)

Suche

var a = {a1:1, a2: 2, a3: 3};
var b = {b1:1, b2: 2, b3: 3};

const newVar = (() => ({a1, a2, b1, b2})).bind({...a, ...b});
const val = newVar();
console.log({...val});
// print: Object { a1: 1, a2: 2, b1: 1, b2: 2 }

Lub

console.log({...(() => ({a1, a2, b1, b2})).bind({...a, ...b})()});

To działa w chrome 53.0.2785.89

let foo = {
  x: "bar",
  y: "baz"
};

let oof = {x, y} = foo;

console.log(`oof: ${JSON.stringify(oof)});

//prints
oof: {
  "x": "bar",
  "y": "baz"
}

Wymyśliłem taką metodę:

exports.pick = function pick(src, props, dest={}) {
    return Object.keys(props).reduce((d,p) => {
        if(typeof props[p] === 'string') {
            d[props[p]] = src[p];
        } else if(props[p]) {
            d[p] = src[p];
        }
        return d;
    },dest);
};

Które możesz użyć Tak:

let cbEvents = util.pick(this.props.events, {onFocus:1,onBlur:1,onCheck:'onChange'});
let wrapEvents = util.pick(this.props.events, {onMouseEnter:1,onMouseLeave:1});

Czyli możesz wybrać, które właściwości chcesz i umieścić je w nowym obiekcie. W przeciwieństwie do _.pick możesz również zmienić ich nazwy w tym samym czasie.

Jeśli chcesz skopiować właściwości na istniejący obiekt, Ustaw arg dest.

To trochę oszustwo, ale możesz zrobić coś takiego...

const originalObject = {
  hello: 'nurse',
  meaningOfLife: 42,
  your: 'mom',
};

const partialObject = (({ hello, your }) => {
  return { hello, your };
})(originalObject);

console.log(partialObject); // ​​​​​{ hello: 'nurse', your: 'mom' }​​​​​

const partialObject = {
  hello: originalObject.hello,
  your: originalObject.your,
};

Kolejna zupełnie inna trasa, która obejmuje mucking z prototypem (Uwaga teraz...):

if (!Object.prototype.pluck) {
  Object.prototype.pluck = function(...props) {
    return props.reduce((destObj, prop) => {
      destObj[prop] = this[prop];

      return destObj;
    }, {});
  }
}

const originalObject = {
  hello: 'nurse',
  meaningOfLife: 42,
  your: 'mom',
};

const partialObject2 = originalObject.pluck('hello', 'your');

console.log(partialObject2); // { hello: 'nurse', your: 'mom' }

Możesz zwrócić zniszczony obiekt za pomocą funkcji Strzałki i użyć obiektu.assign (), aby przypisać go do zmiennej.

const foo = {
  x: "bar",
  y: "baz"
}

const oof = Object.assign({}, () => ({ x, y } = foo));

Jest to najbardziej czytelne i najkrótsze rozwiązanie, jakie mogłem wymyślić:

let props = { 
  isValidDate: 'yes',
  badProp: 'no!',
};

let { isValidDate } = props;
let newProps = { isValidDate };

console.log(newProps);

Wyświetli { isValidDate: 'yes' }

Byłoby miło, gdyby pewnego dnia mógł powiedzieć coś takiego let newProps = ({ isValidDate } = props), ale niestety nie jest to coś, co obsługuje ES6.

Nie jest to piękny sposób, nie polecam go, ale jest to możliwe w ten sposób, tylko dla wiedzy.

const myObject = {
  name: 'foo',
  surname: 'bar',
  year: 2018
};

const newObject = ['name', 'surname'].reduce(
  (prev, curr) => (prev[curr] = myObject[curr], prev),
  {},
);

console.log(JSON.stringify(newObject)); // {"name":"foo","surname":"bar"}