The Swift Programming Language - Enumerations（列挙型）をまとめる #Swift

Enumerations（enum列挙型）

SwiftではObjCやC言語の時よりより表現力が豊

Enumeration Syntax（シンタックス）

ブレス内に記述する

enum SomeEnumeration {
    // 定義をここに書く
}

コンパスの例え

enum CompassPoint {
    case North
    case South
    case East
    case West
}

列挙法のメンバー値、Nort, South, East, West、を定義
caseは新しい行の始まりを意味する

NOTE
SwiftではC言語やObjective-Cとは異なりデフォルトで整数値がセットされない
上記の例でいうなら、North, South, East, West にそれぞれ、0, 1, 2, 3 と定義されない
各々 CompassPoint.型の明示的な独立した値として定義される

（,）カンマ区切りで一行で書く事も出来る

enum Planet {
    case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}

それぞれ列挙型は新しい名前を定義できる
他のSwiftで使われている方と同様に最初の一文字は大文字で書く
単数系で表記しより明白に分かる様にする

var directionToHead = CompassPoint.West

directionToHead 変数が既に CompassPoint の値で初期化されている場合は推論できるようになる
CompassPoint として宣言された directionToHead は.どっとシンタックスをつかって簡易的に書く事ができる

directionToHead = .East

directionToHead の型が既知であれば、代入する値の型を省くことができる
これによってより読みやすいコードになる

Matching Enumeration Values with a Switch Statement（Switchを使った値評価）

Switchステートメントを使ってそれぞれの値を評価することができる

directionToHead = .South
switch directionToHead {
case .North:
    println("Lots of planets have a north")
case .South:
    println("Watch out for penguins")
case .East:
    println("Where the sun rises")
case .West:
    println("Where the skies are blue")
}
// prints "Watch out for penguins"

全ての列挙型の値をカバー出来ない場合 default を指定する

let somePlanet = Planet.Earth
switch somePlanet {
case .Earth:
    println("Mostly harmless")
default:
    println("Not a safe place for humans")
}
// prints "Mostly harmless"

Associated Values（関連値）

関連する値を持たせる事ができる

例えば

var response = ServerResponse.Result("6:00 am", "8:09 pm")

response = .Error("Out of cheese.")

switch response {
case let .Result(sunrise, sunset):
    let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."
case .Error(let error):
    let serverResponse = "Failure... \(error)"
}
println(serverResponse)
// prints "Failure... Out of cheese."

ServerResonse に Reuslt と Error を定義し、それぞれの受け取る値の型を指定
.Result() にセットする値の型が違う場合エラーになる

var response = ServerResponse.Result("6:00 am", "8:09 pm")

変数として response を定義する
この時、 response の型は enum ServerResponse として推論され定義される

response = .Error("Out of cheese.")

ここで、再度 .Error() で代入して response を更新する
response は Error か Result のどちらかしか持てない

switch response {
case let .Result(sunrise, sunset):
    let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."
case .Error(let error):
    let serverResponse = "Failure... \(error)"
}

値を展開したい時は、let or var を使を使う
enum の型の前で宣言すると全ての値を同時に定数か変数として宣言できる
.Error(let error) のように個別に指定もできる

Raw Values （直接値）

色々な方の直接値を指定する事ができる
strings, characters, integer, floating-point number が使える
ObjeCのenumに近い

例えば

enum ASCIIControlCharacter: Character {
    case Tab = "\t"
    case LineFeed = "\n"
    case CarriageReturn = "\r"
}

このように "Associated Values" は異なり、enum型名の後に指定した型の値を前もって直接指定する
"Associated Values" は、定数や変数を生成する時に値を指定するが、 enum は定義するときに指定する

Planet を直接値を指定して書き換えてみる

enum Planet: Int {
    case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}

toRaw()

toRaw() を使って値を取得するこができる
toRaw() は enum に直接指定する値の型を指定してる場合のみ使える

let earthsOrder = Planet.Earth.toRaw()
// earthsOrder は 3

fromRaw()

fromRaw() でenum型を取得できる

let possiblePlanet = Planet.fromRaw(7)
// possiblePlanet は Planet.Uranus で Planet?（オプショナルになる）

Planet.fromRaw() の値はオプショナルなので、Planetが存在しない値を渡したときに nil を返す

let positionToFind = 9
if let somePlanet = Planet.fromRaw(positionToFind) {
    switch somePlanet {
    case .Earth:
        println("Mostly harmless")
    default:
        println("Not a safe place for humans")
    }
} else {
    println("\(positionToFind)のPlanetは存在しません")
}
// prints "9のPlanetは存在しません"

func を使って振る舞い定義

func を使って振る舞いを定義できたりもする

enum Planet: Int {
    case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
    func 日本語() -> String {
        switch self {
        case .Mercury:
            return "水星"
        case .Venus:
            return "金星"
        case .Earth:
            return "地球"
        case .Mars:
            return "火星"
        case .Jupiter:
            return "木星"
        case .Saturn:
            return "土星"
        case .Uranus:
            return "天王星"
        case .Neptune:
            return "海王星"

        }
    }
}

let uranus = Planet.Uranus
let uranus説明 = uranus.日本語()
// uranus説明 は "天王星"