Swiftのenumを理解しよう！使い方と応用の10選

enum Weather {
    case sunny
    case cloudy
    case rainy
}

let todayWeather = Weather.sunny
print(todayWeather)

enum WeatherWithTemperature {
    case sunny(Int)
    case cloudy(Int)
    case rainy(Int)
}

let todayWeather = WeatherWithTemperature.sunny(25)
switch todayWeather {
case .sunny(let temperature):
    print("今日は晴れで、最高気温は\(temperature)度です。")
case .cloudy(let temperature):
    print("今日は曇りで、最高気温は\(temperature)度です。")
case .rainy(let temperature):
    print("今日は雨で、最高気温は\(temperature)度です。")
}

enum AdvisableWeather {
    case sunny
    case cloudy
    case rainy

    func advice() -> String {
        switch self {
        case .sunny:
            return "日焼け止めを塗って外出しましょう。"
        case .cloudy:
            return "外は少し肌寒いかもしれません。"
        case .rainy:
            return "傘を忘れずに持っていきましょう。"
        }
    }
}

let todayWeather = AdvisableWeather.rainy
print(todayWeather.advice())

enum APIResponseStatus {
    case success
    case error(String)
    case unknown

    func message() -> String {
        switch self {
        case .success:
            return "APIのリクエストが成功しました。"
        case .error(let errorMessage):
            return "エラーが発生しました: \(errorMessage)"
        case .unknown:
            return "未知のエラーが発生しました。"
        }
    }
}

let responseStatus = APIResponseStatus.error("通信障害")
print(responseStatus.message())

enum ColorPalette {
    case red
    case green
    case blue

    func rgb() -> (Int, Int, Int) {
        switch self {
        case .red:
            return (255, 0, 0)
        case .green:
            return (0, 255, 0)
        case .blue:
            return (0, 0, 255)
        }
    }

    func name() -> String {
        switch self {
        case .red:
            return "赤色"
        case .green:
            return "緑色"
        case .blue:
            return "青色"
        }
    }
}

let selectedColor = ColorPalette.red
print("\(selectedColor.name())のRGB値は\(selectedColor.rgb())です。")

enum Shape {
    case circle(radius: Double)
    case square(side: Double)
    case triangle(base: Double, height: Double)

    var area: Double {
        switch self {
        case .circle(let radius):
            return 3.14 * radius * radius
        case .square(let side):
            return side * side
        case .triangle(let base, let height):
            return 0.5 * base * height
        }
    }
}

let myShape = Shape.circle(radius: 5)
print("選択した形状の面積は\(myShape.area)平方センチメートルです。")

enum Box<T> {
    case success(T)
    case failure(String)

    // 値を取得する関数
    func value() -> T? {
        switch self {
        case .success(let data):
            return data
        case .failure:
            return nil
        }
    }

    // エラーメッセージを取得する関数
    func errorMessage() -> String? {
        switch self {
        case .success:
            return nil
        case .failure(let message):
            return message
        }
    }
}

let intBox: Box<Int> = .success(100)
print(intBox.value())  // 100と出力されます。

let stringBox: Box<String> = .failure("データの取得に失敗しました。")
print(stringBox.errorMessage())  // "データの取得に失敗しました。"と出力されます。

enum FileReaderError: Error {
    case fileNotFound
    case unreadableData
    case unknownError
}

func readFile(name: String) throws -> String {
    // ここでは例のため実際のファイル読み取りは行いません。
    // 仮のエラーシナリオとして、nameが"unknown"の場合はエラーを投げるとします。
    if name == "unknown" {
        throw FileReaderError.unknownError
    }
    return "File content for \(name)"
}

do {
    let content = try readFile(name: "unknown")
    print(content)
} catch FileReaderError.fileNotFound {
    print("ファイルが見つかりませんでした。")
} catch FileReaderError.unreadableData {
    print("データを読み取ることができませんでした。")
} catch FileReaderError.unknownError {
    print("未知のエラーが発生しました。")
}

enum UserEvent {
    case clicked
    case swiped(direction: String)
    case longPressed(duration: Double)

    func description() -> String {
        switch self {
        case .clicked:
            return "ユーザーがクリックしました。"
        case .swiped(let direction):
            return "ユーザーが\(direction)方向にスワイプしました。"
        case .longPressed(let duration):
            return "ユーザーが\(duration)秒間長押ししました。"
        }
    }
}

let swipeEvent = UserEvent.swiped(direction: "右")
print(swipeEvent.description())  // "ユーザーが右方向にスワイプしました。"と出力されます。

enum Fruit {
    case apple(color: String, weight: Double)
    case banana(weight: Double)
}

let myFruit = Fruit.apple(color: "赤", weight: 150.0)

switch myFruit {
case .apple(let color, let weight) where color == "赤" && weight > 100:
    print("これは重い赤いリンゴです。")
case .banana(let weight) where weight < 100:
    print("これは軽いバナナです。")
default:
    print("他のフルーツまたは条件に当てはまらないフルーツです。")
}

// このコードはコンパイルエラーとなります。
enum Sample: String {
    case one(value: Int)  // 関連値を持つcase
    case two = "TWO"     // RawValueを指定したcase
}

indirect enum ArithmeticExpression {
    case number(Int)
    case addition(ArithmeticExpression, ArithmeticExpression)
    case multiplication(ArithmeticExpression, ArithmeticExpression)
}

let five = ArithmeticExpression.number(5)
let four = ArithmeticExpression.number(4)
let sum = ArithmeticExpression.addition(five, four)

func evaluate(_ expression: ArithmeticExpression) -> Int {
    switch expression {
    case .number(let value):
        return value
    case .addition(let left, let right):
        return evaluate(left) + evaluate(right)
    case .multiplication(let left, let right):
        return evaluate(left) * evaluate(right)
    }
}

print(evaluate(sum))  // 9と出力されます。

enum Direction {
    case north, south, east, west
}

let myDirection: Direction = .North  // コンパイルエラーが発生します。

enum Planet: String {
    case mercury = "水星"
    case venus = "金星"
    case earth = "地球"
}

// RawValueを使用してenumのcaseを取得
let earth = Planet(rawValue: "地球")  // earthにはPlanet.earthが代入されます。

enum Season: CaseIterable {
    case spring
    case summer
    case autumn
    case winter
}

for season in Season.allCases {
    print(season)  // spring, summer, autumn, winterの順に出力されます。
}