Liefert alle Aufzählungswerte als Array

Für Swift 4.2 (Xcode 10) und höher

Es gibt ein CaseIterable-Protokoll:

enum EstimateItemStatus: String, CaseIterable {
    case pending = "Pending"
    case onHold = "OnHold"
    case done = "Done"

    init?(id : Int) {
        switch id {
        case 1: self = .pending
        case 2: self = .onHold
        case 3: self = .done
        default: return nil
        }
    }
}

for value in EstimateItemStatus.allCases {
    print(value)
}

Für Swift <4.2

Nein, Sie können keine enum nach den darin enthaltenen Werten abfragen. Siehe diesen Artikel . Sie müssen ein Array definieren, das alle Werte auflistet, die Sie haben. Schauen Sie sich auch Frank Valbuenas clevere Lösung an.

enum EstimateItemStatus: String {
    case Pending = "Pending"
    case OnHold = "OnHold"
    case Done = "Done"

    static let allValues = [Pending, OnHold, Done]

    init?(id : Int) {
        switch id {
        case 1:
            self = .Pending
        case 2:
            self = .OnHold
        case 3:
            self = .Done
        default:
            return nil
        }
    }
}

for value in EstimateItemStatus.allValues {
    print(value)
}

Swift 4.2 führt ein neues Protokoll mit dem Namen CaseIterable ein

enum Fruit : CaseIterable {
    case Apple , apricot , orange, lemon
}

wenn Sie konform sind, können Sie ein Array aus den enum-Fällen erhalten 

for fruit in Fruit.allCases {
    print("I like eating \(fruit).")
}

Es gibt eine andere Möglichkeit, die zumindest zur Kompilierzeit sicher ist:

enum MyEnum {
    case case1
    case case2
    case case3
}

extension MyEnum {
    static var allValues: [MyEnum] {
        var allValues: [MyEnum] = []
        switch (MyEnum.case1) {
        case .case1: allValues.append(.case1); fallthrough
        case .case2: allValues.append(.case2); fallthrough
        case .case3: allValues.append(.case3)
        }
        return allValues
    }
}

Beachten Sie, dass dies für jeden Aufzählungstyp (RawRepresentable oder nicht) funktioniert. Wenn Sie einen neuen Fall hinzufügen, wird ein Compiler-Fehler angezeigt. Dieser Fehler ist gut, da Sie dies auf dem neuesten Stand halten müssen. 

Add CaseIterable protocol to enum:

enum EstimateItemStatus: String, CaseIterable {
    case pending = "Pending"
    case onHold = "OnHold"
    case done = "Done"
}

Verwendungszweck:

let values: [String] = EstimateItemStatus.allCases.map { $0.rawValue }
//["Pending", "OnHold", "Done"]

Für Swift 2

// Found http://stackoverflow.com/questions/24007461/how-to-enumerate-an-enum-with-string-type
func iterateEnum<T where T: Hashable, T: RawRepresentable>(_: T.Type) -> AnyGenerator<T> {
    var i = 0
    return AnyGenerator {
        let next = withUnsafePointer(&i) {
            UnsafePointer<T>($0).memory
        }
        if next.hashValue == i {
            i += 1
            return next
        } else {
            return nil
        }
    }
}

func arrayEnum<T where T: Hashable, T: RawRepresentable>(type: T.Type) -> [T]{
    return Array(iterateEnum(type))
}

Um es zu benutzen:

arrayEnum(MyEnumClass.self)

enum EstimateItemStatus: String, CaseIterable {
  case pending = "Pending"
  case onHold = "OnHold"
  case done = "Done"

  static var statusList: [String] {
    return EstimateItemStatus.allCases.map { $0.rawValue }
  }
}

["Ausstehend", "OnHold", "Fertig"]

Nach Inspiration von Sequenz und stundenlangem Versuch n Fehler. Ich habe endlich diesen bequemen und schönen Swift 4-Weg auf Xcode 9.1 bekommen:

protocol EnumSequenceElement: Strideable {
    var rawValue: Int { get }
    init?(rawValue: Int)
}

extension EnumSequenceElement {
    func distance(to other: Self) -> Int {
        return other.rawValue - rawValue
    }

    func advanced(by n: Int) -> Self {
        return Self(rawValue: n + rawValue) ?? self
    }
}

struct EnumSequence<T: EnumSequenceElement>: Sequence, IteratorProtocol {
    typealias Element = T

    var current: Element? = T.init(rawValue: 0)

    mutating func next() -> Element? {
        defer {
            if let current = current {
                self.current = T.init(rawValue: current.rawValue + 1)
            }
        }
        return current
    }
}

Verwendungszweck:

enum EstimateItemStatus: Int, EnumSequenceElement, CustomStringConvertible {
    case Pending
    case OnHold
    case Done

    var description: String {
        switch self {
        case .Pending:
            return "Pending"
        case .OnHold:
            return "On Hold"
        case .Done:
            return "Done"
        }
    }
}

for status in EnumSequence<EstimateItemStatus>() {
    print(status)
}
// Or by countable range iteration
for status: EstimateItemStatus in .Pending ... .Done {
    print(status)
}

Ausgabe:

Pending
On Hold
Done

Sie können verwenden

enum Status: Int{
    case a
    case b
    case c

}

extension RawRepresentable where Self.RawValue == Int {

    static var values: [Self] {
        var values: [Self] = []
        var index = 1
        while let element = self.init(rawValue: index) {
            values.append(element)
            index += 1
        }
        return values
    }
}


Status.values.forEach { (st) in
    print(st)
}

Update für Swift 5

Die einfachste Lösung, die ich gefunden habe, besteht darin, .allCases in einer Enumeration zu verwenden, die CaseIterable erweitert.

enum EstimateItemStatus: CaseIterable {
    case Pending
    case OnHold
    case Done

    var description: String {
        switch self {
        case .Pending: return "Pending"
        case .OnHold: return "On Hold"
        case .Done: return "Done"
        }
    }

    init?(id : Int) {
        switch id {
        case 1:
            self = .Pending
        case 2:
            self = .OnHold
        case 3:
            self = .Done
        default:
            return nil
        }
    }
}

.allCases in jedem CaseIterable -Element gibt ein Collection dieses Elements zurück.

var myEnumArray = EstimateItemStatus.allCases

weitere Informationen zu CaseIterable

Verwenden Sie den Ausdruck EnumName.AllCases(), der ein Array zurückgibt, z.

EnumName.allCases.map{$0.rawValue} 

gibt Ihnen eine Liste von Zeichenfolgen mit dem angegebenen EnumName: String, CaseIterable

Hinweis Verwenden Sie allCases anstelle von AllCases().

Wenn Ihre Aufzählung inkrementell ist und mit Zahlen verknüpft ist, können Sie einen Zahlenbereich verwenden, den Sie zuordnen, um Werte aufzuzählen, wie folgt:

// Swift 3
enum EstimateItemStatus: Int {
    case pending = 1,
    onHold
    done
}

let estimateItemStatusValues: [EstimateItemStatus?] = (EstimateItemStatus.pending.rawValue...EstimateItemStatus.done.rawValue).map { EstimateItemStatus(rawValue: $0) }

Dies funktioniert nicht ganz gut mit Enummen, die mit Strings oder anderen Werten als Zahlen verknüpft sind, aber es funktioniert gut, wenn dies der Fall ist!