Na biblioteca Lodash , alguém pode fornecer uma explicação melhor da mesclagem e extensão / atribuição .

É uma pergunta simples, mas a resposta me escapa.

Veja como extend/assign obras: Para cada propriedade na origem, copie seu valor como está até o destino. se os próprios valores da propriedade são objetos, não há um percurso recursivo de suas propriedades. O objeto inteiro seria retirado da origem e definido no destino.

Eis como mergefunciona: Para cada propriedade na fonte, verifique se essa propriedade é o próprio objeto. Se estiver, desça recursivamente e tente mapear as propriedades do objeto filho da origem ao destino. Então, basicamente, mesclamos a hierarquia de objetos da origem ao destino. Enquanto para extend/ assign, é uma cópia simples de um nível das propriedades da origem ao destino.

Aqui está o JSBin simples que deixaria isso bem claro: http://jsbin.com/uXaqIMa/2/edit?js,console

Aqui está uma versão mais elaborada que inclui matriz no exemplo também: http://jsbin.com/uXaqIMa/1/edit?js,console

Versão Lodash 3.10.1

Métodos comparados

• _.merge(object, [sources], [customizer], [thisArg])
• _.assign(object, [sources], [customizer], [thisArg])
• _.extend(object, [sources], [customizer], [thisArg])
• _.defaults(object, [sources])
• _.defaultsDeep(object, [sources])

Semelhanças

• Nenhum deles funciona em matrizes como você poderia esperar
• _.extend é um apelido para _.assign , então eles são idênticos
• Todos eles parecem modificar o objeto de destino (primeiro argumento)
• Todos eles lidam com nullo mesmo

Diferenças

• _.defaults e _.defaultsDeep processa os argumentos em ordem inversa em comparação com os outros (embora o primeiro argumento ainda seja o objeto de destino)
• _.merge e _.defaultsDeep mesclará objetos filho e os outros substituirão no nível raiz
• Somente _.assigne _.extendsubstituirá um valor comundefined

Testes

Todos eles lidam com membros na raiz de maneiras semelhantes.

_.assign      ({}, { a: 'a' }, { a: 'bb' }) // => { a: "bb" }
_.merge       ({}, { a: 'a' }, { a: 'bb' }) // => { a: "bb" }
_.defaults    ({}, { a: 'a' }, { a: 'bb' }) // => { a: "a"  }
_.defaultsDeep({}, { a: 'a' }, { a: 'bb' }) // => { a: "a"  }

_.assignalças, undefinedmas os outros vão pular

_.assign      ({}, { a: 'a'  }, { a: undefined }) // => { a: undefined }
_.merge       ({}, { a: 'a'  }, { a: undefined }) // => { a: "a" }
_.defaults    ({}, { a: undefined }, { a: 'bb' }) // => { a: "bb" }
_.defaultsDeep({}, { a: undefined }, { a: 'bb' }) // => { a: "bb" }

Todos eles lidam com nullo mesmo

_.assign      ({}, { a: 'a'  }, { a: null }) // => { a: null }
_.merge       ({}, { a: 'a'  }, { a: null }) // => { a: null }
_.defaults    ({}, { a: null }, { a: 'bb' }) // => { a: null }
_.defaultsDeep({}, { a: null }, { a: 'bb' }) // => { a: null }

Mas apenas _.mergee _.defaultsDeepmesclará objetos filho

_.assign      ({}, {a:{a:'a'}}, {a:{b:'bb'}}) // => { "a": { "b": "bb" }}
_.merge       ({}, {a:{a:'a'}}, {a:{b:'bb'}}) // => { "a": { "a": "a", "b": "bb" }}
_.defaults    ({}, {a:{a:'a'}}, {a:{b:'bb'}}) // => { "a": { "a": "a" }}
_.defaultsDeep({}, {a:{a:'a'}}, {a:{b:'bb'}}) // => { "a": { "a": "a", "b": "bb" }}

E nenhum deles irá mesclar matrizes parece

_.assign      ({}, {a:['a']}, {a:['bb']}) // => { "a": [ "bb" ] }
_.merge       ({}, {a:['a']}, {a:['bb']}) // => { "a": [ "bb" ] }
_.defaults    ({}, {a:['a']}, {a:['bb']}) // => { "a": [ "a"  ] }
_.defaultsDeep({}, {a:['a']}, {a:['bb']}) // => { "a": [ "a"  ] }

Todos modificam o objeto de destino

a={a:'a'}; _.assign      (a, {b:'bb'}); // a => { a: "a", b: "bb" }
a={a:'a'}; _.merge       (a, {b:'bb'}); // a => { a: "a", b: "bb" }
a={a:'a'}; _.defaults    (a, {b:'bb'}); // a => { a: "a", b: "bb" }
a={a:'a'}; _.defaultsDeep(a, {b:'bb'}); // a => { a: "a", b: "bb" }

Nenhum realmente funciona como esperado em matrizes

Nota: Como o @Mistic apontou, o Lodash trata matrizes como objetos em que as chaves são o índice da matriz.

_.assign      ([], ['a'], ['bb']) // => [ "bb" ]
_.merge       ([], ['a'], ['bb']) // => [ "bb" ]
_.defaults    ([], ['a'], ['bb']) // => [ "a"  ]
_.defaultsDeep([], ['a'], ['bb']) // => [ "a"  ]

_.assign      ([], ['a','b'], ['bb']) // => [ "bb", "b" ]
_.merge       ([], ['a','b'], ['bb']) // => [ "bb", "b" ]
_.defaults    ([], ['a','b'], ['bb']) // => [ "a", "b"  ]
_.defaultsDeep([], ['a','b'], ['bb']) // => [ "a", "b"  ]

Outra diferença a ser observada é a manipulação de undefinedvalores:

mergeInto = { a: 1}
toMerge = {a : undefined, b:undefined}
lodash.extend({}, mergeInto, toMerge) // => {a: undefined, b:undefined}
lodash.merge({}, mergeInto, toMerge)  // => {a: 1, b:undefined}

Portanto merge, não mesclará undefinedvalores em valores definidos.

Também pode ser útil considerar o que eles fazem do ponto de vista semântico:

_.atribuir

   will assign the values of the properties of its second parameter and so on,
   as properties with the same name of the first parameter. (shallow copy & override)

_.merge

   merge is like assign but does not assign objects but replicates them instead.
  (deep copy)

_.defaults

   provides default values for missing values.
   so will assign only values for keys that do not exist yet in the source.

_.defaultsDeep

   works like _defaults but like merge will not simply copy objects
   and will use recursion instead.

Acredito que aprender a pensar nesses métodos do ponto de vista semântico permitiria "adivinhar" qual seria o comportamento de todos os diferentes cenários de valores existentes e não existentes.

Se você deseja uma cópia profunda sem substituir, mantendo a mesma objreferência

obj = _.assign(obj, _.merge(obj, [source]))