Estoy cansado de tener que escribir siempre código como este:

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

O si no quiero escribir el código yo mismo, implemente una biblioteca que ya lo haga. Seguramente ES6 + vendrá al rescate en esto nos proporcionará algo así como un Object.prototype.extend(obj2...)oObject.extend(obj1,obj2...)

Entonces, ¿ES6 + proporciona esa funcionalidad? Si aún no está allí, ¿se planifica dicha funcionalidad? Si no está planeado, ¿por qué no?

Podrá hacer una fusión / extensión / asignación superficial en ES6 utilizando Object.assign:

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

Sintaxis:

Object.assign ( objetivo , fuentes );

donde ... fuentes representa los objetos fuente.

Ejemplo:

var obj1 = {name: 'Daisy', age: 30};
var obj2 = {name: 'Casey'};

Object.assign(obj1, obj2);

console.log(obj1.name === 'Casey' && obj1.age === 30);
// true

Puede usar la sintaxis de propagación de objetos para esto:

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

Para las matrices, el operador de propagación ya era parte de ES6 (ES2015), pero para los objetos se agregó a la especificación de lenguaje en ES9 (ES2018). Su propuesta fue habilitada por defecto en herramientas como Babel mucho antes de eso.

Sé que este es un problema un poco antiguo, pero la solución más fácil en ES2015 / ES6 es bastante simple, usando Object.assign (),

Esperemos que esto ayude, esto también hace una fusión PROFUNDA :

/**
 * 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;
}

Ejemplo de uso:

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

La adición de Object.mixinse está discutiendo actualmente para cuidar el comportamiento que está solicitando. https://mail.mozilla.org/pipermail/es-discuss/2012-December/027037.html

Aunque todavía no está en el borrador de ES6, parece que hay mucho apoyo para él, por lo que creo que aparecerá pronto en los borradores.

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 Babel

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

¿Quizás el Object.definePropertiesmétodo ES5 hará el trabajo?

p.ej

var a = {name:'fred'};
var b = {age: {value: 37, writeable: true}};

Object.defineProperties(a, b);

alert(a.age); // 37

Documentación de MDN: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/defineProperties