Ich habe die folgende Aufzählung.

enum EstimateItemStatus: Printable {
    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
        }
    }
}

Ich muss alle Rohwerte als Array von Strings erhalten (wie so ["Pending", "On Hold", "Done"]).

Ich habe diese Methode zur Aufzählung hinzugefügt.

func toArray() -> [String] {
    var n = 1
    return Array(
        GeneratorOf<EstimateItemStatus> {
            return EstimateItemStatus(id: n++)!.description
        }
    )
}

Aber ich erhalte den folgenden Fehler.

Es kann kein Initialisierer für den Typ 'GeneratorOf' gefunden werden, der eine Argumentliste vom Typ '(() -> _)' akzeptiert.

Gibt es eine einfachere, bessere oder elegantere Möglichkeit, dies zu tun?

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

Es gibt ein CaseIterableProtokoll:

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 nicht abfragen, enumwelche Werte darin enthalten sind. Siehe diesen Artikel . Sie müssen ein Array definieren, das alle Ihre Werte auflistet. Lesen Sie auch die Lösung von Frank Valbuena unter " So erhalten Sie alle Enum-Werte als Array ".

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 einCaseIterable

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

Wenn Sie sich an die Anforderungen halten, können Sie aus enumsolchen Fällen ein Array abrufen

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

Fügen Sie das CaseIterable- Protokoll zur Aufzählung hinzu:

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

Verwendung:

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

Es gibt noch einen anderen Weg, der zumindest beim Kompilieren 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 Compilerfehler angezeigt, der gut ist, da Sie gezwungen sind, diesen auf den neuesten Stand zu bringen.

Ich habe irgendwo diesen Code gefunden:

protocol EnumCollection : Hashable {}


extension EnumCollection {

    static func cases() -> AnySequence<Self> {
        typealias S = Self
        return AnySequence { () -> AnyIterator<S> in
            var raw = 0
            return AnyIterator {
                let current : Self = withUnsafePointer(to: &raw) { $0.withMemoryRebound(to: S.self, capacity: 1) { $0.pointee }
                }
                guard current.hashValue == raw else { return nil }
                raw += 1
                return current
            }
        }
    }
}

Verwenden:

enum YourEnum: EnumCollection { //code }

YourEnum.cases()

Liste der Fälle von YourEnum zurückgeben

Verwenden Sie den Ausdruck, EnumName.allCasesder ein Array zurückgibt, z

EnumName.allCases.map{$0.rawValue} 

wird Ihnen eine Liste von Strings geben, wenn das gegeben ist EnumName: String, CaseIterable

Hinweis: Verwenden Sie allCasesanstelle von AllCases().

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"]

Update für Swift 5

Die einfachste Lösung, die ich gefunden habe, besteht darin, sie .allCasesfür eine erweiterte Aufzählung zu verwendenCaseIterable

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
        }
    }
}

.allCasesBei jeder CaseIterableAufzählung wird ein CollectionElement dieses Elements zurückgegeben.

var myEnumArray = EstimateItemStatus.allCases

Weitere Informationen zu CaseIterable

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)

Nach Inspiration von Sequence und stundenlangem Versuch n Fehler. Ich habe endlich diesen komfortablen und schönen Swift 4 Way 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
    }
}

Verwendung:

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)
}

Wenn Ihre Aufzählung inkrementell ist und Zahlen zugeordnet ist, können Sie einen Zahlenbereich verwenden, den Sie Aufzählungswerten zuordnen, z.

// 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 mit Aufzählungen, die mit Zeichenfolgen oder anderen Elementen als Zahlen verknüpft sind, aber es funktioniert hervorragend, wenn dies der Fall ist!

Erweiterung einer Aufzählung zum Erstellen von allValues.

extension RawRepresentable where Self: CaseIterable {
      static var allValues: [Self.RawValue] {
        return self.allCases.map { $0.rawValue}
      }
    }