¿Cómo duplicar propiedades de objeto en otro objeto?

Dado el objeto:

var firstObject = {
    key1 : 'value1',
    key2 : 'value2'
};

¿Cómo puedo copiar las propiedades dentro de otro objeto ( secondObject) como este:

var secondObject = {
    key1 : 'value1',
    key2 : 'value2',
    key3 : 'value3',
    key4 : 'value4'
};

utilizando una referencia a la firstObject? Algo como esto:

var secondObject = {
    firstObject,
    key3 : 'value3',
    key4 : 'value4'
};

(esto no funciona ... Lo puse solo para mostrar en grandes líneas cómo me gustaría estructurar el código).

¿Es posible una solución sin usar ningún framework de JavaScript?

for(var k in firstObject) secondObject[k]=firstObject[k];

Siguiendo el ejemplo de la respuesta de @ Bardzuśny aquí, ES6 ha entregado una solución nativa: ¡la Object.assign()función!

El uso es simple:

Object.assign(secondObject, firstObject);

¡Eso es!

El apoyo en este momento es obviamente pobre; solo Firefox (34+) lo admite de forma inmediata, mientras que Chrome (45+) y Opera (32+) requieren que se establezca el 'indicador experimental'.

El soporte está mejorando, con las últimas versiones de Chrome, Firefox, Opera, Safari y Edge que lo soportan (IE notablemente no tiene soporte). Los transpiladores también están disponibles, como Babel y Traceur. Ver aquí para más detalles.

Por ES6 - Sintaxis extendida :

Simplemente puede usar:

const thirdObject = {
   ...firstObject,
   ...secondObject   
}

Esto evita problemas de pasar estos objetos por referencia.

Además, se ocupa de los objetos que tienen un anidamiento profundo.

Recorra las propiedades del primer objeto y asígnelas al segundo objeto, así:

var firstObject = {
    key1 : 'value1',
    key2 : 'value2'
};

var secondObject = {
    key3 : 'value3',
    key4 : 'value4'
};

for (var prop in firstObject) {
    if (firstObject.hasOwnProperty(prop)) {
        secondObject[prop] = firstObject[prop];
    }
}

El for- inbucle no es suficiente; lo que necesita hasOwnProperty. Consulte http://bonsaiden.github.com/JavaScript-Garden/#object.forinloop para obtener una explicación detallada de por qué.

Jugar al nigromante aquí, porque ES5 nos trajo Object.keys(), con potencial para salvarnos de todos estos .hasOwnProperty()controles.

Object.keys(firstObject).forEach(function(key) {
  secondObject[key] = firstObject[key];
});

O, envolviéndolo en una función ("copia" limitada de lodash _.assign()):

function assign(object, source) {
  Object.keys(source).forEach(function(key) {
    object[key] = source[key];
  });
}

assign(secondObject, firstObject); // assign firstObject properties to secondObject

Object.keys()es un método relativamente nuevo, sobre todo: no está disponible en IE <9. Lo mismo ocurre con el .forEach()método de matriz, que utilicé en lugar del forbucle regular .

Afortunadamente, hay es5-shim disponible para estos navegadores antiguos, que rellenará muchas funciones de ES5 (incluidas esas dos).

(Estoy a favor de los polyfills en lugar de evitar el uso de nuevas y geniales funciones de lenguaje).

Necro'ing para que las personas puedan encontrar un método de copia profunda con hasOwnProperty y verificación de objeto real:

var extend = function (original, context, key) {
  for (key in context)
    if (context.hasOwnProperty(key))
      if (Object.prototype.toString.call(context[key]) === '[object Object]')
        original[key] = extend(original[key] || {}, context[key]);
      else
        original[key] = context[key];
  return original;
};

Se puede usar Object.assign para combinar objetos. Combinará y anulará la propiedad común de derecha a izquierda, es decir, la misma propiedad en la izquierda será anulada por la derecha.

Y es importante suministrar un objeto vacío en el primero para evitar la mutación de los objetos fuente. Los objetos de origen deben dejarse limpios ya que Object.assign()por sí solo devuelve un nuevo objeto.

¡Espero que esto ayude!

var firstObject = {
    key1 : 'value1',
    key2 : 'value2'
};

var secondObject = {
    key3 : 'value3',
    key4 : 'value4'
};

var finalObject = Object.assign({}, firstObject, secondObject)

console.log(finalObject)

Mejora de la idea kingPuppy y la idea OP (copia superficial): solo agrego 3 puntos al "ejemplo" OP :)

var secondObject = {
    ...firstObject,
    key3 : 'value3',
    key4 : 'value4'
};

var firstObject = {
    key1 : 'value1',
    key2 : 'value2'
};

var secondObject = {
    ...firstObject,
    key3 : 'value3',
    key4 : 'value4'
};

console.log(secondObject);

Esto debería funcionar, probado aquí .

var secondObject = {
    firstObject: JSON.parse(JSON.stringify(firstObject)),
    key3 : 'value3',
    key4 : 'value4'
};

Nota : esto no copiará los métodos de la firstObject
Nota 2 : para usar en navegadores antiguos, necesitará un analizador json.
Nota 3 : la asignación por referencia es una opción viable, especialmente si firstObjectcontiene métodos. Ajustó el ejemplo jsfiddle dado en consecuencia

Desafortunadamente, no puede poner una referencia a una variable en un objeto como ese. Sin embargo, puede realizar una función que copie los valores del objeto en otro objeto.

function extend( obj1, obj2 ) {
    for ( var i in obj2 ) {
        obj1[i] = obj2[i];
    }
    return obj1;
}

var firstObject = {
    key1: "value1",
    key2: "value2"
};

var secondObject = extend({
    key3: "value3",
    key4: "value4"
}, firstObject );

Si desea tomar solo las propiedades que existen en el segundo objeto, puede usar Object.keyspara tomar las propiedades del primer objeto, puede hacer dos métodos:

A.) map para asignar las propiedades del primer objeto al segundo objeto usando efectos secundarios:

var a = {a:100, b:9000, c:300};
var b = {b:-1};

Object.keys(a).map(function(key, index) {
    if (typeof b[key] !== 'undefined') {
        console.log(key);
        b[key] = a[key];    
    }
});

B.) o reducepara crear un nuevo objeto y asignarlo al segundo objeto. Tenga en cuenta que este método reemplaza otras propiedades que el segundo objeto podría tener antes de las que no coincidían con el primer objeto:

var a = {a:100, b:9000, c:300};
var b = {b:-1, d:-1}; // d will be gone

b = Object.keys(a).reduce(function(result, current) {
    if (typeof b[current] !== 'undefined') {
        result[current] = a[current];   
    }
    return result;
}, {});

Use la notación de propagación de propiedad. Se agregó en ES2018 (la distribución para matrices / iterables era anterior, ES2015), {... firstObject} extiende todas las propiedades enumerables como propiedades discretas.

let secondObject = {
      ...firstObject,
      key3 : 'value3',
      key4 : 'value4'
    }

Prefiero usar firstObject como prototipo de secondObject y agregar el descriptor de propiedad:

var secondObject = Object.create(firstObject, {
      key3: {value: "value3", writable: true, configurable: true, enumerable: true},
      key4: {value: "value4", writable: true, configurable: true, enumerable: true}
      });

Ciertamente no es una línea, pero te da más control. Si está interesado en los descriptores de propiedades, le sugiero que lea este artículo: http://patrickdelancy.com/2012/09/property-descriptors-in-javascript/#comment-2062 y la página MDN https: //developer.mozilla. org / es-es / docs / Web / JavaScript / Reference / Global_Objects / Object / create

También puede simplemente asignar valores y omitir los descriptores y hacerlo un poco más corto:

var secondObject = Object.create(firstObject, {
      key3: {value: "value3"}
      key4: {value: "value4"}
  });

Compatibilidad: ECMAScript 5, entonces IE9 +

var firstObject = {
     key1: "value1",
     key2: "value2"
};

var secondObject = {
     key3: "value3",
     key4: "value4"
     copy: function(firstObject){
           this.key1 = firstObject.key1;
           this.key2 = firstObject.key2;
     }
 };

El uso del siguiente método copiará las propiedades

secondObject.copy(firstObject)

Soy muy nuevo en javascript, pero encontré que esto funciona. Un poco demasiado largo, supongo, pero funciona.