Wie füge ich ein Wörterbuch mit Elementen zu einem anderen Wörterbuch hinzu?

172

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)
rostig
quelle
fromDict.forEach {intoDict[$0] = $1}
Sazzad Hissain Khan

Antworten:

171

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
    } 
}
Shucao
quelle
1
Oh Mann, ich hatte so große Probleme damit, die richtige generische Erklärung dafür zu finden, dass ich alles außer diesem ausprobiert habe. Aber du kannst das @assignmentund fallen lassen return, du mutierst schon links. Edit: eigentlich, obwohl ich keine Fehler bekomme, denke ich @assignmentsollte bleiben.
Roland
14
Mehr Syntax Zucker: func +=<K, V> (inout left: [K : V], right: [K : V]) { for (k, v) in right { left[k] = v } }
Ivan Vavilov
48
@animal_chin Weil wir die Hälfte der Sprache selbst implementieren müssen? Ja. Beeindruckt. Versteh mich nicht falsch, ich liebe das Überladen von Bedienern. Ich mag es einfach nicht, es für grundlegende Funktionen verwenden zu müssen, die eingebaut werden sollten.
devios1
2
@devios Haha dann machen Sie es eine Pull-Anfrage an das Swift-Repo: D Da Apple offensichtlich nicht bewaffnet werden kann
CommaToast
6
Direkt aus der SwifterSwift Library ziehen :public static func +=(lhs: inout [Key: Value], rhs: [Key: Value]) { rhs.forEach({ lhs[$0] = $1}) }
Justin Oroz
99

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]
Vin Gazoil
quelle
1
// veränderlich: var dictA = ["x": 1, "y": 2, "z": 3] var dictB = ["x": 11, "y": 22, "w": 0] dictA. merge (dictB, uniquingKeysWith: {(first, _) in first}) print (dictA) // ["x": 1, "y": 2, "z": 3, "w": 0]
muthukumar
1
Das zweite Beispiel in dieser Antwort entspricht [NSMutableDictionary addEntriesFromDictionary:].
Orj
92

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.

Jasongregori
quelle
43
Schöne Lösung. Etwas kürzer: dict2.forEach {dict1 [$ 0] = $ 1}
Brett
1
Dies ist eine großartige Lösung, aber für Swift 4 wird höchstwahrscheinlich eine Fehlermeldung angezeigt Closure tuple parameter '(key: _, value: _)' does not support destructuring(zumindest zum Zeitpunkt dieses Schreibens). Man müsste die Schließung gemäß [dieser Stackoverflow-Antwort] ( stackoverflow.com/questions/44945967/… ) umstrukturieren :
JonnyB
78

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]
Stange
quelle
3
Dies ist eine großartige Verwendung der Erweiterung für das Wörterbuch!
Marc Attinasi
76

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.

Samwize
quelle
1
Ich wollte nur darauf hinweisen, dass dies das prägnanteste und naheliegendste ist, was ich in der Apple-Dokumentation gefunden habe - (void)addEntriesFromDictionary:(NSDictionary<KeyType, ObjectType> *)otherDictionary;. In Bezug auf die Vorgehensweise bei Duplikaten heißt es: "Wenn beide Wörterbücher denselben Schlüssel enthalten, wird dem vorherigen Wertobjekt des empfangenden Wörterbuchs für diesen Schlüssel eine Freigabemeldung gesendet, und das neue Wertobjekt nimmt seinen Platz ein." Die Swift-Version oder in Merge (_: uniquingKeysWith :), die den zweiten Wert zurückgibt $1, ist dieselbe wie das, was sie addEntriesFromDictionarytut.
Tim Fuqua
31

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"]
Mythos
quelle
1
Sie können dies auch für + = tun, um ein Diktat zu aktualisieren (gemäß der Operationsfrage).
Rod
3
Sie können mapdie erste for (k, v)...Schleife entfernen und löschen , wenn Sie den leftParameter als deklarieren varund dann einfach Werte daraus kopieren right.
Nate Cook
2
@NateCook, der das Wörterbuch mutieren würde, was für den +Infix-Operator kein erwartetes Verhalten ist .
Mythos
Dank dafür. Ihre Antwort war wahrscheinlich genauer auf den Beispielcode, den ich gepostet habe, während der andere mehr das war, was ich aufgrund meiner Frage wollte. Mein schlechtes, gab euch beiden sowieso eine Gegenstimme;)
rustyshelf
2
@mythz Es ist nicht wirklich mutierend, da die +Operatorüberladung auch keine Methode ist Dictionary, sondern eine einfache Funktion. Die Änderungen, die Sie an einem variablen leftParameter vornehmen, sind außerhalb der Funktion nicht sichtbar.
Nate Cook
28

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"]
Pavel Sharanda
quelle
6
etwas besserfunc merged(with dictionary: Dictionary<Key,Value>) -> Dictionary<Key,Value> { var copy = self dictionary.forEach { copy.updateValue($1, forKey: $0) } return copy }
Alexander Vasenin
16

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
    }
}
Olsen
quelle
Ich
Der unionFunktion wird der Wert a übergeben var, was bedeutet, dass das kopierte Wörterbuch mutiert werden kann. Es ist ein bisschen sauberer als func union(dictionary: Dictionary) -> Dictionary { var dict2 = dictionary; dict2.unionInPlace(self); return dict2 }, wenn auch nur um eine Zeile.
MaddTheSane
2
var-Parameter sind veraltet und werden in Swift 3 entfernt. Die bevorzugte Methode hierfür besteht nun darin, eine var im Body zu deklarieren : var dictionary = dictionary. Von hier: github.com/apple/swift-evolution/blob/master/proposals/…
Daniel Wood
Um die Sicherheit typsicherer zu gestalten, fügen Sie <Key, Value>diese hinzu Dictionary.
Raphael
12

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"]
Ricardopereira
quelle
5
Ich verstehe nicht, warum dies nicht standardmäßig in Swift eingebaut ist.
Ioquatix
1
beabsichtigen Sie, Werte von links in Ihrer "unveränderlichen" Lösung nach rechts zu überschreiben? Ich denke, Sie wollen haben right.reduce(left), zumindest ist das das erwartete Verhalten imo (und es ist das Verhalten Ihres zweiten Beispiels) - dh. ["A":1] + ["A":2]sollte ausgeben["A":2]
ccwasden
Die Ausgabe entspricht dem Code. Ich möchte, dass der Anfangswert die richtige Seite ist, so wie es jetzt ist.
Ricardopereira
12

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]
Vinayak Parmar
quelle
2
Ich füge einen funktionalen Stil für das obige Beispiel hinzu:oldDictionary.merge(newDictionary) { $1 }
Andrej
11

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
    }    
}
Orkoden
quelle
3
sehr schöne und saubere Lösung!
user3441734
11

Sie können dies versuchen

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

var temp = NSMutableDictionary(dictionary: dict1);
temp.addEntriesFromDictionary(dict2)
Uttam Kumar
quelle
10

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
}
farhadf
quelle
Das sieht interessant aus, aber was sind dund p?
ausrauben
1
d ist das anhaltende Ergebnis jeder Iteration des Reduktionsblocks und p ist das Element der Sammlung, das reduziert wird.
Farhadf
1
Dies scheint in der schnellen
Version
var Parameter sind in Swift 3
Dmitry Klochkov
Dies ist meine Lieblingslösung unter den hier genannten. Filtern / Zuordnen / Reduzieren von Gewinnen erneut für großartige, präzise Lösungen.
Gokeji
7

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})
    }
}
Justin Oroz
quelle
Tatsächlich wurde SE-110 zurückgesetzt, daher sollte die Swift 4-Version mit der Swift 3-Version identisch sein.
BallpointBen
5

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.

LeonS
quelle
4

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
}
Dmitry Klochkov
quelle
4

Swift 3, Wörterbucherweiterung:

public extension Dictionary {

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

}
aaannjjaa
quelle
4

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}
    }
}
John Montgomery
quelle
3

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 .

Jeehut
quelle
Das Installieren einer Bibliothek zur Verwendung einer einzelnen Funktion ist eine schlechte Praxis
HackaZach
@ HackaZach: Ich habe gerade meine Antwort aktualisiert, um den entsprechenden Teil des Frameworks aufzunehmen, um die Aufnahme der gesamten Bibliothek zu verhindern, wenn nur dieser kleine Teil benötigt wird. Ich behalte den Hinweis auf das Framework für Leute, die mehrere seiner Funktionen nutzen möchten. Ich hoffe, das hilft, gute Praxis zu halten!
Jeehut
3

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.
    }
Burak Dizlek
quelle
2

Sie können verwenden,

func addAll(from: [String: Any], into: [String: Any]){
    from.forEach {into[$0] = $1}
}
Sazzad Hissain Khan
quelle
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.

Anton
quelle
Entschuldigung, was meinst du genau?
Anton
Nur eine Präferenz. Scheint verwickelt zu sein, um eine Brücke zwischen den Sprachen zu schlagen. Es ist besser, sich an die Grenzen einer einzigen Sprache zu halten und gleichzeitig das Objekt schneller sterben zu lassen.
TruMan1
2
Ja, ich habe diese Antwort buchstäblich an dem Tag gepostet, an dem Swift sie angekündigt hat ....... Es gab also einen Grund
Anton
1
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.

Jim Driscoll
quelle
1

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) 
Kevin ABRIOUX
quelle
Dies funktioniert leider nur mit NSMutableDictionary und nicht mit nativen Swift-Wörterbüchern. Ich wünschte, dies würde Swift nativ hinzugefügt.
Chris Paveglio
0

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)")
Chris Conover
quelle
0

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
}
Apinho
quelle
Wenn Sie dies setzen, können Sie die erste Schleife entfernen: `var result = left`
NikeAlive
0

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]
Andy
quelle
5
jQuery ist zurück, yay!
Ben Sinclair
0

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]
Brian J. Roberts
quelle