Wie fügen Sie einem Wörterbuch von Elementen in ein anderes Wörterbuch

Wie etwa

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

Fügt hinzu, dass alle dict2 die Schlüssel und Werte in dict1.

InformationsquelleAutor jasongregori

Derzeit, mit Blick auf die Swift-Standard Library Reference für das Wörterbuch, gibt es keine Möglichkeit, um einfach aktualisieren Sie ein Wörterbuch mit einer anderen.

Schreiben Sie eine Erweiterung, um es zu tun

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]

InformationsquelleAutor Rod

Ist es nicht eingebaut in die Swift-Bibliothek, aber Sie können hinzufügen, was Sie wollen mit operator-überladung, e.g:

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
}

Diese überlastungen der + Betreiber für die Wörterbücher, die Sie jetzt verwenden Sie zum hinzufügen von Wörterbüchern mit der + Betreiber, e.g:

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

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

InformationsquelleAutor mythz

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

InformationsquelleAutor olsen

Keine Notwendigkeit, irgendwelche Wörterbuch-Erweiterungen jetzt. Swift(Xcode 9.0+) Wörterbuch hat eine Funktion für diese. Haben Sie einen Blick hier. Unten hier ist ein Beispiel, wie man es verwenden,

  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]

InformationsquelleAutor Vinayak Parmar

Können Sie versuchen, diese

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

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

InformationsquelleAutor Uttam Kumar

Empfehle ich die SwifterSwift Bibliothek. Allerdings, wenn Sie nicht wollen, verwenden Sie die gesamte Bibliothek und alle seine großen Erweiterungen können Sie nur nutzen, Ihre Erweiterung Dictionary:

Swift 3+

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

InformationsquelleAutor Justin Oroz

Gleich wie @farhadf Antwort, aber angenommen für 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
}

InformationsquelleAutor Dmitry Klochkov

Swift 3 -, Lexikon-Erweiterung:

public extension Dictionary {

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

}

InformationsquelleAutor aaannjjaa

Können Sie die bridgeToObjectiveC () - Funktion, um das Wörterbuch ein NSDictionary.

Werden, wie die folgenden:

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 konvertieren die NSDictionary(kombiniert) zurück oder tun, was auch immer.

InformationsquelleAutor Anton

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) 

InformationsquelleAutor Kevin ABRIOUX

Meine Bedürfnisse waren unterschiedlich, brauchte ich zum Zusammenführen unvollständige, geschachtelte Datensätze ohne Stress.

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

Dieser war härter, als ich wollte, es zu sein. Die Herausforderung Bestand in der Zuordnung von dynamischen Typisierung statische Typisierung, und ich verwendete Protokolle, diese zu lösen.

Hervorzuheben ist auch, dass, wenn Sie verwenden das dictionary-literal-syntax, bekommen Sie eigentlich das Fundament-Typen, die nicht abholen, die Protokoll-Erweiterungen. Ich trieb meinen Bemühungen zu unterstützen, die wie ich nicht finden konnte, ein leicht zu überprüfen die Homogenität der Elemente aus der Sammlung.

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

InformationsquelleAutor Chris Conover

Hier ist eine nette Erweiterung, die ich schrieb...

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

verwenden:

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

dict1 = dict1.mergeOnto(target: dict2)

Dann, dict1 werden geändert, um

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

InformationsquelleAutor Brian J. Roberts