Jak scalić dwie tablice w słowniku?

Question

Mam 2 tablice:

var identic = [String]() 
    var linef = [String]() 

Mam dołączone je danymi. Teraz dla celów użyteczności moim celem jest, aby połączyć je wszystkie w słowniku o następującej strukturze

FullStack = ["identic 1st value":"linef first value", "identic 2nd value":"linef 2nd value"] 

Byłem przeglądania wokół netto i nie mógł znaleźć praktyczne rozwiązanie do tego.

Wszelkie pomysły są bardzo cenne.

Dziękujemy!

Answer 1

To brzmi jak praca dla .enumerated()!

var arrayOne: [String] = [] 
var arrayTwo: [String] = [] 

var dictionary: [String: String] = [:] 

for (index, element) in arrayOne.enumerated() 
{ 
    dictionary[element] = arrayTwo[index] 
} 

Jednak jeśli chcesz pro podejście do , należy użyć rozszerzenia:

extension Dictionary 
{ 
    public init(keys: [Key], values: [Value]) 
    { 
     precondition(keys.count == values.count) 

     self.init() 

     for (index, key) in keys.enumerate() 
     { 
      self[key] = values[index] 
     } 
    } 
} 

Edit:enumerate() → enumerated() (Swift 3 → Swift 4)

Answer 2

jest to ogólne rozwiązanie:

func dictionaryFromKeysAndValues<K : Hashable, V>(keys:[K], values:[V]) -> Dictionary<K, V> 
{ 
    assert((count(keys) == count(values)), "number of elements odd") 
    var result = Dictionary<K, V>() 
    for i in 0..<count(keys) { 
    result[keys[i]] = values[i] 
    } 
    return result 
} 

var identic = ["identic 1st value", "identic 2nd value", "identic 3rd value"] 
var linef = ["linef 1st value", "linef 2nd value", "linef 3rd value"] 

let mergedDictionary = dictionaryFromKeysAndValues(identic, linef) 

Answer 3

Jeśli chcesz być bezpieczniejszy i upewnić się, że wybierasz mniejszą liczbę komórek za każdym razem (aby uniknąć potencjalnego awarii, jeśli druga macie jest mniejsza niż pierwsza), wykonaj następujące czynności:

var identic = ["A", "B", "C", "D"] 
var linef = ["1", "2", "3"] 

var Fullstack = [String: String]() 
for i in 0..<min(linef.count, identic.count) { 
    Fullstack[identic[i]] = linef[i] 
} 

print(Fullstack) // "[A: 1, B: 2, C: 3]" 

Answer 4

Nieco inna metoda, która nie wymaga, aby tablice były tej samej długości, ponieważ funkcja zip będzie ją bezpiecznie obsługiwać.

extension Dictionary { 
    init(keys: [Key], values: [Value]) { 
     self.init() 

     for (key, value) in zip(keys, values) { 
      self[key] = value 
     } 
    } 
} 

Answer 5

Oto rozszerzenie, które łączy niektóre z poprzednich odpowiedzi i akceptuje wszystkie Sekwencje, a nie tylko Tablice.

public extension Dictionary { 
    init<K: Sequence, V: Sequence>(keys: K, values: V) where K.Element == Key, V.Element == Value, K.Element: Hashable { 
     self.init() 
     for (key, value) in zip(keys, values) { 
      self[key] = value 
     } 
    } 
} 

To rozszerzenie nie wymaga, aby sekwencje były tej samej długości. Jeśli chcesz, tutaj jest rozszerzenie z asercją.

public extension Dictionary { 
    init<K: Sequence, V: Sequence>(keys: K, values: V) where K.Element == Key, V.Element == Value, K.Element: Hashable { 
     self.init() 
     var keyIterator = keys.makeIterator() 
     for value in values { 
      let key = keyIterator.next() 
      assert(key != nil, "The value sequence was longer.") 
      self[key!] = value 
     } 
     assert(keyIterator.next() == nil, "The key sequence was longer.") 
    } 
} 

Answer 6

Począwszy od Xcode 9.0, można po prostu zrobić:

var identic = [String]() 
var linef = [String]() 

// Add data... 

let fullStack = Dictionary(uniqueKeysWithValues: zip(identic, linef)) 

Jeśli klucze nie są gwarantowane jest unikatowy, użyj zamiast tego:

let fullStack = 
    Dictionary(zip(identic, linef), uniquingKeysWith: { (first, _) in first }) 

lub

let fullStack = 
    Dictionary(zip(identic, linef), uniquingKeysWith: { (_, last) in last }) 

Dokumentacja:

• https://developer.apple.com/documentation/swift/dictionary/2894798-init

• https://developer.apple.com/documentation/swift/dictionary/2892961-init