In Lodash kütüphane, kutu birisi daha iyi bir açıklama birleştirme ve / ata uzatmak .

Bu basit bir soru ama cevap yine de beni kaçıyor.

Şöyle extend/ assignçalışır: Kaynaktaki her özellik için değerini olduğu gibi hedefe kopyalayın. özellik değerlerinin kendileri nesne ise, özelliklerinde özyinelemeli geçiş olmaz. Tüm nesne kaynaktan alınır ve hedefe ayarlanır.

Şöyle mergeçalışır: Kaynaktaki her özellik için, o özelliğin nesnenin kendisi olup olmadığını kontrol edin. Öyleyse, özyinelemeli olarak aşağı inin ve alt nesne özelliklerini kaynaktan hedefe eşlemeye çalışın. Yani esasen nesne hiyerarşisini kaynaktan hedefe birleştiriyoruz. extend/ İçin iken assign, özelliklerin kaynaktan hedefe basit bir düzeyli kopyasıdır.

İşte bu kristali netleştirecek basit JSBin: http://jsbin.com/uXaqIMa/2/edit?js,console

Örnekte dizi içeren daha ayrıntılı sürüm: http://jsbin.com/uXaqIMa/1/edit?js,console

Lodash sürüm 3.10.1

Karşılaştırılan yöntemler

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

benzerlikler

• Hiçbiri beklediğiniz gibi dizilerde çalışmaz
• _.extendiçin bir takma addır _.assign, bu yüzden aynıdırlar
• Hepsi hedef nesneyi değiştiriyor gibi görünüyor (ilk argüman)
• Hepsi nullaynı şekilde

farklılıklar

• _.defaultsve _.defaultsDeepargümanları diğerlerine göre ters sırada işler (ilk argüman hala hedef nesne olsa da)
• _.mergeve _.defaultsDeepalt nesneler birleştirilecek ve diğerleri kök seviyesinde üzerine yazılır
• Yalnızca _.assignve _.extendile bir değerin üzerine yazılırundefined

Testler

Hepsi de kökten üyeleri benzer şekilde ele alıyor.

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

_.assignkolları undefinedama diğerleri atlayacak

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

Hepsi nullaynı şekilde

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

Ancak yalnızca _.mergeve _.defaultsDeepalt nesneleri birleştirir

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

Ve hiçbiri dizileri birleştirmeyecek gibi görünüyor

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

Tümü hedef nesneyi değiştirir

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

Hiçbiri dizilerde beklendiği gibi çalışmaz

Not: @Mistic'in işaret ettiği gibi, Lodash dizilere anahtarların dizinin dizini olduğu nesneler gibi davranır.

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

Dikkat edilmesi gereken bir diğer fark undefineddeğerlerin işlenmesidir :

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

Böylece değerleri tanımlı değerlerle mergebirleştirmeyeceğiz undefined.

Semantik bir bakış açısıyla yaptıklarını düşünmek de yararlı olabilir:

_.atamak

   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)

_.birleştirmek

   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.

Bu yöntemleri semantik açıdan düşünmeyi öğrenmenin, mevcut ve mevcut olmayan değerlerin tüm farklı senaryoları için nasıl bir davranış olacağını daha iyi "tahmin etmenizi" sağlayacağına inanıyorum.

Aynı objreferansı korurken geçersiz kılmadan derin bir kopya istiyorsanız

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