Swiftの「switch」文で関数やメソッドを呼び出す最適な方法

func sayHello() {
    print("Hello!")
}

func sayGoodbye() {
    print("Goodbye!")
}

let action = "greet"

switch action {
case "greet":
    sayHello()  // "greet"の場合、sayHelloを呼び出す
case "farewell":
    sayGoodbye()  // "farewell"の場合、sayGoodbyeを呼び出す
default:
    print("Unknown action")
}

func greet(person: String) {
    print("Hello, \(person)!")
}

let name = "Alice"

switch name {
case "Alice", "Bob":
    greet(person: name)  // "Alice"または"Bob"なら、greetを呼び出す
default:
    print("No greeting available")
}

func handleCitrus(fruit: String) {
    print("\(fruit) is a citrus fruit.")
}

func handleBerry(fruit: String) {
    print("\(fruit) is a berry.")
}

let fruit = "Orange"

switch fruit {
case "Orange", "Lemon", "Lime":
    handleCitrus(fruit: fruit)  // Citrusフルーツなら、handleCitrusを呼び出す
case "Strawberry", "Blueberry":
    handleBerry(fruit: fruit)  // ベリー系フルーツなら、handleBerryを呼び出す
default:
    print("\(fruit) is not categorized.")
}

let age = 25

switch age {
case 0...12:
    print("You are a child.")
case 13...19:
    print("You are a teenager.")
case 20...29:
    print("You are in your twenties.")
default:
    print("Age not categorized.")
}

func handleAction(actionType: String) {
    print("\(actionType) action handled.")
}

let action = "start"

switch action {
case "start", "resume", "restart":
    handleAction(actionType: action)  // "start", "resume", "restart"のいずれかの場合、同じ関数を呼び出す
case "stop", "pause":
    print("\(action) action performed.")  // 個別の処理
default:
    print("Unknown action.")
}

func processOrder(status: String) {
    print("Processing \(status) order.")
}

let orderStatus = "shipped"

switch orderStatus {
case "shipped", "delivered":
    processOrder(status: orderStatus)  // 共通の処理
    print("Order complete.")  // 個別の追加処理
case "pending", "processing":
    processOrder(status: orderStatus)  // 共通の処理
    print("Order is still in progress.")  // 別の個別処理
default:
    print("Unknown order status.")
}

func processData() {
    // データ処理のロジック
    print("Data processed.")
}

func updateUI() {
    // UIの更新ロジック
    print("UI updated.")
}

let action = "process"

switch action {
case "process":
    processData()  // データ処理のメソッドを呼び出す
case "update":
    updateUI()  // UI更新のメソッドを呼び出す
default:
    print("Unknown action.")
}

func calculateTotalPrice() {
    // 商品の合計価格を計算する処理
}

func applyDiscount() {
    // 割引を適用する処理
}

switch action {
case "calculate":
    calculateTotalPrice()  // 名前が機能を明確に示している
case "discount":
    applyDiscount()
default:
    print("Unknown action.")
}

func handleNetworkRequest() {
    // 複雑なネットワークリクエスト処理
    print("Network request handled.")
}

func saveDataLocally() {
    // 複雑なローカルデータ保存処理
    print("Data saved locally.")
}

let task = "network"

switch task {
case "network":
    handleNetworkRequest()  // 複雑な処理を別メソッドに分ける
case "save":
    saveDataLocally()
default:
    print("Unknown task.")
}

func logAction(_ action: String) {
    // 任意のアクションをログに記録する
    print("Action logged: \(action)")
}

switch action {
case "start":
    logAction("start")
case "stop":
    logAction("stop")
default:
    logAction("unknown")
}

struct Product {
    let name: String
    let category: String
}

let product = Product(name: "iPhone", category: "Electronics")

switch product.category {
case "Electronics":
    print("\(product.name) is an electronic product.")
case "Clothing":
    print("\(product.name) is a clothing item.")
default:
    print("\(product.name) belongs to an unknown category.")
}

class Vehicle {
    let type: String

    init(type: String) {
        self.type = type
    }

    func performAction() {
        switch self.type {
        case "Car":
            print("Driving the car.")
        case "Bike":
            print("Riding the bike.")
        case "Boat":
            print("Sailing the boat.")
        default:
            print("Unknown vehicle type.")
        }
    }
}

let vehicle = Vehicle(type: "Bike")
vehicle.performAction()  // "Riding the bike."

enum TransportationMode {
    case car(speed: Int)
    case bike
    case train

    func describe() {
        switch self {
        case .car(let speed):
            print("Driving a car at \(speed) km/h.")
        case .bike:
            print("Riding a bike.")
        case .train:
            print("Taking the train.")
        }
    }
}

let mode = TransportationMode.car(speed: 100)
mode.describe()  // "Driving a car at 100 km/h."

class User {
    var name: String
    var age: Int

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }

    func updateName(_ newName: String) -> User {
        self.name = newName
        return self
    }

    func increaseAge(by years: Int) -> User {
        self.age += years
        return self
    }

    func printDetails() -> User {
        print("Name: \(name), Age: \(age)")
        return self
    }
}

let user = User(name: "Alice", age: 30)

switch user.age {
case 0..<18:
    user.updateName("Young \(user.name)").printDetails()  // 若いユーザーの処理
case 18..<50:
    user.increaseAge(by: 5).printDetails()  // 年齢に応じた処理
default:
    user.printDetails()  // その他の年齢に対する処理
}

class Profile {
    var username: String
    var isActive: Bool

    init(username: String, isActive: Bool) {
        self.username = username
        self.isActive = isActive
    }

    func deactivate() -> Profile {
        self.isActive = false
        return self
    }

    func updateUsername(to newName: String) -> Profile {
        self.username = newName
        return self
    }

    func printProfile() -> Profile {
        print("Username: \(username), Active: \(isActive)")
        return self
    }
}

let profile = Profile(username: "SwiftUser", isActive: true)

switch profile.username {
case "Admin":
    profile.updateUsername(to: "AdminUser").deactivate().printProfile()  // Adminユーザーの処理
case "Guest":
    profile.updateUsername(to: "GuestUser").printProfile()  // ゲストユーザーの処理
default:
    profile.printProfile()  // その他のユーザー
}

// メソッドチェーンが長くなる場合は、適切に分割
user.updateName("NewName")
    .increaseAge(by: 5)
    .printDetails()

enum FileError: Error {
    case fileNotFound
    case insufficientPermissions
    case unknown
}

func readFile(filename: String) throws {
    switch filename {
    case "missingFile.txt":
        throw FileError.fileNotFound
    case "protectedFile.txt":
        throw FileError.insufficientPermissions
    default:
        print("File read successfully.")
    }
}

do {
    try readFile(filename: "missingFile.txt")
} catch FileError.fileNotFound {
    print("Error: The file was not found.")
} catch FileError.insufficientPermissions {
    print("Error: You do not have permission to access this file.")
} catch {
    print("An unknown error occurred.")
}

enum NetworkError: Error {
    case disconnected
    case timeout
    case invalidURL
}

func performNetworkRequest(url: String) throws {
    switch url {
    case "invalidURL":
        throw NetworkError.invalidURL
    case "timeoutURL":
        throw NetworkError.timeout
    case "noConnection":
        throw NetworkError.disconnected
    default:
        print("Network request successful.")
    }
}

func handleRequest(url: String) {
    do {
        try performNetworkRequest(url: url)
    } catch NetworkError.invalidURL {
        print("Error: The URL is invalid.")
    } catch NetworkError.timeout {
        print("Error: The request timed out.")
    } catch NetworkError.disconnected {
        print("Error: No network connection.")
    } catch {
        print("An unknown network error occurred.")
    }
}

handleRequest(url: "timeoutURL")

func processRequest(url: String) {
    do {
        try performNetworkRequest(url: url)
    } catch let error as NetworkError {
        switch error {
        case .invalidURL:
            print("Handle invalid URL error.")
        case .timeout:
            print("Handle timeout error.")
        case .disconnected:
            print("Handle no connection error.")
        }
    } catch {
        print("An unexpected error occurred.")
    }
}

processRequest(url: "invalidURL")

func handleAPIResponse(statusCode: Int) {
    switch statusCode {
    case 200:
        print("Success: The request was successful.")
    case 400:
        print("Bad Request: There was an error with the request.")
    case 401:
        print("Unauthorized: Authentication is required.")
    case 500:
        print("Server Error: Something went wrong on the server.")
    default:
        print("Unknown Status Code: \(statusCode)")
    }
}

let responseCode = 200
handleAPIResponse(statusCode: responseCode)

struct APIResponse {
    let statusCode: Int
    let data: [String: Any]?
}

func handleResponse(_ response: APIResponse) {
    switch response.statusCode {
    case 200:
        if let data = response.data, let message = data["message"] as? String {
            print("Success: \(message)")
        } else {
            print("Success: No additional data.")
        }
    case 400:
        print("Bad Request: Please check your request.")
    case 404:
        print("Not Found: The requested resource could not be found.")
    case 500:
        print("Server Error: Internal server error occurred.")
    default:
        print("Unhandled status code: \(response.statusCode)")
    }
}

let successfulResponse = APIResponse(statusCode: 200, data: ["message": "Data retrieved successfully."])
handleResponse(successfulResponse)

enum APIError: Error {
    case invalidResponse
    case noData
    case failedRequest
}

func processAPIResponse(response: APIResponse) throws {
    switch response.statusCode {
    case 200:
        if let data = response.data {
            print("Data received: \(data)")
        } else {
            throw APIError.noData
        }
    case 400, 404:
        throw APIError.invalidResponse
    case 500:
        throw APIError.failedRequest
    default:
        print("Unknown status code.")
    }
}

do {
    let response = APIResponse(statusCode: 500, data: nil)
    try processAPIResponse(response: response)
} catch APIError.invalidResponse {
    print("Error: Invalid response received.")
} catch APIError.noData {
    print("Error: No data in the response.")
} catch APIError.failedRequest {
    print("Error: The request failed due to server issues.")
} catch {
    print("An unknown error occurred.")
}

func add(a: Int, b: Int) -> Int {
    return a + b
}

func subtract(a: Int, b: Int) -> Int {
    return a - b
}

func multiply(a: Int, b: Int) -> Int {
    return a * b
}

func calculate(operation: String, a: Int, b: Int) -> Int {
    switch operation {
    case "add":
        return add(a: a, b: b)
    case "subtract":
        return subtract(a: a, b: b)
    case "multiply":
        return multiply(a: a, b: b)
    default:
        print("Unknown operation")
        return 0
    }
}

let result = calculate(operation: "add", a: 5, b: 3)
print("Result: \(result)")  // Result: 8

func performOperation(_ operation: (Int, Int) -> Int, a: Int, b: Int) {
    let result = operation(a, b)
    print("Result: \(result)")
}

let addOperation: (Int, Int) -> Int = { $0 + $1 }
let subtractOperation: (Int, Int) -> Int = { $0 - $1 }

let operationType = "add"

switch operationType {
case "add":
    performOperation(addOperation, a: 10, b: 5)  // Result: 15
case "subtract":
    performOperation(subtractOperation, a: 10, b: 5)  // Result: 5
default:
    print("Unknown operation")
}

func getRequest() {
    print("Performing GET request")
}

func postRequest() {
    print("Performing POST request")
}

func handleRequest(type: String, requestFunction: () -> Void) {
    print("Handling \(type) request...")
    requestFunction()
}

let requestType = "GET"

switch requestType {
case "GET":
    handleRequest(type: requestType, requestFunction: getRequest)
case "POST":
    handleRequest(type: requestType, requestFunction: postRequest)
default:
    print("Unknown request type")
}