Ich habe es satt, immer so Code schreiben zu müssen:

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

Oder wenn ich den Code nicht selbst schreiben möchte, implementieren Sie eine Bibliothek, die dies bereits tut. Sicherlich kommt ES6 + zur Rettung, um uns so etwas wie ein Object.prototype.extend(obj2...)oder zu liefernObject.extend(obj1,obj2...)

Bietet ES6 + solche Funktionen? Wenn nicht bereits vorhanden, ist eine solche Funktionalität dann geplant? Wenn nicht geplant, warum dann nicht?

Mit Object.assign können Sie in ES6 eine flache Zusammenführung / Erweiterung / Zuweisung durchführen:

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

Syntax:

Object.assign ( Ziel , Quellen );

Dabei steht ... source für das / die Quellobjekt (e).

Beispiel:

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

Object.assign(obj1, obj2);

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

Sie können hierfür die Objektverbreitungssyntax verwenden :

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

Für Arrays war der Spread-Operator bereits Teil von ES6 (ES2015), für Objekte wurde er jedoch der Sprachspezifikation bei ES9 (ES2018) hinzugefügt. Sein Vorschlag wurde in Tools wie Babel schon lange vorher standardmäßig aktiviert.

Ich weiß, dass dies ein altes Problem ist, aber die einfachste Lösung in ES2015 / ES6 ist mit Object.assign () recht einfach.

Hoffentlich hilft das, dies führt auch zum Zusammenführen von 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;
}

Anwendungsbeispiel:

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

Die Hinzufügung von Object.mixinwird derzeit diskutiert, um das von Ihnen gewünschte Verhalten zu berücksichtigen.https://mail.mozilla.org/pipermail/es-discuss/2012-December/027037.html

Obwohl es noch nicht im ES6-Entwurf enthalten ist, scheint es viel Unterstützung dafür zu geben, daher denke ich, dass es bald in den Entwürfen auftauchen wird.

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 oder Babel

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

Vielleicht erledigt die ES5- Object.definePropertiesMethode den Job?

z.B

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

Object.defineProperties(a, b);

alert(a.age); // 37

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