如何快速从枚举成员原始值制作数组字符串

Question

I am new in programming and swift. I have an enum like this

enum City : String {
    case tokyo = "tokyo"
    case london = "london"
    case newYork = "new york"
}

Could I possibly get that city name to an array from enum raw value? I hope I can get something like this :

let city = ["tokyo","london","new york"]

Answer 1

Something like this.

let cities = [City.tokyo, .london, .newYork]
let names = cities.map { $0.rawValue }
print(names) // ["tokyo", "london", "new york"]

To get all enum values as an array see this .

Answer 2

Swift 4.0

If you want to iterate through enum you can do like this.

enum City : String {

    case tokyo = "tokyo"
    case london = "london"
    case newYork = "new york"

    static let allValues = [tokyo,london,newYork] 
}

let values = City.allValues.map { $0.rawValue }
print(values) //tokyo london new york

Answer 3

Hope this might help. Please look into this https://stackoverflow.com/a/28341290/2741603 for more detail

enum City : String {
    case tokyo = "tokyo"
    case london = "london"
    case newYork = "new york"
}

func iterateEnum<T: Hashable>(_: T.Type) -> AnyIterator<T> {
    var k = 0
    return AnyIterator {
        let next = withUnsafeBytes(of: &k) { $0.load(as: T.self) }
        if next.hashValue != k { return nil }
        k += 1
        return next
    }
}


var cityList:[String] = []
for item in iterateEnum(City.self){
    cityList.append(item.rawValue)

}
print(cityList)

Answer 4

Using Rintaro answer as inspiration I have created two protocols to be used in simple Enumerations. One to extract all cases and another to extract all rawValues:

protocol Enumeratable: Hashable {
    static var cases: [Self] { get }
}
extension Enumeratable {
    static var cases: [Self] {
        var cases: [Self] = []
        var index = 0
        for element: Self in AnyIterator({
            let item = withUnsafeBytes(of: &index) { $0.load(as: Self.self) }
            guard item.hashValue == index else { return nil }
            index += 1
            return item
        }) {
            cases.append(element)
        }
        return cases
    }
}

---

protocol RawValued: Hashable, RawRepresentable {
    static var rawValues: [RawValue] { get }
}
extension RawValued {
    static var rawValues: [RawValue] {
        var rawValues: [RawValue] = []
        var index = 0
        for element: Self in AnyIterator({
            let item = withUnsafeBytes(of: &index) { $0.load(as: Self.self) }
            guard item.hashValue == index else { return nil }
            index += 1
            return item
        }) {
            rawValues.append(element.rawValue)
        }
        return rawValues
    }
}

---

Playground testing:

enum City: String, RawValued, Enumeratable {
    case tokyo, london, newYork = "new york"
}

City.cases       // [tokyo, london, newYork]
City.rawValues   // ["tokyo", "london", "new york"]