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

我有这个密码

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

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

提前谢谢

没有“下一个键”这样的东西；字典没有顺序

但是，由于您正在遍历字典

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

我假设你的意思是：在这个迭代中，我怎么知道下一个迭代中的

k

是什么

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

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

let arr = Array(myDict)
for (ix, (k,v)) in enumerate(arr) {
    println("This key is \(k)")
    if ix < arr.count-1 {
        println("The next key is \(arr[ix+1].0)")
    }
}

让arr=Array（myDict）
对于枚举（arr）中的（ix，（k，v））{
println（“此键为\（k）”）
如果ix

---

---

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

我不知道这是否是您想要的，但您可以 以与迭代类似的方式迭代字典 使用

字典索引作为索引，通过数组：

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
当前键：条，当前值：2
下一个键：baz，下一个值：3
当前键：baz，当前值：3
下一个键：foo，下一个值：1
当前键：foo，当前值：1
一种可能的解决方案是创建
生成器
，它按顺序返回当前值和以前的值。为此，您需要一个自定义的
生成器
，它将从
下一个
返回一个元组，其中包含序列中的上一个值和当前值：

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

现在您需要一个函数，该函数将从符合
SequenceType
的对象创建一个
PairSequence
：

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

假设字典中键的顺序未定义，您试图实现什么？
advance（idx，1）
或：
idx.succession（）
for var idx=dict.startIndex；idx！=dict.endIndex；idx++
或：
用于dict.startIndex中的idx..我还发现
索引（dict）
比
dict.startIndex..@AirspeedVelocity好：事实上，我已经忘记了这一点。（这仍然是我的答案吗？）除非我弄错了，
zip（values，dropFirst（values））
将给出与您的
对（values）
相同的顺序。谢谢，我没有意识到这一点。那肯定简单多了！谢谢@matt！你是对的，这起作用了，我为没有详细说明而道歉。我确实想知道在这个迭代中，在下一个迭代中k是什么
struct PairSequence<Base: SequenceType> : SequenceType {
    let generator: PairGenerator<Base.Generator>

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

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

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

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