Question

我有2个阵列：

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

我已经为他们添加了数据。现在出于可用性目的，我的目标是将它们全部组合成具有以下结构的字典

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

我一直在网上浏览，无法找到可行的解决方案。

非常感谢任何想法。

谢谢！

Answer 1

使用enumerated()：

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

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

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

专业方法是使用扩展程序：

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

修改： enumerate()→enumerated()（Swift 3→Swift 4）

Answer 2

从Xcode 9.0开始，您只需执行以下操作：

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

// Add data...

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

如果您的密钥不能保证是唯一的，请改用：

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

或

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

文档：

Answer 3

稍微不同的方法，它不需要数组具有相同的长度，因为zip函数将安全地处理它。

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

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

Answer 4

如果您希望更安全并确保每次都选择较小的数组（如果第二个数组小于第一个数组，则不会发生崩溃），然后执行以下操作：

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 5

这是一个通用的解决方案

cublasSgetrfBatched(handle, n, &dProdATA, lda, P, INFO, mybatch);

Answer 6

这是一个扩展，结合了以前的一些答案并接受所有序列，而不仅仅是阵列。

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

该扩展名不要求序列长度相同。如果你想要，那么这是一个带断言的扩展。

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

如何将两个数组合并到字典中？

6 个答案: