Как выбрать случайное значение перечисления

С момента написания этого ответа Swift получил новые функции, которые обеспечивают гораздо лучшее решение - см. "Как выбрать случайное значение перечисления".

Я не без ума от вашего последнего случая - похоже, вы включаете .GeometryClassificationMax исключительно для включения случайного выбора. Вам нужно будет учитывать этот дополнительный случай везде, где вы используете оператор switch, и он не имеет семантического значения. Вместо этого статический метод на enum мог бы определить максимальное значение и вернуть случайный случай, и был бы намного более понятным и удобным в обслуживании.

enum GeometryClassification: UInt32 {
    case Circle
    case Square
    case Triangle

    private static let _count: GeometryClassification.RawValue = {
        // find the maximum enum value
        var maxValue: UInt32 = 0
        while let _ = GeometryClassification(rawValue: maxValue) { 
            maxValue += 1
        }
        return maxValue
    }()

    static func randomGeometry() -> GeometryClassification {
        // pick and return a new value
        let rand = arc4random_uniform(_count)
        return GeometryClassification(rawValue: rand)!
    }
}

И теперь вы можете исчерпать enum в операторе switch:

switch GeometryClassification.randomGeometry() {
case .Circle:
    println("Circle")
case .Square:
    println("Square")
case .Triangle:
    println("Triangle")
}

В Swift на самом деле существует протокол для перечислений под названием CaseIterable, который, если вы добавите его в свое перечисление, вы можете просто ссылаться на все случаи как на коллекцию с .allCases следующим образом:

enum GeometryClassification: CaseIterable {

    case Circle
    case Square
    case Triangle

}

а затем вы можете .allCases, а затем .randomElement(), чтобы получить случайный

let randomGeometry = GeometryClassification.allCases.randomElement()!

Принудительное разворачивание требуется, потому что существует вероятность того, что перечисление не будет иметь случаев и, таким образом, randomElement() вернет nil.

Поскольку вы находитесь внутри класса enum, указание на метод random() наивысшего значения явным образом избавит от необходимости каждый раз их подсчитывать:

enum GeometryClassification: UInt32 {
    case Circle
    case Square
    case Triangle

    static func random() -> GeometryClassification {
        // Update as new enumerations are added
        let maxValue = Triangle.rawValue

        let rand = arc4random_uniform(maxValue+1)
        return GeometryClassification(rawValue: rand)!
    }
}

Для Swift 5 существует "RandomNumberGenerator":

enum Weekday: CaseIterable {
    case sunday, monday, tuesday, wednesday, thursday, friday, saturday

    static func random<G: RandomNumberGenerator>(using generator: inout G) -> Weekday {
        return Weekday.allCases.randomElement(using: &generator)!
    }

    static func random() -> Weekday {
        var g = SystemRandomNumberGenerator()
        return Weekday.random(using: &g)
    }
}

Вам нужно назначить необработанный тип вашему перечислению. Если вы используете целочисленный тип, то значения случая перечисления будут автоматически сгенерированы, начиная с 0:

enum GeometryClassification: UInt32 {  
    case Circle
    case Square
    case Triangle
    case GeometryClassificationMax
}

Согласно перечислениям:

«В отличие от C и Objective-C, членам перечисления Swift не присваивается целочисленное значение по умолчанию при их создании».

Указание целочисленного типа позволяет ему генерировать значения обычным способом.

Затем вы можете сгенерировать случайное значение следующим образом:

let randomEnum: GeometryClassification = GeometryClassification.fromRaw(arc4random_uniform(GeometryClassification.GeometryClassificationMax.toRaw()))!

Это ужасно уродливый вызов, и все эти вызовы fromRaw и toRaw довольно неэлегантны, поэтому я бы действительно рекомендовал сначала сгенерировать случайный UInt32, который находится в нужном вам диапазоне, а затем создать GeometryClassification из этого значения:

GeometryClassification.fromRaw(someRandomUInt32)

Вы можете поместить все значения в массив и сгенерировать случайный,

extension GeometryClassification {

    static func random() -> GeometryClassification {
        let all: [GeometryClassification] = [.Circle,
                                             .Square,
                                             .Triangle,
                                             .GeometryClassificationMax]
        let randomIndex = Int(arc4random()) % all.count
        return all[randomIndex]
    }
}

Вот мой дубль Swift 1.2:

enum GeometryClassification : Int {
    case Circle = 0
    case Square = 1
    case Triangle = 2

    static func random() -> GeometryClassification {
        let min = MutationType.Circle.rawValue
        let max = MutationType.Triangle.rawValue
        let rand = Int.random(min: min, max: max) // Uses ExSwift!
        return self(rawValue: rand)!
    }
}

Я написал глобальное расширение, используя ответ Энди. Наслаждаться :)

extension CaseIterable {
    static func random<G: RandomNumberGenerator>(using generator: inout G) -> Self.AllCases.Element {
        return Self.allCases.randomElement(using: &generator)!
    }

    static func random() -> Self.AllCases.Element {
        var g = SystemRandomNumberGenerator()
        return Self.random(using: &g)
    }
}

Просто расширьте свое перечисление, чтобы оно соответствовало протоколу CaseIterable, и используйте следующее:

let state = YourEnum.random()

Проще всего создать глобальное расширение:

extension CaseIterable {
    static func randomElement() -> AllCases.Element {
        guard Self.allCases.count > 0 else {
            fatalError("There must be at least one case in the enum")
        }
        return Self.allCases.randomElement()!
    }
}

Таким образом, любое перечисление, которое соответствует CaseIterable, автоматически имеет функцию