Swift列挙型でケースごとに異なる値を保持する方法を徹底解説

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

var currentDirection = Direction.north

currentDirection = .south

switch currentDirection {
case .north:
    print("Heading North")
case .south:
    print("Heading South")
case .east:
    print("Heading East")
case .west:
    print("Heading West")
}

enum Transportation {
    case car(seats: Int)
    case train(line: String)
    case airplane(flightNumber: String, seats: Int)
}

let myCar = Transportation.car(seats: 4)
let myTrain = Transportation.train(line: "Central Line")
let myFlight = Transportation.airplane(flightNumber: "JL123", seats: 180)

switch myFlight {
case .car(let seats):
    print("Car with \(seats) seats")
case .train(let line):
    print("Train on \(line)")
case .airplane(let flightNumber, let seats):
    print("Flight \(flightNumber) with \(seats) seats")
}

enum Payment {
    case cash(amount: Double)
    case creditCard(cardNumber: String, expiryDate: String)
    case applePay(account: String)
}

// 正しい例
let paymentMethod = Payment.cash(amount: 100.0)

// 間違った例（コンパイルエラー）
let wrongPayment = Payment.cash(amount: "100.0")  // String型を渡しているためエラー

let payment = Payment.creditCard(cardNumber: "1234-5678-9101-1121", expiryDate: "12/25")

switch payment {
case .cash(let amount):
    print("Paid \(amount) in cash")
case .creditCard(let cardNumber, let expiryDate):
    print("Paid with credit card \(cardNumber), expiring on \(expiryDate)")
case .applePay(let account):
    print("Paid with Apple Pay account \(account)")
}

enum UIElement {
    case button(title: String)
    case label(text: String)
    case textField(placeholder: String, inputText: String?)
}

let submitButton = UIElement.button(title: "Submit")
let nameLabel = UIElement.label(text: "Name:")
let inputField = UIElement.textField(placeholder: "Enter your name", inputText: nil)

func renderUI(element: UIElement) {
    switch element {
    case .button(let title):
        print("Rendering a button with title: \(title)")
    case .label(let text):
        print("Rendering a label with text: \(text)")
    case .textField(let placeholder, let inputText):
        print("Rendering a text field with placeholder: \(placeholder)")
        if let text = inputText {
            print("User input: \(text)")
        } else {
            print("No user input yet.")
        }
    }
}

renderUI(element: submitButton)  // Output: Rendering a button with title: Submit
renderUI(element: nameLabel)     // Output: Rendering a label with text: Name:
renderUI(element: inputField)    // Output: Rendering a text field with placeholder: Enter your name
                                 //         No user input yet.

enum FormFieldStatus {
    case empty
    case valid(value: String)
    case invalid(reason: String)
}

func validateField(input: String?) -> FormFieldStatus {
    guard let input = input, !input.isEmpty else {
        return .empty
    }

    if input.count >= 3 {
        return .valid(value: input)
    } else {
        return .invalid(reason: "Input must be at least 3 characters long")
    }
}

let nameFieldStatus = validateField(input: "John")
let passwordFieldStatus = validateField(input: "")

switch nameFieldStatus {
case .empty:
    print("Name field is empty")
case .valid(let value):
    print("Name is valid: \(value)")
case .invalid(let reason):
    print("Invalid name: \(reason)")
}

enum NetworkResponse {
    case success(data: Data)
    case failure(error: String)
}

func handleResponse(response: NetworkResponse) {
    switch response {
    case .success(let data):
        print("Data received: \(data)")
        // ここでデータを解析したり表示したりする
    case .failure(let error):
        print("Error occurred: \(error)")
    }
}

// サーバーから成功したレスポンスを受け取った場合
let response = NetworkResponse.success(data: Data())
handleResponse(response: response)

// サーバーから失敗したレスポンスを受け取った場合
let errorResponse = NetworkResponse.failure(error: "404 Not Found")
handleResponse(response: errorResponse)

enum AppState {
    case loading
    case loaded(content: String)
    case error(message: String)
}

func updateUI(for state: AppState) {
    switch state {
    case .loading:
        print("Loading data...")
    case .loaded(let content):
        print("Content loaded: \(content)")
    case .error(let message):
        print("Error: \(message)")
    }
}

let currentState = AppState.loaded(content: "Welcome to the app!")
updateUI(for: currentState)

enum Transportation {
    case car(seats: Int)
    case train(line: String)
    case airplane(flightNumber: String, seats: Int)

    var description: String {
        switch self {
        case .car(let seats):
            return "A car with \(seats) seats"
        case .train(let line):
            return "Train running on the \(line) line"
        case .airplane(let flightNumber, let seats):
            return "Flight \(flightNumber) with \(seats) seats"
        }
    }
}

let myCar = Transportation.car(seats: 4)
print(myCar.description)  // Output: A car with 4 seats

enum Transportation {
    case car(seats: Int)
    case train(line: String)
    case airplane(flightNumber: String, seats: Int)

    var description: String {
        switch self {
        case .car(let seats):
            return "A car with \(seats) seats"
        case .train(let line):
            return "Train running on the \(line) line"
        case .airplane(let flightNumber, let seats):
            return "Flight \(flightNumber) with \(seats) seats"
        }
    }

    func estimatedTravelTime(distance: Double) -> Double {
        switch self {
        case .car:
            return distance / 60.0  // 車の平均速度を60km/hと仮定
        case .train:
            return distance / 100.0 // 列車の平均速度を100km/hと仮定
        case .airplane:
            return distance / 800.0 // 飛行機の平均速度を800km/hと仮定
        }
    }
}

let travelByTrain = Transportation.train(line: "Green Line")
let travelTime = travelByTrain.estimatedTravelTime(distance: 200)
print("Estimated travel time by train: \(travelTime) hours")  // Output: Estimated travel time by train: 2.0 hours

enum Transportation {
    case car(seats: Int, fuelEfficiency: Double) // fuelEfficiency: km/l
    case train(line: String, maxSpeed: Double)   // maxSpeed: km/h
    case airplane(flightNumber: String, seats: Int, range: Double)  // range: km

    var description: String {
        switch self {
        case .car(let seats, let fuelEfficiency):
            return "A car with \(seats) seats and fuel efficiency of \(fuelEfficiency) km/l"
        case .train(let line, let maxSpeed):
            return "Train on the \(line) line with a maximum speed of \(maxSpeed) km/h"
        case .airplane(let flightNumber, let seats, let range):
            return "Flight \(flightNumber) with \(seats) seats and range of \(range) km"
        }
    }

    func estimatedFuelConsumption(forDistance distance: Double) -> Double? {
        switch self {
        case .car(_, let fuelEfficiency):
            return distance / fuelEfficiency
        case .train:
            return nil  // 列車は燃料消費を考慮しない
        case .airplane(_, _, let range):
            return distance > range ? nil : distance / range * 1000  // 範囲内の燃料消費量を推定
        }
    }
}

let myCar = Transportation.car(seats: 4, fuelEfficiency: 15.0)
if let fuelNeeded = myCar.estimatedFuelConsumption(forDistance: 300) {
    print("Fuel needed for 300km: \(fuelNeeded) liters")
}

enum AppState {
    case loading
    case loaded(content: String)
    case error(message: String)
}

func updateUI(for state: AppState) {
    switch state {
    case .loading:
        print("Loading data... Please wait.")
    case .loaded(let content):
        print("Content loaded: \(content)")
    case .error(let message):
        print("Error occurred: \(message)")
    }
}

let currentState = AppState.loaded(content: "Welcome to the app!")
updateUI(for: currentState)
// Output: Content loaded: Welcome to the app!

func fetchData(completion: @escaping (AppState) -> Void) {
    completion(.loading)

    // Simulate network delay
    DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
        let success = Bool.random()  // ランダムに成功・失敗を決める
        if success {
            completion(.loaded(content: "Data from API"))
        } else {
            completion(.error(message: "Failed to load data"))
        }
    }
}

fetchData { state in
    updateUI(for: state)
}
// Output (random): "Loading data... Please wait."
// Output after 2 seconds: "Content loaded: Data from API" or "Error occurred: Failed to load data"

enum AuthState {
    case loggedIn(user: String)
    case loggedOut
    case loginError(message: String)
}

func handleAuthState(state: AuthState) {
    switch state {
    case .loggedIn(let user):
        print("Welcome, \(user)!")
    case .loggedOut:
        print("Please log in.")
    case .loginError(let message):
        print("Login failed: \(message)")
    }
}

enum Transportation {
    case car(seats: Int)
    case train(line: String)
    case airplane(flightNumber: String, seats: Int)
}

struct Car {
    var seats: Int
    var fuelEfficiency: Double
}

struct Car {
    var seats: Int
    var fuelEfficiency: Double
}

enum CarStatus {
    case moving(speed: Double)
    case parked(location: String)
    case maintenance(reason: String)
}

// 本の在庫状態を列挙型で定義
enum StockStatus {
    case inStock
    case soldOut
    case comingSoon
}

// 本のタイプを列挙型で定義
enum BookType {
    case physical(weight: Double)   // 物理書籍は重量を保持
    case digital(fileSize: Double)  // 電子書籍はファイルサイズを保持
}

// 本の基本情報を構造体で定義
struct Book {
    var title: String
    var author: String
    var pageCount: Int
    var type: BookType
    var stockStatus: StockStatus
}

// 本のインスタンスを作成
let physicalBook = Book(title: "Swift Programming", author: "John Appleseed", pageCount: 350, type: .physical(weight: 1.2), stockStatus: .inStock)
let digitalBook = Book(title: "Learn Swift", author: "Jane Doe", pageCount: 200, type: .digital(fileSize: 5.5), stockStatus: .soldOut)

// 在庫状態に応じた処理
func checkStock(for book: Book) {
    switch book.stockStatus {
    case .inStock:
        print("\(book.title) is available for purchase.")
    case .soldOut:
        print("\(book.title) is currently sold out.")
    case .comingSoon:
        print("\(book.title) will be available soon.")
    }
}

checkStock(for: physicalBook)
checkStock(for: digitalBook)

// ユーザーアカウントの状態を列挙型で定義
enum AccountStatus {
    case loggedIn(name: String, email: String)
    case loggedOut
    case authenticating
}

// ユーザーの状態に応じた処理
func handleAccountStatus(status: AccountStatus) {
    switch status {
    case .loggedIn(let name, let email):
        print("Welcome, \(name)! Your email is \(email).")
    case .loggedOut:
        print("You are logged out. Please log in.")
    case .authenticating:
        print("Authenticating... Please wait.")
    }
}

// ユーザー状態の例
let currentStatus = AccountStatus.loggedIn(name: "Alice", email: "alice@example.com")
let otherStatus = AccountStatus.loggedOut

// 状態に応じたメッセージを表示
handleAccountStatus(status: currentStatus)
handleAccountStatus(status: otherStatus)

enum NetworkStatus {
    case connected
    case disconnected
    case connecting
}

// 新しいケース追加後、未処理のケースがエラーを引き起こす
func handleNetworkStatus(status: NetworkStatus) {
    switch status {
    case .connected:
        print("Connected")
    case .disconnected:
        print("Disconnected")
    case .connecting:
        print("Connecting")
    }
}

switch status {
case .connected:
    print("Connected")
default:
    print("Other status")
}

enum PaymentMethod {
    case cash(amount: Double)
    case creditCard(number: String, expiry: String)
}

let payment = PaymentMethod.creditCard(number: "1234-5678-9012", expiry: "12/25")

switch payment {
case .cash(let amount):
    print("Paid in cash: \(amount)")
case .creditCard(let number, let expiry):
    print("Paid with credit card \(number), expires on \(expiry)")
}

enum TaskStatus {
    case notStarted
    case inProgress(percentage: Int)
    case completed
}

var task1 = TaskStatus.inProgress(percentage: 50)
var task2 = task1

task2 = .completed

// task1は依然としてinProgress状態
print(task1)  // Output: inProgress(percentage: 50)
print(task2)  // Output: completed

struct CreditCard {
    var number: String
    var expiryDate: String
}

enum Payment {
    case cash(amount: Double)
    case creditCard(details: CreditCard)
}

let card = CreditCard(number: "1234-5678-9012", expiryDate: "12/25")
let paymentMethod = Payment.creditCard(details: card)

switch paymentMethod {
case .cash(let amount):
    print("Paid in cash: \(amount)")
case .creditCard(let details):
    print("Paid with credit card \(details.number), expires on \(details.expiryDate)")
}