Question

我有这段代码

<table>
    <tr onclick="selectRow(this)";>
        <td><a href="something">Link Text</a></td>
        <td><input id="someID" type="text" value="display"></td>
    </tr>
</table>

如何访问字典中的下一个键（例如myDict [k + 1]）？

提前致谢！

Answer 1

没有＆＃34;下一个键＆＃34 ;;字典没有顺序。

但是，你正在迭代字典......

for (k, v) in myDict {
    println(k)
}

我会假设你的意思是：我怎么知道这个迭代，下一个 {/ 1}} >迭代？

一个简单的解决方案是将字典强制转换为数组（键值元组）：

k

现在你有了整数索引。所以你可以这样枚举它：

let arr = Array(myDict)

当然，事实是你可以直接枚举字典，但索引不是整数，因此它们更难以使用。 Martin R也展示了一种说明这一点的方法。

Answer 2

我不知道这是否是您正在寻找的，但您可以在＆＃34;类似的＆＃34;中迭代字典。迭代的方式通过使用DictionaryIndex<Key, Value>作为索引的数组：

let dict = [ "foo" : 1, "bar" : 2, "baz" : 3]

for idx in indices(dict) {

    let (k, v) = dict[idx]
    println("Current key: \(k), current value: \(v)")

    let nextIdx = idx.successor()
    if nextIdx != dict.endIndex {
        let (k1, v1) = dict[nextIdx]
        println("Next key: \(k1), next value: \(v1)")
    }
}

示例输出：

Current key: bar, current value: 2
Next key: baz, next value: 3
Current key: baz, current value: 3
Next key: foo, next value: 1
Current key: foo, current value: 1

Answer 3

一种可能的解决方案是创建Generator，它返回序列中的当前值和先前值。为此，您需要一个自定义Generator，它将返回一个元组，其中包含序列中的前一个和当前值，来自next：

struct PairGenerator<Base: GeneratorType> : GeneratorType {
    typealias ElementPair = (previousElement: Base.Element, currentElement: Base.Element)

    private var base: Base
    private var previousElement: Base.Element?

    init(_ base: Base) {
        self.base = base
    }

    mutating func next() -> ElementPair? {
        if previousElement == nil { previousElement = base.next() }
        let currentElement = base.next()

        // Since `base.next()` returns `nil` when the end of the sequence
        // is reached, we need to check `previousElement` and `currentElement ` 
        // aren't `nil`. If either of them are, `nil` will be returned to signal
        // there aren't any pairs left.
        if let prev = previousElement, curr = currentElement {
            previousElement = currentElement
            return (prev, curr)
        }

        return nil
    }
}

然后PairGenerator存储在PairSequence中，符合SequenceType;这意味着您可以在for循环中迭代它。

struct PairSequence<Base: SequenceType> : SequenceType {
    let generator: PairGenerator<Base.Generator>

    init(_ base: Base) {
        generator = PairGenerator(base.generate())
    }

    func generate() -> PairGenerator<Base.Generator> {
        return generator
    }
}

现在你需要一个能够从符合PairSequence的对象创建SequenceType的函数：

func pairs<Seq: SequenceType>(base: Seq) -> PairSequence<Seq> {
    return PairSequence(base)
}

最后，您可以这样使用：

let myDict = ["1": 1, "2": 2, "3": 3, "4": 4]
let values = Array(myDict.values).sorted(<)

for (prev, curr) in pairs(values) {
    println("\(prev), \(curr)")
}

// Prints:
// 1, 2
// 2, 3
// 3, 4

您可以使用pairs(myDict)，但是像@Martin R和@matt说的那样 - 字典没有订单，因此您可能无法按照预期的顺序获得结果。

有关SequenceType和GeneratorType的详情，建议您查看Playing With Swift和Generators In Swift。

或者，正如@Martin R在评论中指出的那样，你可以使用：

for (prev, curr) in zip(values, dropFirst(values)) {
    println("\(prev), \(curr)")
}

如何访问Swift词典中的下一个键？

3 个答案: