Arrays in Swift unterstützen den Operator + =, um den Inhalt eines Arrays einem anderen hinzuzufügen. Gibt es eine einfache Möglichkeit, dies für ein Wörterbuch zu tun?

z.B:

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

var combinedDict = ... (some way of combining dict1 & dict2 without looping)

Sie können einen +=Operator für Dictionaryz.

func += <K, V> (left: inout [K:V], right: [K:V]) { 
    for (k, v) in right { 
        left[k] = v
    } 
}

In Swift 4 sollte man verwenden merging(_:uniquingKeysWith:):

Beispiel:

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]

Wie wäre es mit

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

Dadurch werden alle Schlüssel und Werte von dict2 zu dict1 hinzugefügt.

Derzeit gibt es in der Swift Standard Library-Referenz für Wörterbuch keine Möglichkeit, ein Wörterbuch einfach mit einem anderen zu aktualisieren.

Sie können dazu eine Erweiterung schreiben

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]

Swift 4 bietet merging(_:uniquingKeysWith:)also für Ihren Fall:

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

Der Kurzschluss wird zurückgegeben $1, daher wird der Wert von dict2 verwendet, wenn ein Konflikt mit den Schlüsseln vorliegt.

Es ist nicht in die Swift-Bibliothek integriert, aber Sie können beim Überladen von Operatoren hinzufügen, was Sie möchten, z.

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
}

Dies überlastet die + Operator für Wörterbücher, mit denen Sie jetzt Wörterbücher mit dem +Operator hinzufügen können, z.

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

Unveränderlich

Ich bevorzuge es, unveränderliche Wörterbücher mit dem +Operator zu kombinieren / zu vereinen , also habe ich es wie folgt implementiert:

// 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"]

Veränderlich

// 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"]

Sie müssen jetzt keine Wörterbucherweiterungen mehr haben. Das Swift-Wörterbuch (Xcode 9.0+) verfügt über eine entsprechende Funktionalität. Schauen Sie hier . Unten finden Sie ein Beispiel für die Verwendung

  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]

Eine besser lesbare Variante mit einer Erweiterung.

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

Sie können dies versuchen

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

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

Sie können auch Reduzieren verwenden, um sie zusammenzuführen. Versuchen Sie dies auf dem Spielplatz

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
}

Ich empfehle die SwifterSwift Library . Wenn Sie jedoch nicht die gesamte Bibliothek und all ihre großartigen Ergänzungen verwenden möchten, können Sie einfach die Erweiterung des Wörterbuchs verwenden:

Swift 3+

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

Sie können die Schlüsselwertkombinationen für den Wert, den Sie zusammenführen möchten, durchlaufen und über die Methode updateValue (forKey :) hinzufügen:

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

Jetzt wurden alle Werte von dictionaryTwo zu dictionaryOne hinzugefügt.

Das gleiche wie die Antwort von @ farhadf, jedoch für Swift 3 übernommen:

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
}

Swift 3, Wörterbucherweiterung:

public extension Dictionary {

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

}

Einige noch optimierte Überladungen für Swift 4:

extension Dictionary {
    static func += (lhs: inout [Key:Value], rhs: [Key:Value]) {
        lhs.merge(rhs){$1}
    }
    static func + (lhs: [Key:Value], rhs: [Key:Value]) -> [Key:Value] {
        return lhs.merging(rhs){$1}
    }
}

Sie können eine DictionaryErweiterung wie folgt hinzufügen :

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

Dann ist die Verwendung so einfach wie die folgende:

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

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

Wenn Sie es vorziehen , einen Rahmen, der auch einige umfasst mehr praktische Funktionen dann Kasse HandySwift . Importieren Sie es einfach in Ihr Projekt und Sie können den obigen Code verwenden, ohne dem Projekt selbst Erweiterungen hinzuzufügen .

Es ist keine Erweiterung oder zusätzliche Funktion mehr erforderlich. Sie können so schreiben:

firstDictionary.merge(secondDictionary) { (value1, value2) -> AnyObject in
        return object2 // what you want to return if keys same.
    }

Sie können verwenden,

func addAll(from: [String: Any], into: [String: Any]){
    from.forEach {into[$0] = $1}
}

Mit der Funktion bridgeToObjectiveC () können Sie das Wörterbuch zu einem NSDictionary machen.

Wird wie folgt sein:

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)

Dann können Sie das NSDictionary (konvertieren) zurück konvertieren oder was auch immer tun.

import Foundation

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

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

Das Ergebnis ist ein NSMutableDictionary, kein Swift-typisiertes Wörterbuch, aber die Syntax für die Verwendung ist dieselbe (out["a"] == 1 in diesem Fall), sodass Sie nur dann ein Problem haben, wenn Sie Code von Drittanbietern verwenden, der ein Swift-Wörterbuch erwartet, oder wirklich brauche die Typprüfung.

Die kurze Antwort hier ist, dass Sie tatsächlich eine Schleife durchführen müssen. Auch wenn Sie es nicht explizit eingeben, funktioniert die von Ihnen aufgerufene Methode (addEntriesFromDictionary: hier) genau so. Ich würde vorschlagen, wenn Sie sich nicht sicher sind, warum dies der Fall ist, sollten Sie überlegen, wie Sie die Blattknoten zweier B-Bäume zusammenführen würden.

Wenn Sie im Gegenzug wirklich einen nativen Swift-Wörterbuchtyp benötigen, würde ich vorschlagen:

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

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

Der Nachteil dieses Ansatzes ist, dass der Wörterbuchindex - wie auch immer er ausgeführt wird - möglicherweise mehrmals in der Schleife neu erstellt wird. In der Praxis ist dies also etwa 10-mal langsamer als der Ansatz von NSMutableDictionary.

Alle diese Antworten sind kompliziert. Dies ist meine Lösung für 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) 

Meine Anforderungen waren unterschiedlich, ich musste unvollständige verschachtelte Datensätze zusammenführen, ohne zu überladen.

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

Das war schwieriger als ich es wollte. Die Herausforderung bestand in der Zuordnung von dynamischer Typisierung zu statischer Typisierung, und ich habe Protokolle verwendet, um dies zu lösen.

Bemerkenswert ist auch, dass Sie bei Verwendung der Wörterbuchliteral-Syntax tatsächlich die Grundlagentypen erhalten, die die Protokollerweiterungen nicht übernehmen. Ich habe meine Bemühungen, diese zu unterstützen, abgebrochen, da ich keine einfache Möglichkeit fand, die Einheitlichkeit der Sammlungselemente zu überprüfen.

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
}

Ich würde nur die Dollar- Bibliothek benutzen .

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

Fügt alle Wörterbücher zusammen und das letztere Wörterbuch überschreibt den Wert bei einem bestimmten Schlüssel

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]

Hier ist eine schöne Erweiterung, die ich geschrieben habe ...

extension Dictionary where Value: Any {
    public func mergeOnto(target: [Key: Value]?) -> [Key: Value] {
        guard let target = target else { return self }
        return self.merging(target) { current, _ in current }
    }
}

benutzen:

var dict1 = ["cat": 5, "dog": 6]
var dict2 = ["dog": 9, "rodent": 10]

dict1 = dict1.mergeOnto(target: dict2)

Dann wird dict1 in geändert

["cat": 5, "dog": 6, "rodent": 10]