Swift中的反向范围

有没有办法在Swift中使用反向范围？

例如：

for i in 5...1 {
  // do something
}

是一个无限循环。

在较新版本的Swift中，该代码可以编译，但在运行时会出现错误：

致命错误：无法使用upperBound <lowerBound形成Range

我知道我可以1..5代替使用计算j = 6 - i和j用作索引。我只是想知道是否还有更清晰的地方？

更新以获取最新的Swift 3（仍可在Swift 4中使用）

您可以reversed()在范围上使用该方法

for i in (1...5).reversed() { print(i) } // 5 4 3 2 1

或stride(from:through:by:)方法

for i in stride(from:5,through:1,by:-1) { print(i) } // 5 4 3 2 1

stide(from:to:by:) 相似，但不包括最后一个值

for i in stride(from:5,to:0,by:-1) { print(i) } // 5 4 3 2 1

更新以获取最新的Swift 2

首先，协议扩展更改了reverse使用方式：

for i in (1...5).reverse() { print(i) } // 5 4 3 2 1

Xide 7 Beta 6中对Stride进行了重新设计。新用法是：

for i in 0.stride(to: -8, by: -2) { print(i) } // 0 -2 -4 -6
for i in 0.stride(through: -8, by: -2) { print(i) } // 0 -2 -4 -6 -8

它也适用于Doubles：

for i in 0.5.stride(to:-0.1, by: -0.1) { print(i) }

提防浮点数在这里比较界限。

Swift 1.2的早期编辑：从Xcode 6 Beta 4开始，by和ReverseRange不再存在：[

如果您只是想反转范围，则只需使用反转功能即可：

for i in reverse(1...5) { println(i) } // prints 5,4,3,2,1

如0x7fffffff所发布的那样，有一个新的跨步构造可用于迭代和递增任意整数。苹果还表示，浮点支持即将到来。

来自他的回答：

for x in stride(from: 0, through: -8, by: -2) {
    println(x) // 0, -2, -4, -6, -8
}

for x in stride(from: 6, to: -2, by: -4) {
    println(x) // 6, 2
}

这种不对称性令人不安：

for i in (1..<5).reverse()

...与此相反：

for i in 1..<5 {

这意味着每次我想做一个反向范围时，我都必须记住加上括号，并且必须.reverse()在最后写上括号，像拇指一样伸出来。与C样式的for循环（对称地递增和递减）相比，这确实很丑陋。因此，我倾向于使用C样式进行循环。但是在Swift 2.2中，C风格的for循环将消失！因此，我不得不急于用这种丑陋的.reverse()结构替换所有递减的C风格的循环代码-一直在想，为什么地球上没有反向范围运算符？

可是等等！这是Swift-我们可以定义自己的运算符！！开始了：

infix operator >>> {
    associativity none
    precedence 135
}

func >>> <Pos : ForwardIndexType where Pos : Comparable>(end:Pos, start:Pos)
    -> ReverseRandomAccessCollection<(Range<Pos>)> {
        return (start..<end).reverse()
}

所以现在我可以说：

for i in 5>>>1 {print(i)} // 4, 3, 2, 1

这包括刚刚发生在我的代码，但它最常见的情况是遥遥领先的最常见的情况，所以这是目前我所需要的。

我遇到了运营商的内部危机。我本来希望使用>..，因为与的含义相反..<，但这是不合法的：它出现在非点之后不能使用点。我考虑过，..>但认为很难区别于此..<。有趣的>>>是它向您尖叫：“ 下去！” （当然，您可以自由地提出另一个运算符。但是我的建议是：对于超对称性，定义<<<以执行..<操作，现在您已经拥有了<<<，>>>对称且易于键入。）

Swift 3版本（Xcode 8种子6）：

infix operator >>> : RangeFormationPrecedence
func >>><Bound>(maximum: Bound, minimum: Bound) ->
    ReversedRandomAccessCollection<CountableRange<Bound>> 
    where Bound : Comparable, Bound.Stride : Integer {
        return (minimum..<maximum).reversed()
}

Swift 4版本（Xcode 9 beta 3）：

infix operator >>> : RangeFormationPrecedence
func >>><Bound>(maximum: Bound, minimum: Bound)
    -> ReversedRandomAccessCollection<CountableRange<Bound>>
    where Bound : Comparable & Strideable { 
        return (minimum..<maximum).reversed()
}

Swift 4.2版本（Xcode 10 beta 1）：

infix operator >>> : RangeFormationPrecedence
func >>><Bound>(maximum: Bound, minimum: Bound)
    -> ReversedRandomAccessCollection<Range<Bound>>
    where Bound : Strideable { 
        return (minimum..<maximum).reversed()
}

Swift 5版本（Xcode 10.2.1）：

infix operator >>> : RangeFormationPrecedence
func >>><Bound>(maximum: Bound, minimum: Bound)
    -> ReversedCollection<Range<Bound>>
    where Bound : Strideable {
        return (minimum..<maximum).reversed()
}

随着我们逐步通过测试版，该问题的答案似乎有所改变。从beta 4开始，by()功能和ReversedRange类型均已从语言中删除。如果您想将范围调小，现在可以选择以下选项：

1：创建一个正向范围，然后使用该reverse()功能将其反向。

for x in reverse(0 ... 4) {
    println(x) // 4, 3, 2, 1, 0
}

for x in reverse(0 ..< 4) {
    println(x) // 3, 2, 1, 0
}

2：使用stride()beta 4中添加的新函数，其中包括指定开始索引和结束索引以及进行迭代的数量的函数。

for x in stride(from: 0, through: -8, by: -2) {
    println(x) // 0, -2, -4, -6, -8
}

for x in stride(from: 6, to: -2, by: -4) {
    println(x) // 6, 2
}

请注意，我在这篇文章中也包括了新的独占范围运算符。..被替换为..<。

编辑：从Xcode 6 beta 5发行说明，Apple添加了以下建议来处理此问题：

ReverseRange已被删除；使用lazy（x ..

这是一个例子。

for i in lazy(0...5).reverse() {
    // 0, 1, 2, 3, 4, 5
}

Xcode 7，测试版2：

for i in (1...5).reverse() {
  // do something
}

Swift 3，4+：您可以这样操作：

for i in sequence(first: 10, next: {$0 - 1}) {

    guard i >= 0 else {
        break
    }
    print(i)
}

结果：10，9，8 ... 0

您可以按自己喜欢的任何方式自定义它。有关更多信息，请参阅func sequence<T>参考

这可能是另一种方式。

(1...5).reversed().forEach { print($0) }

Reverse（）函数用于反向编号。

Var n：Int //输入数字

对于1中的i ... n.reverse（）{打印（i）}