Sicuramente ES6 + deve avere un modo per unire insieme due oggetti javascript, che cos’è?

Sono stufo di dover sempre scrivere codice come questo:

function shallowExtend(obj1,obj2){ var key; for ( key in obj2 ) { if ( obj2.hasOwnProperty(key) === false ) continue; obj1[key] = obj2[key] } } 

O se non voglio scrivere il codice da solo, implementare una libreria che lo faccia già. Sicuramente ES6 + sta venendo in soccorso su questo ci fornirà qualcosa come Object.prototype.extend(obj2...) o Object.extend(obj1,obj2...)

Quindi ES6 + fornisce tale funzionalità? Se non c’è già, allora è prevista una tale funzionalità? Se non pianificato, allora perché no?

Sarai in grado di eseguire una fusione / estensione / assegnazione superficiale in ES6 utilizzando Object.assign:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign

Sintassi:

Object.assign ( target , … fonti );

dove … fonti rappresenta l’object o gli oggetti sorgente.

Nota: non confondere … fonti nella definizione della syntax con un operatore di diffusione ES6.

Esempio:

 var obj1 = {name: 'Daisy', age: 30}; var obj2 = {name: 'Casey'}; Object.assign(obj1, obj2); console.log(obj1.name === 'Casey' && obj1.age === 30); // true 

È ansible utilizzare il resto dell’object / diffusione per questo:

 const merged = {...obj1, ...obj2} 

La proposta ECMAScript è attualmente in fase 3 e abilitata in Babel utilizzando il preset stage-3 .

So che questo è un po ‘un vecchio problema, ma la soluzione più semplice in ES2015 / ES6 è in realtà abbastanza semplice, usando Object.assign (),

Speriamo che questo aiuti, questo fa anche la fusione di DEEP :

 /** * Simple is object check. * @param item * @returns {boolean} */ export function isObject(item) { return (item && typeof item === 'object' && !Array.isArray(item) && item !== null); } /** * Deep merge two objects. * @param target * @param source */ export function mergeDeep(target, source) { if (isObject(target) && isObject(source)) { for (const key in source) { if (isObject(source[key])) { if (!target[key]) Object.assign(target, { [key]: {} }); mergeDeep(target[key], source[key]); } else { Object.assign(target, { [key]: source[key] }); } } } return target; } 

Esempio di utilizzo:

 mergeDeep(this, { a: { b: { c: 123 } } }); // or const merged = mergeDeep({a: 1}, { b : { c: { d: { e: 12345}}}}); console.dir(merged); // { a: 1, b: { c: { d: [Object] } } } 

L’aggiunta di Object.mixin è attualmente in fase di discussione per occuparsi del comportamento che stai richiedendo. https://mail.mozilla.org/pipermail/es-discuss/2012-December/027037.html

Anche se non è ancora nella bozza ES6, sembra che ci sia un sacco di supporto per questo, quindi penso che verrà presto visualizzato nelle bozze.

Forse il metodo ES5 Object.defineProperties farà il lavoro?

per esempio

 var a = {name:'fred'}; var b = {age: {value: 37, writeable: true}}; Object.defineProperties(a, b); alert(a.age); // 37 

Documentazione MDN: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/defineProperties

ES6

 Object.assign(o1,o2) ; Object.assign({},o1,o2) ; //safe inheritance var copy=Object.assign({},o1); // clone o1 //------Transform array of objects to one object--- var subjects_assess=[{maths:92},{phy:75},{sport:99}]; Object.assign(...subjects_assess); // {maths:92,phy:75,sport:99} 

ES7 o Babele

 {...o1,...o2} // inheritance var copy= {...o1};