En la biblioteca de Lodash , ¿alguien puede proporcionar una mejor explicación de fusión y extensión / asignación .

Es una pregunta simple pero la respuesta me evade.

Aquí se explica cómo extend/ assignfunciona: para cada propiedad en el origen, copie su valor tal cual al destino. Si los valores de propiedad en sí mismos son objetos, no existe un recorrido recursivo de sus propiedades. Todo el objeto se tomaría del origen y se establecería en el destino.

Así es como mergefunciona: para cada propiedad en la fuente, verifique si esa propiedad es el objeto mismo. Si es así, baje de forma recursiva e intente asignar propiedades de objetos secundarios desde el origen al destino. Entonces, esencialmente fusionamos la jerarquía de objetos de origen a destino. Mientras que para extend/ assign, es una copia simple de un nivel de propiedades desde el origen hasta el destino.

Aquí hay un JSBin simple que aclararía esto: http://jsbin.com/uXaqIMa/2/edit?js,console

Aquí hay una versión más elaborada que incluye una matriz en el ejemplo también: http://jsbin.com/uXaqIMa/1/edit?js,console

Lodash versión 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])

Similitudes

• Ninguno de ellos funciona en matrices como cabría esperar.
• _.extend es un alias para _.assign , lo que son idénticos
• Todos parecen modificar el objeto de destino (primer argumento)
• Todos ellos manejan nulllo mismo

Las diferencias

• _.defaultsy _.defaultsDeepprocesa los argumentos en orden inverso en comparación con los demás (aunque el primer argumento sigue siendo el objeto de destino)
• _.merge y _.defaultsDeep fusionará objetos secundarios y los demás se sobrescribirán en el nivel raíz
• Solo _.assigny _.extendsobrescribirá un valor conundefined

Pruebas

Todos manejan miembros en la raíz de manera similar.

_.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"  }

_.assignmaneja undefinedpero los demás lo omitirán

_.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 manejan nulllo mismo

_.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 }

Pero solo _.mergey _.defaultsDeepfusionará objetos secundarios

_.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" }}

Y ninguno de ellos fusionará matrices, 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 modifican el 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" }

Ninguno realmente funciona como se esperaba en las matrices

Nota: Como señaló @Mistic, Lodash trata las matrices como objetos donde las claves son el índice de la 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"  ]

Otra diferencia a la que prestar atención es el manejo 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}

Por mergelo tanto , no fusionará undefinedvalores en valores definidos.

También podría ser útil considerar lo que hacen desde un punto de vista semántico:

_.asignar

   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)

_.unir

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

_defectos

   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.

Creo que aprender a pensar en esos métodos desde el punto de vista semántico le permitiría "adivinar" mejor cuál sería el comportamiento para todos los diferentes escenarios de valores existentes y no existentes.

Si desea una copia profunda sin anulación mientras conserva la misma objreferencia

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