Array di Swift mendukung operator + = untuk menambahkan konten dari satu Array ke Array yang lain. Apakah ada cara mudah untuk melakukannya untuk kamus?

misalnya:

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

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

Anda dapat menentukan +=operator untuk Dictionary, misalnya,

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

Dalam Swift 4, seseorang harus menggunakan merging(_:uniquingKeysWith:):

Contoh:

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]

Bagaimana tentang

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

Itu menambahkan semua kunci dan nilai dict2 ke dalamct1.

Saat ini, melihat Referensi Perpustakaan Swift untuk Kamus, tidak ada cara untuk dengan mudah memperbarui kamus dengan yang lain.

Anda dapat menulis ekstensi untuk melakukannya

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 menyediakan merging(_:uniquingKeysWith:), jadi untuk kasus Anda:

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

Penutupan steno mengembalikan $1, oleh karena itu nilai dict2 akan digunakan ketika ada konflik dengan kunci.

Itu tidak dibangun ke dalam pustaka Swift tetapi Anda dapat menambahkan apa yang Anda inginkan dengan overloading operator, misalnya:

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
}

Ini membebani +operator untuk Kamus yang sekarang dapat Anda gunakan untuk menambahkan kamus dengan +operator, misalnya:

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

Kekal

Saya lebih suka menggabungkan / menyatukan kamus abadi dengan +operator jadi saya mengimplementasikannya seperti:

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

Yg mungkin berubah

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

Tidak perlu memiliki ekstensi kamus apa pun sekarang. Kamus Swift (Xcode 9.0+) telah mendapatkan fungsionalitas untuk ini. Silahkan lihat di sini . Di bawah ini adalah contoh cara menggunakannya

  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]

Varian yang lebih mudah dibaca menggunakan ekstensi.

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

Anda bisa mencoba ini

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

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

Anda juga dapat menggunakan pengurangan untuk menggabungkannya. Coba ini di taman bermain

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
}

Saya merekomendasikan Perpustakaan SwifterSwift . Namun, jika Anda tidak ingin menggunakan seluruh pustaka dan semua tambahannya yang hebat, Anda bisa memanfaatkan ekstensi Kamus mereka:

Swift 3+

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

Anda dapat mengulangi kombinasi Nilai Kunci dengan nilai yang ingin Anda gabungkan dan menambahkannya melalui metode updateValue (forKey :):

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

Sekarang semua nilai dictionaryTwo ditambahkan ke dictionaryOne.

Sama dengan jawaban @ farhadf tetapi diadopsi untuk 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
}

Swift 3, ekstensi kamus:

public extension Dictionary {

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

}

Beberapa kelebihan beban yang lebih ramping untuk 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}
    }
}

Anda dapat menambahkan Dictionaryekstensi seperti ini:

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

Kemudian penggunaan adalah sebagai sederhana sebagai berikut:

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

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

Jika Anda lebih menyukai kerangka kerja yang juga mencakup beberapa fitur yang lebih berguna maka checkout HandySwift . Cukup impor ke proyek Anda dan Anda dapat menggunakan kode di atas tanpa menambahkan sendiri ekstensi ke proyek.

Tidak perlu ekstensi atau fungsi tambahan lagi. Anda bisa menulis seperti itu:

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

Kamu bisa memakai,

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

Anda dapat menggunakan fungsi bridgeToObjectiveC () untuk membuat kamus menjadi NSDictionary.

Akan seperti berikut ini:

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)

Kemudian Anda dapat mengkonversi kembali NSDictionary (menggabungkan) atau melakukan apa pun.

import Foundation

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

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

Hasilnya adalah NSMutableDictionary bukan kamus yang diketik Swift, tetapi sintaks untuk menggunakannya adalah sama ( out["a"] == 1dalam hal ini) sehingga Anda hanya akan memiliki masalah jika Anda menggunakan kode pihak ketiga yang mengharapkan kamus Swift, atau benar-benar perlu pengecekan tipe.

Jawaban singkatnya di sini adalah Anda benar-benar harus mengulang. Bahkan jika Anda tidak memasukkannya secara eksplisit, itulah metode yang Anda panggil (addEntriesFromDictionary: di sini) akan dilakukan. Saya akan menyarankan jika Anda sedikit tidak jelas mengapa hal itu terjadi, Anda harus mempertimbangkan bagaimana Anda akan menggabungkan node daun dari dua B-tree.

Jika Anda benar-benar membutuhkan jenis kamus asli Swift sebagai gantinya, saya sarankan:

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

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

Kelemahan dari pendekatan ini adalah bahwa indeks kamus - namun demikian dilakukan - dapat dibangun kembali beberapa kali dalam loop, jadi dalam praktiknya ini sekitar 10x lebih lambat daripada pendekatan NSMutableDictionary.

Semua tanggapan ini rumit. Ini solusi saya untuk 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) 

Kebutuhan saya berbeda, saya perlu menggabungkan set data bersarang tidak lengkap tanpa clobbering.

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

Ini lebih sulit daripada yang saya inginkan. Tantangannya adalah dalam pemetaan dari pengetikan dinamis ke pengetikan statis, dan saya menggunakan protokol untuk menyelesaikannya.

Juga patut dicatat adalah bahwa ketika Anda menggunakan sintaks literal kamus, Anda benar-benar mendapatkan jenis dasar, yang tidak mengambil ekstensi protokol. Saya membatalkan upaya saya untuk mendukung itu karena saya tidak dapat menemukan mudah untuk memvalidasi keseragaman elemen koleksi.

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

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

Saya hanya akan menggunakan perpustakaan Dollar .

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

Menggabungkan semua kamus bersama-sama dan kamus yang terakhir menimpa nilai pada kunci yang diberikan

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]

Ini adalah ekstensi yang bagus yang saya tulis ...

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

menggunakan:

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

dict1 = dict1.mergeOnto(target: dict2)

Kemudian, dict1 akan dimodifikasi menjadi

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