对于Swift 2.0及以上版本，你应该在range collection上应用reverse

for i in (0 ..< 10).reverse() {
  // process
}

在Swift 3.0中已被重命名为.reversed()

这将以相反的顺序递减1。

let num1 = [1,2,3,4,5]
for item in nums1.enumerated().reversed() { 

    print(item.offset) // Print the index number: 4,3,2,1,0
    print(item.element) // Print the value :5,4,3,2,1

}

或者你可以用这个index value属性

let num1 = [1,2,3,4,5]
for (index,item) in nums1.enumerated().reversed() { 

    print(index) // Print the index number: 4,3,2,1,0
    print(item) // Print the value :5,4,3,2,1

}

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结构体的定义不同。

这个答案的前一个版本使用了Range结构体的by()成员函数，该函数在beta 4中被删除。如果您想了解它是如何工作的，请检查编辑历史记录。

对范围应用reverse函数进行反向迭代:

对于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中高效运行，显示它没有创建一个包含一万亿int的数组!

测试:

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更新

下面的答案是可用选项的摘要。选择一个最适合你的需求。

反转:范围内的数字

向前

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: SequenceType中的元素

let 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

反转:带索引的元素

在迭代一个集合时，有时需要索引。为此，您可以使用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在他的回答中指出的那样，您可能希望使用. enumeration ().reversed()而不是.reversed(). enumeration()(这会使索引数增加)。

步:数字

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的区别。

stride: SequenceType的元素

向前递增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 

笔记

@matt有一个有趣的解决方案，他定义了自己的反向运算符，并称之为>>>。它不需要太多代码来定义，并像这样使用: 为索引5>>>0 { 打印(索引) ｝ / / 4 / / 3 / / 2 / / 1 / / 0 查看从Swift 3中删除的c风格For循环

在Swift 4及后续版本中

    let count = 50//For example
    for i in (1...count).reversed() {
        print(i)
    }