Aşağıdaki numaraya sahibim.

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

Tüm ham değerleri bir dizi dizisi olarak almam gerekiyor (böyle ["Pending", "On Hold", "Done"]).

Bu yöntemi numaralandırmaya ekledim.

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

Ama şu hatayı alıyorum.

'(() -> _)' türünde bir bağımsız değişken listesini kabul eden 'GeneratorOf' türü için bir başlatıcı bulunamıyor

Bunu yapmanın daha kolay, daha iyi veya daha zarif bir yolu var mı?

Swift 4.2 (Xcode 10) ve sonrası için

Bir CaseIterableprotokol var:

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

Swift <4.2 için

Hayır, enumhangi değerleri içerdiğini sorgulayamazsınız . Bkz bu yazıyı . Sahip olduğunuz tüm değerleri listeleyen bir dizi tanımlamalısınız. Ayrıca Frank Valbuena'nın " Tüm enum değerleri bir dizi olarak nasıl elde edilir" konusundaki çözümüne bakın .

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 , adlı yeni bir protokol sunarCaseIterable

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

uyduğunuzda, bunun enumgibi durumlardan bir dizi elde edebilirsiniz.

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

Numaralandırmaya CaseIterable protokolünü ekleyin :

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

Kullanım:

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

En azından derleme zamanında güvenli olmanın başka bir yolu var:

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

Bunun herhangi bir enum türü (RawRepresentable veya değil) için işe yaradığına dikkat edin ve ayrıca yeni bir vaka eklerseniz, iyi olan bir derleyici hatası alacaksınız çünkü sizi bunu güncellemeye zorlayacaktır.

Bu kodu bir yerde buldum:

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

Kullanım:

enum YourEnum: EnumCollection { //code }

YourEnum.cases()

YourEnum'daki vakaların listesini döndür

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

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

["Beklemede", "Beklemede", "Bitti"]

İşlevsel amaçlarla bir liste almak için, EnumName.allCasesbir dizi döndüren ifadeyi kullanın, örn.

EnumName.allCases.map{$0.rawValue} 

size bir Dizeler listesi verecektir. EnumName: String, CaseIterable

Not: allCasesyerine kullanın AllCases().

Swift 5 Güncellemesi

Bulduğum en kolay çözüm, .allCasesgenişleyen bir enum üzerinde kullanmaktır .CaseIterable

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

.allCasesherhangi bir CaseIterableenum Collection, o öğenin a değerini döndürür .

var myEnumArray = EstimateItemStatus.allCases

CaseIterable hakkında daha fazla bilgi

Swift 2 için

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

Kullanmak için:

arrayEnum(MyEnumClass.self)

Esinlenerek sonra Dizi ve denemede n hataların saat. Sonunda Xcode 9.1'de bu rahat ve güzel Swift 4 yolunu aldım:

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

Kullanım:

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

Çıktı:

Pending
On Hold
Done

Kullanabilirsiniz

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

Numaranız artımlıysa ve sayılarla ilişkiliyse, değerleri sıralamak için eşlediğiniz sayı aralığını şu şekilde kullanabilirsiniz:

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

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

Bu, dizelerle veya sayılardan başka herhangi bir şeyle ilişkili numaralandırmalarla pek işe yaramaz, ancak durum buysa harika çalışıyor!

AllValues ​​oluşturmak için bir enum üzerinde uzantı.

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