swift - 快速添加对范围运算符的支持？ (例如，红色...紫色的 x)

Question

在 Swift 中，我们可以使用 range operators ( ... 和 ..< )循环范围:

for i in 0...4 { ... }

假设我有很多颜色:

let red: MyColor
let orange: MyColor
let yellow: MyColor
let green: MyColor
let blue: MyColor
let indigo: MyColor
let violet: MyColor

let black: MyColor
let brown: MyColor

如何支持范围运算符，以便我可以按彩虹顺序循环颜色？

for rainbowColor in red...violet { ... }

Answer 1

(注意这是Swift 3，如果你想要Swift 2.2，请参阅Senseful的答案，与旧协议(protocol)基本相同。)

您想要Color成为Strideable与 Stride的Int 。然后你得到...和..<免费。让我们这样做吧。

首先，我假设您的类型是这样的。这只是一个例子。只要您能够实现Strideable，您就可以做所有种类的事情。您似乎想要结构而不是枚举(这很好)，所以让我们使用结构。这只是意味着任何人都可以添加其他颜色，并且您必须在设计中考虑到这一点。颜色需要一些东西来区分它们，所以我们会给它们一个名字。如果是类的话，也能区分出来。

struct Color {
    let name: String

    static let red = Color(name: "red")
    static let orange = Color(name: "orange")
    static let yellow = Color(name: "yellow")
    static let green = Color(name: "green")
    static let blue = Color(name: "blue")
    static let indigo = Color(name: "indigo")
    static let violet = Color(name: "violet")
}

Strideable 的第一条规则是 Equatable。

extension Color: Equatable {
    static func == (lhs: Color, rhs: Color) -> Bool {
        return lhs.name == rhs.name
    }
}

既然可以等同，我们应该弄清楚“顺序”的含义。这是一种方法。由于结构使意想不到的值成为可能，我说过这些都是平等的，并且在我的任何彩虹颜色之前排列。如果这是一个枚举，我们就不必担心这种情况。

extension Color {
    private static let _order: [Color] = [red, orange, yellow, green, blue, indigo, violet]

    private var _indexValue: Int {
        return Color._order.index(of: self) ?? Int.min
    }
}

这样，我们就可以回答问题#2:可比性:

extension Color: Comparable {
    static func < (lhs: Color, rhs: Color) -> Bool {
        return lhs._indexValue < rhs._indexValue
    }
}

只需再迈出一小步即可实现 Strideable:

extension Color: Strideable {
    func advanced(by n: Int) -> Color {
        return Color._order[self._indexValue + n]
    }

    func distance(to other: Color) -> Int {
        return other._indexValue - _indexValue
    }
}

还有，你的... :

for rainbowColor: Color in .red ... .violet { print(rainbowColor) }

---

现在我碰巧非常喜欢枚举，如果你尝试用枚举来实现它，它们恰好有一些技巧，所以值得注意。例如，假设您有:

enum Color {
    case red
    case orange
    case yellow
    case green
    case blue
    case indigo
    case violet
}

事实证明，你不能使用 index(of:)用于计算_indexValue 。你会让自己陷入无限循环，因为它调用 distance(to:)默认==实现(我实际上还不确定为什么会发生这种情况)。所以你必须实现 _indexValue这样:

private var _indexValue: Int {
    switch self {
    case .red: return 0
    case .orange: return 1
    case .yellow: return 2
    case .green: return 3
    case .blue: return 4
    case .indigo: return 5
    case .violet: return 6
    }
}

嗯；这看起来非常像原始值。是的。整个方法基本上是从侧面附加原始值，而无需修改类型本身。这就是为什么它看起来非常相似。其余部分与结构相同，并且该方法可以应用于您可以弄清楚如何跨步的任何其他内容。