带增量的循环的Swift 3

Question

如何在Swift3中编写以下内容？

for (f = first; f <= last; f += interval)          
{
    n += 1
}

这是我自己的尝试

for _ in 0.stride(to: last, by: interval)
{
    n += 1
}

Answer 1

简单地说，Swift 3.0的工作代码：

let (first, last, interval) = (0, 100, 1)
var n = 0
for _ in stride(from: first, to: last, by: interval) {
    n += 1
}

Answer 2

使用Swift 5，您可以从以下5个示例中选择一个来解决您的问题。

let first = 0
let last = 10
let interval = 2

let sequence = stride(from: first, to: last, by: interval)

for element in sequence {
    print(element)
}

/*
prints:
0
2
4
6
8
*/

let first = 0
let last = 10
let interval = 2

let unfoldSequence = sequence(first: first, next: {
    $0 + interval < last ? $0 + interval : nil
})

for element in unfoldSequence {
    print(element)
}

/*
prints:
0
2
4
6
8
*/

let anySequence = AnySequence<Int>({ () -> AnyIterator<Int> in
    let first = 0
    let last = 10
    let interval = 2

    var value = first
    return AnyIterator<Int> {
        defer { value += interval }
        return value < last ? value : nil
    }
})

for element in anySequence {
    print(element)
}

/*
prints:
0
2
4
6
8
*/

let first = 0
let last = 10
let interval = 2

let range = first ..< last
let lazyCollection = range.lazy.filter({ $0 % interval == 0 })

for element in lazyCollection {
    print(element)
}

/*
prints:
0
2
4
6
8
*/

let first = 0
let last = 10
let interval = 2

let range = first ..< last
let lazyCollection = range.lazy.compactMap({ $0 % interval == 0 ? $0 : nil })

for element in lazyCollection {
    print(element)
}

/*
prints:
0
2
4
6
8
*/

Answer 3

在Swift 2.2中，我们可以（正如您在自己的尝试中所尝试的那样）利用协议中的stride（通过：by:）和stride（到：by:）功能

/* Swift 2.2: stride example usage */
let from = 0
let to = 10
let through = 10
let by = 1
for _ in from.stride(through, by: by) { } // from ... through (steps: 'by')
for _ in from.stride(to, by: by) { }      // from ..< to      (steps: 'by')

而在Swift 3.0中，这两个功能已从可移动的中删除，以支持全局功能stride（from:to:by:）和stride（from:to:by:）；因此，上述等效Swift 3.0版本如下

/* Swift 3.0: stride example usage */
let from = 0
let to = 10
let through = 10
let by = 1
for _ in stride(from: from, through: through, by: by) { }
for _ in stride(from: from, to: to, by: by) { }

在您的示例中，您希望使用闭合间隔步幅备选方案步幅（from:to:by:），因为for循环中的不变量使用小于或等于（

/* example values of your parameters 'first', 'last' and 'interval' */
let first = 0
let last = 10
let interval = 2
var n = 0
for f in stride(from: first, through: last, by: interval) { 
    print(f)
    n += 1 
} // 0 2 4 6 8 10
print(n) // 6

其中，自然地，我们使用您的for循环仅作为从for循环到跨步的一个示例，因为您可以自然地，对于您的特定示例，只计算n，而不需要循环（n=1（最后一个第一）/间隔）。

随着进化建议SE-0094的实施，Swift 3.0引入了全局序列函数：

• 序列（第一个：下一个：），

对于具有更复杂的迭代增量关系的情况（本例中不是这种情况），这可能是跨步的合适替代方案。

声明（s）

func sequence<T>(first: T, next: @escaping (T) -> T?) -> 
         UnfoldSequence<T, (T?, Bool)>

func sequence<T, State>(state: State, 
                        next: @escaping (inout State) -> T?) ->
           UnfoldSequence<T, State>

我们将简要介绍这两个函数中的第一个。Next参数采用一个闭包，该闭包应用一些逻辑来懒惰地构造给定当前序列元素的下一个序列元素（从first开始）。当Next返回nil或无限时，如果Next从不返回nil，则序列终止。

应用于上述简单的恒定步幅示例，sequence方法有点冗长和过度。适合此目的的stride解决方案：

let first = 0
let last = 10
let interval = 2
var n = 0
for f in sequence(first: first,
                  next: { $0 + interval <= last ? $0 + interval : nil }) {
    print(f)
    n += 1
} // 0 2 4 6 8 10
print(n) // 6

然而，序列功能对于非恒定步幅的情况非常有用，例如，如以下Q中所述的示例

• swift中的快速循环和动态范围

只需注意使用最终的nil返回终止序列（如果不是：“无限”元素生成），或者，当Swift 3.1到达时，结合序列的前缀（while:）方法使用其惰性生成，如进化提案SE-0045所述。后者应用于这个答案的运行示例，使得序列方法不那么冗长，显然包括元素生成的终止标准。

/* for Swift 3.1 */
// ... as above
for f in sequence(first: first, next: { $0 + interval })
    .prefix(while: { $0 <= last }) {
    print(f)
    n += 1
} // 0 2 4 6 8 10
print(n) // 6