当我在Playground中使用for循环时，一切正常，直到我将for循环的第一个参数更改为最高值。 （按降序迭代）
这是一个错误吗？还有其他人有吗？
for index in 510..509
{
var a = 10
}
显示将要执行的迭代次数的计数器一直在滴答作响......
Xcode 6 beta 4添加了两个函数来迭代范围，其中一个步骤不是一个：stride(from: to: by:)，它与独占范围和stride(from: through: by:)一起使用，它与包含范围一起使用。
要以相反的顺序迭代范围，可以按如下方式使用它们：
for index in stride(from: 5, to: 1, by: -1) {
print(index)
}
//prints 5, 4, 3, 2
for index in stride(from: 5, through: 1, by: -1) {
print(index)
}
//prints 5, 4, 3, 2, 1
请注意，这些都不是Range成员函数。它们是返回StrideTo或StrideThrough结构的全局函数，它们的定义与Range结构不同。
此答案的先前版本使用by()结构的Range成员函数，该函数已在beta 4中删除。如果您想了解其工作原理，请查看编辑历史记录。
至于Swift 2.2，Xcode 7.3（10，2016年6月）：
for (index,number) in (0...10).enumerate() {
print("index \(index) , number \(number)")
}
for (index,number) in (0...10).reverse().enumerate() {
print("index \(index) , number \(number)")
}
输出：
index 0 , number 0
index 1 , number 1
index 2 , number 2
index 3 , number 3
index 4 , number 4
index 5 , number 5
index 6 , number 6
index 7 , number 7
index 8 , number 8
index 9 , number 9
index 10 , number 10
index 0 , number 10
index 1 , number 9
index 2 , number 8
index 3 , number 7
index 4 , number 6
index 5 , number 5
index 6 , number 4
index 7 , number 3
index 8 , number 2
index 9 , number 1
index 10 , number 0
var sum1 = 0
for i in 0...100{
sum1 += i
}
print (sum1)
for i in (10...100).reverse(){
sum1 /= i
}
print(sum1)
您可以考虑使用C风格的while循环。这在Swift 3中运行得很好：
var i = 5
while i > 0 {
print(i)
i -= 1
}
您可以使用reversed（）方法轻松反转值。
var i:Int
for i in 1..10.reversed() {
print(i)
}
reversed（）方法反转了值。
如果你有一个数组，你可以简单地这样做
func reverseArray(a: [Int]) -> [Int] {
var reverseArr = [Int]()
for i in stride(from: a.count-1, to: -1, by: -1){
reverseArr.append(a[i])
}
return reverseArr
}
将反向函数应用于范围以向后迭代：
对于Swift 1.2及更早版本：
// Print 10 through 1
for i in reverse(1...10) {
println(i)
}
它也适用于半开放范围：
// Print 9 through 1
for i in reverse(1..<10) {
println(i)
}
注意：reverse(1...10)创建了一个[Int]类型的数组，所以尽管这对于小范围可能没问题，但如果你的范围很大，那么使用如下所示的lazy或考虑接受的stride答案是明智的。
要避免创建大型数组，请使用lazy和reverse()。以下测试在Playground中高效运行，表明它没有创建一个万亿Ints阵列！
测试：
var count = 0
for i in lazy(1...1_000_000_000_000).reverse() {
if ++count > 5 {
break
}
println(i)
}
对于Xcode 7中的Swift 2.0：
for i in (1...10).reverse() {
print(i)
}
请注意，在Swift 2.0中，(1...1_000_000_000_000).reverse()的类型为ReverseRandomAccessCollection<(Range<Int>)>，所以这很好用：
var count = 0
for i in (1...1_000_000_000_000).reverse() {
count += 1
if count > 5 {
break
}
print(i)
}
对于Swift 3.0，reverse()已更名为reversed()：
for i in (1...10).reversed() {
print(i) // prints 10 through 1
}
针对Swift 3进行了更新
以下答案是可用选项的摘要。选择最适合您需求的产品。
reversed: numbers in a range向前
for index in 0..<5 {
print(index)
}
// 0
// 1
// 2
// 3
// 4
向后
for index in (0..<5).reversed() {
print(index)
}
// 4
// 3
// 2
// 1
// 0
reversed: elements in SequenceTypelet animals = ["horse", "cow", "camel", "sheep", "goat"]
向前
for animal in animals {
print(animal)
}
// horse
// cow
// camel
// sheep
// goat
向后
for animal in animals.reversed() {
print(animal)
}
// goat
// sheep
// camel
// cow
// horse
reversed: elements with an index有时在迭代集合时需要索引。为此你可以使用enumerate()，它返回一个元组。元组的第一个元素是索引，第二个元素是对象。
let animals = ["horse", "cow", "camel", "sheep", "goat"]
向前
for (index, animal) in animals.enumerated() {
print("\(index), \(animal)")
}
// 0, horse
// 1, cow
// 2, camel
// 3, sheep
// 4, goat
向后
for (index, animal) in animals.enumerated().reversed() {
print("\(index), \(animal)")
}
// 4, goat
// 3, sheep
// 2, camel
// 1, cow
// 0, horse
请注意，正如Ben Lachman在his answer中指出的那样，你可能想要做.enumerated().reversed()而不是.reversed().enumerated()（这会使指数增加）。
Stride是在不使用范围的情况下迭代的方法。有两种形式。代码末尾的注释显示了范围版本（假设增量大小为1）。
startIndex.stride(to: endIndex, by: incrementSize) // startIndex..<endIndex
startIndex.stride(through: endIndex, by: incrementSize) // startIndex...endIndex
向前
for index in stride(from: 0, to: 5, by: 1) {
print(index)
}
// 0
// 1
// 2
// 3
// 4
向后
将增量大小更改为-1可以让您向后移动。
for index in stride(from: 4, through: 0, by: -1) {
print(index)
}
// 4
// 3
// 2
// 1
// 0
请注意to和through的区别。
以2为增量转发
let animals = ["horse", "cow", "camel", "sheep", "goat"]
我在这个例子中使用2只是为了展示另一种可能性。
for index in stride(from: 0, to: 5, by: 2) {
print("\(index), \(animals[index])")
}
// 0, horse
// 2, camel
// 4, goat
向后
for index in stride(from: 4, through: 0, by: -1) {
print("\(index), \(animals[index])")
}
// 4, goat
// 3, sheep
// 2, camel
// 1, cow
// 0, horse
>>>。它不需要很多代码来定义，并使用如下：
for index in 5>>>0 {
print(index)
}
// 4
// 3
// 2
// 1
// 0
斯威夫特4号以后
for i in stride(from: 5, to: 0, by: -1) {
print(i)
}
//prints 5, 4, 3, 2, 1
for i in stride(from: 5, through: 0, by: -1) {
print(i)
}
//prints 5, 4, 3, 2, 1, 0
对于Swift 2.0及更高版本，您应该对范围集合应用反向
for i in (0 ..< 10).reverse() {
// process
}
它已在Swift 3.0中重命名为.reversed（）
使用Swift 5，根据您的需要，您可以选择以下四个Playground代码示例中的一个来解决您的问题。
ClosedRange reversed() methodClosedRange有一种叫做reversed()的方法。 reversed()方法有以下声明：
func reversed() -> ReversedCollection<ClosedRange<Bound>>
返回以相反顺序显示集合元素的视图。
用法：
let reversedCollection = (0 ... 5).reversed()
for index in reversedCollection {
print(index)
}
/*
Prints:
5
4
3
2
1
0
*/
作为替代方案，您可以使用Range reversed()方法：
let reversedCollection = (0 ..< 6).reversed()
for index in reversedCollection {
print(index)
}
/*
Prints:
5
4
3
2
1
0
*/
sequence(first:next:) functionSwift标准库提供了一个名为sequence(first:next:)的函数。 sequence(first:next:)有以下声明：
func sequence<T>(first: T, next: @escaping (T) -> T?) -> UnfoldFirstSequence<T>
返回由
first形成的序列和next的重复惰性应用。
用法：
let unfoldSequence = sequence(first: 5, next: {
$0 > 0 ? $0 - 1 : nil
})
for index in unfoldSequence {
print(index)
}
/*
Prints:
5
4
3
2
1
0
*/
stride(from:through:by:) functionSwift标准库提供了一个名为stride(from:through:by:)的函数。 stride(from:through:by:)有以下声明：
func stride<T>(from start: T, through end: T, by stride: T.Stride) -> StrideThrough<T> where T : Strideable
返回从起始值开始的序列，并且可能包括结束值，步长为指定的量。
用法：
let sequence = stride(from: 5, through: 0, by: -1)
for index in sequence {
print(index)
}
/*
Prints:
5
4
3
2
1
0
*/
作为替代方案，您可以使用stride(from:to:by:)：
let sequence = stride(from: 5, to: -1, by: -1)
for index in sequence {
print(index)
}
/*
Prints:
5
4
3
2
1
0
*/
AnyIterator init(_:) initializerAnyIterator有一个名为init(_:)的初始化程序。 init(_:)有以下声明：
init(_ body: @escaping () -> AnyIterator<Element>.Element?)
创建一个迭代器，在其
next()方法中包装给定的闭包。
用法：
var index = 5
guard index >= 0 else { fatalError("index must be positive or equal to zero") }
let iterator = AnyIterator({ () -> Int? in
defer { index = index - 1 }
return index >= 0 ? index : nil
})
for index in iterator {
print(index)
}
/*
Prints:
5
4
3
2
1
0
*/
如果需要，您可以通过为Int创建扩展方法并将迭代器包装在其中来重构以前的代码：
extension Int {
func iterateDownTo(_ endIndex: Int) -> AnyIterator<Int> {
var index = self
guard index >= endIndex else { fatalError("self must be greater than or equal to endIndex") }
let iterator = AnyIterator { () -> Int? in
defer { index = index - 1 }
return index >= endIndex ? index : nil
}
return iterator
}
}
let iterator = 5.iterateDownTo(0)
for index in iterator {
print(index)
}
/*
Prints:
5
4
3
2
1
0
*/
在Swift 4和后者中
let count = 50//For example
for i in (1...count).reversed() {
print(i)
}
Swift 4.0
for i in stride(from: 5, to: 0, by: -1) {
print(i) // 5,4,3,2,1
}
如果要包含to值：
for i in stride(from: 5, through: 0, by: -1) {
print(i) // 5,4,3,2,1,0
}
如果一个人想要反过来迭代一个数组（Array或更普遍的任何SequenceType）。您还有一些其他选择。
首先你可以reverse()数组并正常循环它。但是我更喜欢在很多时候使用enumerate()，因为它输出一个包含对象及其索引的元组。
这里要注意的一件事是，以正确的顺序调用它们很重要：
for (index, element) in array.enumerate().reverse()
按降序产生索引（这是我通常所期望的）。然而：
for (index, element) in array.reverse().enumerate()（与NSArray的reverseEnumerator更接近）
向后走数组但输出升序索引。