Como duplicar propriedades do objeto em outro objeto?

Dado o objeto:

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

como posso copiar as propriedades dentro de outro objeto ( secondObject) como este:

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

usando uma referência ao firstObject? Algo assim:

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

(isso não funciona ... coloquei apenas para mostrar em grandes linhas como eu gostaria de estruturar o código).

É possível uma solução sem o uso de estruturas JavaScript?

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

Tomando uma sugestão da resposta de @ Bardzuśny aqui, o ES6 forneceu uma solução nativa: a Object.assign()função!

O uso é simples:

Object.assign(secondObject, firstObject);

É isso aí!

O suporte agora é obviamente ruim; somente o Firefox (34+) é compatível imediatamente, enquanto o Chrome (45+) e o Opera (32+) exigem que o 'sinalizador experimental' seja definido.

O suporte está melhorando, com as versões mais recentes do Chrome, Firefox, Opera, Safari e Edge (o IE notavelmente não tem suporte). Transpilers também estão disponíveis, como Babel e Traceur. Veja aqui para mais detalhes.

Por ES6 - sintaxe de propagação :

Você pode simplesmente usar:

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

Isso evita problemas de passar esses objetos por referência.

Além disso, ele cuida de objetos com aninhamento profundo.

Faça um loop pelas propriedades do primeiro objeto e atribua-as ao segundo objeto, assim:

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

O loop for- innão é suficiente; você precisa hasOwnProperty. Veja http://bonsaiden.github.com/JavaScript-Garden/#object.forinloop para uma explicação detalhada do porquê.

Jogando o necromante aqui, porque o ES5 nos trouxe Object.keys(), com potencial para nos salvar de todas essas .hasOwnProperty()verificações.

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

Ou, agrupando-o em uma função ("cópia" limitada do 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()é um método relativamente novo, mais notavelmente: não disponível no IE <9. O mesmo vale para o .forEach()método array, que eu usei no lugar do forloop regular .

Felizmente, há es5-shim disponível para esses navegadores antigos, que preencherão muitos recursos do ES5 (incluindo os dois).

(Eu sou a favor de polyfills, em vez de não usar novos recursos interessantes de idioma.)

Necro'ing para que as pessoas possam encontrar um método de cópia profunda com hasOwnProperty e verificação 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;
};

Pode-se usar Object.assign para combinar objetos. Ele combinará e substituirá a propriedade comum da direita para a esquerda, ou seja, a mesma propriedade na esquerda será substituída pela direita.

E é importante fornecer um objeto vazio no primeiro para evitar a mutação dos objetos de origem. Os objetos de origem devem ser deixados limpos, pois, Object.assign()por si só, retorna um novo objeto.

Espero que isto ajude!

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

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

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

console.log(finalObject)

Melhoria da ideia kingPuppy e OP (cópia superficial) - adiciono apenas 3 pontos ao "exemplo" do OP :)

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

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

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

console.log(secondObject);

Isso deve funcionar, testado aqui .

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

Nota : isso não copiará os métodos da firstObject
Nota 2 : para uso em navegadores antigos, você precisará de um analisador json
Nota 3 : atribuir por referência é uma opção viável, especialmente se firstObjectcontiver métodos. Ajustado o exemplo jsfiddle fornecido de acordo

Infelizmente, você não pode colocar uma referência a uma variável em um objeto como esse. No entanto, você pode criar uma função que copie os valores do objeto em outro 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 );

Se você deseja capturar apenas as propriedades existentes no segundo objeto, pode usar Object.keysas propriedades do primeiro objeto, pode executar dois métodos:

A.) map para atribuir as propriedades do primeiro objeto ao segundo objeto usando efeitos colaterais:

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.) ou reducepara criar um novo objeto e atribuí-lo ao segundo objeto. Esteja ciente de que esse método substitui outras propriedades que o segundo objeto pode ter antes daquilo que não corresponde ao primeiro 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 a notação de propriedade espalhada. Foi adicionado no ES2018 (o spread para arrays / iterables era anterior, ES2015), {... firstObject} espalha todas as propriedades enumeráveis ​​como propriedades discretas.

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

Prefiro usar firstObject como protótipo de secondObject e adicionar descritor de propriedades:

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

Certamente não é uma linha, mas oferece mais controle. Se você estiver interessado em descritores de propriedade, sugiro ler este artigo: http://patrickdelancy.com/2012/09/property-descriptors-in-javascript/#comment-2062 e a página MDN https: //developer.mozilla. org / pt-br / docs / Web / JavaScript / Referência / Global_Objects / Object / create

Você também pode atribuir valores e omitir os descritores e torná-lo um pouco mais curto:

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

Compatibilidade: ECMAScript 5, então IE9 +

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

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

O uso do método follwing copiará as propriedades

secondObject.copy(firstObject)

Eu sou muito novo em javascript, mas achei isso funcionando. Um pouco demais, eu acho, mas funciona.