たとえば、2つのオブジェクトがあるとします。

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

そして

var oof = {}

そして、xとyの値をfooからoofに転送したかったのです。es6構造化構文を使用してそれを行う方法はありますか？

おそらく次のようなもの：

oof{x,y} = foo

醜いと少し繰り返しながら、行うことができます

({x: oof.x, y: oof.y} = foo);

これは、fooオブジェクトの2つの値を読み取り、それらをoofオブジェクトのそれぞれの場所に書き込みます。

個人的にはまだ読んだほうがいい

oof.x = foo.x;
oof.y = foo.y;

または

['x', 'y'].forEach(prop => oof[prop] = foo[prop]);

でも。

いいえ、構造化では省略表現のメンバー式はサポートされていませんが、現時点ではプレーンプロパティ名のみがサポートされています。esdiscussでそのようなことについての話がありましたが、提案はES6にそれを作ることはありません。

Object.assignただし、使用できる場合があります。独自のプロパティがすべて必要ない場合でも、引き続き使用できます。

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

IMOこれはあなたが探しているものを達成する最も簡単な方法です：

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

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

基本的には、変数に分解し、初期化子の省略形を使用して新しいオブジェクトを作成します。の必要はありませんObject.assign

とにかく、これが最も読みやすい方法だと思います。これによりsomeObject、必要な小道具を正確に選択できます。プロップをマージしたい既存のオブジェクトがある場合は、次のようにします。

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

それを書くもう一つの、間違いなくよりクリーンな方法は：

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

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

私はこれをPOST数個の個別のデータだけが必要なリクエストによく使用します。しかし、私はこれを行うための1つのライナーがあるべきであることに同意します。

編集：PS- 私は最近、複雑なオブジェクトからネストされた値を引き出すために、最初のステップで超構造化を使用できることを学びました！例えば...

let { prop1, 
      prop2: { somethingDeeper }, 
      prop3: { 
         nested1: {
            nested2
         } 
      } = someObject;
let data = { prop1, somethingDeeper, nested2 };

さらに、新しいオブジェクトを作成するときにObject.assignの代わりにspread演算子を使用できます。

const { prop1, prop2, prop3 } = someObject;
let finalObject = {...otherObject, prop1, prop2, prop3 };

または...

const { prop1, prop2, prop3 } = someObject;
const intermediateObject = { prop1, prop2, prop3 };
const finalObject = {...otherObject, ...intermediateObject };

他よりもObject.assignそこにあるオブジェクトのスプレッド構文はECMAScriptのためのステージ2の提案です。

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

var oof = { z: "z" }

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

console.log(oof)

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

ただし、この機能を使用するには、Babelのプラグインstage-2またはtransform-object-rest-spreadプラグインを使用する必要があります。ここにバベルのデモがありますstage-2

BabelJSプラグイン

BabelJSを使用している場合は、プラグインをアクティブ化できますbabel-plugin-transform-object-from-destructuring（インストールと使用方法については、npmパッケージを参照してください））。

このスレッドで説明したのと同じ問題があり、構造化式からオブジェクトを作成するとき、特にプロパティの名前を変更、追加、または削除する必要があるときは、非常に疲れました。このプラグインを使用すると、このようなシナリオを維持することがはるかに簡単になります。

オブジェクトの例

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

次のように書くことができます：

let myTest = { test1, test3 } = myObject;

配列の例

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

次のように書くことができます：

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

それは完全に可能です。1つのステートメントではありません。

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

（ステートメントの前後の括弧に注意してください。）ただし、コードゴルフよりも読みやすさが重要です:)

出典：http : //exploringjs.com/es6/ch_destructuring.html#sec_assignment-targets

次のように再構築を使用できます。

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

または、oofに値がある場合は両方のオブジェクトをマージします。

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

アロー関数で非構造化オブジェクトを返し、Object.assign（）を使用してそれを変数に割り当てることができます。

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

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

ドライ

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 }

または

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

別のオブジェクト属性に直接割り当てるオブジェクトを破棄できます。

作業例：

let user = {};
[user.name, user.username] = "Stack Overflow".split(' ');
document.write(`
1st attr: ${user.name} <br /> 
2nd attr: ${user.username}`);

キャッチしたいオブジェクト属性と同じ名前の変数を使用して、デストラクタを操作できます。これにより、次の操作を行う必要がなくなります。

let user = { name: 'Mike' }
let { name: name } = user;

この方法を使用します。

let user = { name: 'Mike' }
let { name } = user;

同じ方法で、同じ名前のオブジェクト構造に新しい値を設定できます。

この実用的な例を見てください：

// The object to be destructed
let options = {
  title: "Menu",
  width: 100,
  height: 200
};

// Destructing
let {width: w, height: h, title} = options;

// Feedback
document.write(title + "<br />");  // Menu
document.write(w + "<br />");      // 100
document.write(h);                 // 200

これは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"
}

私はこの方法を思いつきました：

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

次のように使用できます：

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

つまり、必要なプロパティを選択して、新しいオブジェクトに配置できます。_.pickあなたとは異なり、それらの名前を同時に変更することもできます。

プロップを既存のオブジェクトにコピーする場合は、dest引数を設定するだけです。

これは一種の不正行為ですが、次のようなことができます...

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

プロトタイプをいじくることを含む別の完全に異なるルート（今は注意してください...）：

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

これは私が思いつくことができる最も読みやすく、最も短い解決策です：

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

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

console.log(newProps);

出力されます { isValidDate: 'yes' }

いつの日かこのようなことを言うことができればいいのですlet newProps = ({ isValidDate } = props)が、残念ながらそれはES6がサポートするものではありません。

それは美しい方法ではありませんし、私もお勧めしませんが、知識のためだけに、この方法は可能です。

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

JSONクラスのメソッドを使用して、次のように実現できます。

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

const oof = JSON.parse(JSON.stringify(foo, ['x','y']));
// output -> {x: "bar", y: "baz"}

結果のオブジェクトに追加する必要があるプロパティをstringify、配列形式で機能する2番目の引数として渡します。

JSON.stringifyのMDNドキュメント