对我来说，这是最好的办法。

var arrayOfNums = [1,4,5,68,9,10]

for i in 0..<arrayOfNums.count {
    print(arrayOfNums[arrayOfNums.count - i - 1])
}

反转一个数组只需要一个步骤。reverse()

var arrOfnum = [1,2,3,4,5,6]
arrOfnum.reverse()

使用Swift 5，根据您的需要，您可以选择以下四个Playground代码示例中的一个来解决您的问题。

---

# 1。使用ClosedRange reversed()方法

ClosedRange有一个叫做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
*/

---

# 2。使用sequence(first:next:)函数

Swift标准库提供了一个名为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
*/

---

# 3。使用stride(from:through:by:)函数

Swift标准库提供了一个名为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
*/

---

# 4。使用AnyIterator init(_:)初始化器

AnyIterator有一个名为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
*/

如果希望反向遍历数组(array或更一般的任何SequenceType)。您还有一些额外的选项。

首先，您可以reverse()数组并像往常一样遍历它。但是我更喜欢使用enumerate()，因为它输出一个包含对象和它的索引的元组。

这里需要注意的一件事是，以正确的顺序调用它们是很重要的:

For (index, element) in array.enumerate().reverse()

按降序生成索引(这是我通常期望的)。而:

for (index, element) in array.reverse().enumerate()(与NSArray的reverseEnumerator更接近)

反向遍历数组，但输出升序索引。

对我来说，这是最好的办法。

var arrayOfNums = [1,4,5,68,9,10]

for i in 0..<arrayOfNums.count {
    print(arrayOfNums[arrayOfNums.count - i - 1])
}

Swift向前

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