A może

dict2.forEach { (k,v) in dict1[k] = v }

Dodaje wszystkie klucze i wartości dict2 do dict1.

Obecnie, patrząc na Swift Standard Library Reference dla słownika, nie ma możliwości łatwej aktualizacji słownika o inny.

Możesz napisać do tego rozszerzenie

var dict1 = ["a" : "foo"]
var dict2 = ["b" : "bar"]

extension Dictionary {
    mutating func update(other:Dictionary) {
        for (key,value) in other {
            self.updateValue(value, forKey:key)
        }
    }
}

dict1.update(dict2)
// dict1 is now ["a" : "foo", "b" : "bar]

W Swift 4 należy użyć merging(_:uniquingKeysWith:):

Przykład:

let dictA = ["x" : 1, "y": 2, "z": 3]
let dictB = ["x" : 11, "y": 22, "w": 0]

let resultA = dictA.merging(dictB, uniquingKeysWith: { (first, _) in first })
let resultB = dictA.merging(dictB, uniquingKeysWith: { (_, last) in last })

print(resultA) // ["x": 1, "y": 2, "z": 3, "w": 0]
print(resultB) // ["x": 11, "y": 22, "z": 3, "w": 0]

Nie jest wbudowany w bibliotekę Swift, ale możesz dodać to, co chcesz z przeciążeniem operatora, np.:

func + <K,V>(left: Dictionary<K,V>, right: Dictionary<K,V>) 
    -> Dictionary<K,V> 
{
    var map = Dictionary<K,V>()
    for (k, v) in left {
        map[k] = v
    }
    for (k, v) in right {
        map[k] = v
    }
    return map
}

Powoduje przeciążenie operatora + dla słowników, których możesz teraz użyć do dodawania słowników z operatorem +, np.:

var dict1 = ["a" : "foo"]
var dict2 = ["b" : "bar"]

var dict3 = dict1 + dict2 // ["a": "foo", "b": "bar"]

Swift 3:

extension Dictionary {

    mutating func merge(with dictionary: Dictionary) {
        dictionary.forEach { updateValue($1, forKey: $0) }
    }

    func merged(with dictionary: Dictionary) -> Dictionary {
        var dict = self
        dict.merge(with: dictionary)
        return dict
    }
}

let a = ["a":"b"]
let b = ["1":"2"]
let c = a.merged(with: b)

print(c) //["a": "b", "1": "2"]

Swift 2.0

extension Dictionary {

    mutating func unionInPlace(dictionary: Dictionary) {
        dictionary.forEach { self.updateValue($1, forKey: $0) }
    }

    func union(var dictionary: Dictionary) -> Dictionary {
        dictionary.unionInPlace(self)
        return dictionary
    }
}

Swift 4 zapewnia merging(_:uniquingKeysWith:), więc w Twoim przypadku:

let combinedDict = dict1.merging(dict2) { $1 }

Skrócone zamknięcie zwraca $1, dlatego wartość dict2 będzie używana, gdy dojdzie do konfliktu z kluczami.

Immutable

Wolę łączyć / łączyć niezmienne słowniki z operatorem +, więc zaimplementowałem to tak:

// Swift 2
func + <K,V> (left: Dictionary<K,V>, right: Dictionary<K,V>?) -> Dictionary<K,V> {
    guard let right = right else { return left }
    return left.reduce(right) {
        var new = $0 as [K:V]
        new.updateValue($1.1, forKey: $1.0)
        return new
    }
}

let moreAttributes: [String:AnyObject] = ["Function":"authenticate"]
let attributes: [String:AnyObject] = ["File":"Auth.swift"]

attributes + moreAttributes + nil //["Function": "authenticate", "File": "Auth.swift"]    
attributes + moreAttributes //["Function": "authenticate", "File": "Auth.swift"]
attributes + nil //["File": "Auth.swift"]

Mutable

// Swift 2
func += <K,V> (inout left: Dictionary<K,V>, right: Dictionary<K,V>?) {
    guard let right = right else { return }
    right.forEach { key, value in
        left.updateValue(value, forKey: key)
    }
}

let moreAttributes: [String:AnyObject] = ["Function":"authenticate"]
var attributes: [String:AnyObject] = ["File":"Auth.swift"]

attributes += nil //["File": "Auth.swift"]
attributes += moreAttributes //["File": "Auth.swift", "Function": "authenticate"]

Bardziej czytelny wariant z rozszerzeniem.

extension Dictionary {    
    func merge(dict: Dictionary<Key,Value>) -> Dictionary<Key,Value> {
        var mutableCopy = self        
        for (key, value) in dict {
            // If both dictionaries have a value for same key, the value of the other dictionary is used.           
            mutableCopy[key] = value 
        }        
        return mutableCopy
    }    
}

Nie trzeba mieć teraz żadnych rozszerzeń słownikowych. Słownik Swift (Xcode 9.0+) ma do tego funkcjonalność. Zobacz Tutaj . Poniżej znajduje się przykład jak z niego korzystać

  var oldDictionary = ["a": 1, "b": 2]
  var newDictionary = ["a": 10000, "b": 10000, "c": 4]

  oldDictionary.merge(newDictionary) { (oldValue, newValue) -> Int in
        // This closure return what value to consider if repeated keys are found
        return newValue 
  }
  print(oldDictionary) // Prints ["b": 10000, "a": 10000, "c": 4]

Możesz spróbować tego

    var dict1 = ["a" : "foo"]
    var dict2 = ["b" : "bar"]


    var temp = NSMutableDictionary(dictionary: dict1);
    temp .addEntriesFromDictionary(dict2)

Możesz również użyć reduce, aby je połączyć. Spróbuj tego na placu zabaw

let d1 = ["a":"foo","b":"bar"]
let d2 = ["c":"car","d":"door"]

let d3 = d1.reduce(d2) { (var d, p) in
   d[p.0] = p.1
   return d
}

Polecam bibliotekę SwifterSwift . Jednak, jeśli nie chcesz korzystać z całej biblioteki i wszystkich jej wspaniałych dodatków, możesz po prostu skorzystać z ich rozszerzenia słownika:

Swift 3+

public extension Dictionary {
    public static func +=(lhs: inout [Key: Value], rhs: [Key: Value]) {
        rhs.forEach({ lhs[$0] = $1})
    }
}

Możesz iterować nad kombinacjami wartości klucza i wartości, które chcesz połączyć i dodać je za pomocą metody updateValue (forKey:):

dictionaryTwo.forEach {
    dictionaryOne.updateValue($1, forKey: $0)
}

Teraz wszystkie wartości dictionaryytwo zostały dodane do dictionaryOne.

Taka sama jak odpowiedź @farhadf ale przyjęta dla Swift 3:

let sourceDict1 = [1: "one", 2: "two"]
let sourceDict2 = [3: "three", 4: "four"]

let result = sourceDict1.reduce(sourceDict2) { (partialResult , pair) in
    var partialResult = partialResult //without this line we could not modify the dictionary
    partialResult[pair.0] = pair.1
    return partialResult
}

Możesz dodać Dictionary rozszerzenie w ten sposób:

extension Dictionary {
    func mergedWith(otherDictionary: [Key: Value]) -> [Key: Value] {
        var mergedDict: [Key: Value] = [:]
        [self, otherDictionary].forEach { dict in
            for (key, value) in dict {
                mergedDict[key] = value
            }
        }
        return mergedDict
    }
}

Następnie użycie jest tak proste Jak poniżej:

var dict1 = ["a" : "foo"]
var dict2 = ["b" : "bar"]

var combinedDict = dict1.mergedWith(dict2)
// => ["a": "foo", "b": "bar"]

Jeśli wolisz framework, który zawiera również kilka bardziej przydatnych funkcji, to checkout HandySwift. Po prostu zaimportuj go do swojego projektu i możesz użyć powyższego kodu bez dodawania żadnych rozszerzeń do projektu samodzielnie.

Biblioteka ExSwift zapewnia łączenie słowników (zwane Union i zdefiniowane jako operator rury'|'), a także mnóstwo innych funkcji wygodnych dla podstawowych typów.

Swift 3, Rozszerzenie słownika:

public extension Dictionary {

    public static func +=(lhs: inout Dictionary, rhs: Dictionary) {
        for (k, v) in rhs {
            lhs[k] = v
        }
    }

}

Możesz użyć funkcji bridgetoobjectiv (), aby słownik stał się NSDictionary.

Będzie wyglądać następująco:

var dict1 = ["a":"Foo"]
var dict2 = ["b":"Boo"]

var combinedDict = dict1.bridgeToObjectiveC()
var mutiDict1 : NSMutableDictionary! = combinedDict.mutableCopy() as NSMutableDictionary

var combineDict2 = dict2.bridgeToObjectiveC()

var combine = mutiDict1.addEntriesFromDictionary(combineDict2)

Następnie możesz przekształcić NSDictionary (połączyć) z powrotem lub zrobić cokolwiek.

import Foundation

let x = ["a":1]
let y = ["b":2]

let out = NSMutableDictionary(dictionary: x)
out.addEntriesFromDictionary(y)

Rezultatem jest NSMutableDictionary, a nie słownik SWIFT, ale składnia, której należy użyć, jest taka sama (out["a"] == 1 w tym przypadku), więc będziesz miał problem tylko wtedy, gdy używasz kodu innej firmy, który oczekuje słownika Swift, lub naprawdę potrzebujesz sprawdzenia typu.

Krótka odpowiedź jest taka, że naprawdę musisz zapętlić. Nawet jeśli nie wprowadzasz go jawnie, tak zrobi metoda, którą wywołujesz (addEntriesFromDictionary: here). Sugerowałbym, gdybyś był trochę niejasny dlaczego tak jest, powinieneś rozważyć, jak połączyć węzły liściowe Dwóch Drzew B.

Jeśli naprawdę potrzebujesz w zamian szybkiego natywnego słownika, proponuję:

let x = ["a":1]
let y = ["b":2]

var out = x
for (k, v) in y {
    out[k] = v
}

Minusem tego podejścia jest to, że indeks słownikowy - jakkolwiek to się robi - może być wielokrotnie przebudowywany w pętli, więc w praktyce jest to około 10x wolniejsze niż podejście NSMutableDictionary.

Wszystkie te odpowiedzi są skomplikowane. To jest moje rozwiązanie dla swift 2.2:

    //get first dictionnary
    let finalDictionnary : NSMutableDictionary = self.getBasicDict()
    //cast second dictionnary as [NSObject : AnyObject]
    let secondDictionnary : [NSObject : AnyObject] = self.getOtherDict() as [NSObject : AnyObject]
    //merge dictionnary into the first one
    finalDictionnary.addEntriesFromDictionary(secondDictionnary) 

Użyłbym biblioteki Dollar .

Https://github.com/ankurp/Dollar/#merge---merge-1

Scala wszystkie słowniki razem, a drugi słownik nadpisuje wartość przy danym kluczu

let dict: Dictionary<String, Int> = ["Dog": 1, "Cat": 2]
let dict2: Dictionary<String, Int> = ["Cow": 3]
let dict3: Dictionary<String, Int> = ["Sheep": 4]
$.merge(dict, dict2, dict3)
=> ["Dog": 1, "Cat": 2, "Cow": 3, "Sheep": 4]

Moje potrzeby były inne, musiałem scalić niekompletne zagnieżdżone zbiory danych bez zatrzaskiwania.

merging:
    ["b": [1, 2], "s": Set([5, 6]), "a": 1, "d": ["x": 2]]
with
    ["b": [3, 4], "s": Set([6, 7]), "a": 2, "d": ["y": 4]]
yields:
    ["b": [1, 2, 3, 4], "s": Set([5, 6, 7]), "a": 2, "d": ["y": 4, "x": 2]]

Warto również zauważyć, że gdy używasz dosłownej składni słownika, w rzeczywistości otrzymujesz typy fundamentów, które nie odbierają rozszerzeń protokołu. Przerwałem moje wysiłki, aby ich wspierać, ponieważ nie mogłem znaleźć łatwego do sprawdzanie jednorodności elementów kolekcji.

import UIKit


private protocol Mergable {
    func mergeWithSame<T>(right: T) -> T?
}



public extension Dictionary {

    /**
    Merge Dictionaries

    - Parameter left: Dictionary to update
    - Parameter right:  Source dictionary with values to be merged

    - Returns: Merged dictionay
    */


    func merge(right:Dictionary) -> Dictionary {
        var merged = self
        for (k, rv) in right {

            // case of existing left value
            if let lv = self[k] {

                if let lv = lv as? Mergable where lv.dynamicType == rv.dynamicType {
                    let m = lv.mergeWithSame(rv)
                    merged[k] = m
                }

                else if lv is Mergable {
                    assert(false, "Expected common type for matching keys!")
                }

                else if !(lv is Mergable), let _ = lv as? NSArray {
                    assert(false, "Dictionary literals use incompatible Foundation Types")
                }

                else if !(lv is Mergable), let _ = lv as? NSDictionary {
                    assert(false, "Dictionary literals use incompatible Foundation Types")
                }

                else {
                    merged[k] = rv
                }
            }

                // case of no existing value
            else {
                merged[k] = rv
            }
        }

        return merged
    }
}




extension Array: Mergable {

    func mergeWithSame<T>(right: T) -> T? {

        if let right = right as? Array {
            return (self + right) as? T
        }

        assert(false)
        return nil
    }
}


extension Dictionary: Mergable {

    func mergeWithSame<T>(right: T) -> T? {

        if let right = right as? Dictionary {
            return self.merge(right) as? T
        }

        assert(false)
        return nil
    }
}


extension Set: Mergable {

    func mergeWithSame<T>(right: T) -> T? {

        if let right = right as? Set {
            return self.union(right) as? T
        }

        assert(false)
        return nil
    }
}



var dsa12 = Dictionary<String, Any>()
dsa12["a"] = 1
dsa12["b"] = [1, 2]
dsa12["s"] = Set([5, 6])
dsa12["d"] = ["c":5, "x": 2]


var dsa34 = Dictionary<String, Any>()
dsa34["a"] = 2
dsa34["b"] = [3, 4]
dsa34["s"] = Set([6, 7])
dsa34["d"] = ["c":-5, "y": 4]


//let dsa2 = ["a": 1, "b":a34]
let mdsa3 = dsa12.merge(dsa34)
print("merging:\n\t\(dsa12)\nwith\n\t\(dsa34) \nyields: \n\t\(mdsa3)")

Swift 2.2

func + <K,V>(left: [K : V], right: [K : V]) -> [K : V] {
    var result = [K:V]()

    for (key,value) in left {
        result[key] = value
    }

    for (key,value) in right {
        result[key] = value
    }
    return result
}