Swiftのwhere句を使った高度な条件分岐の実装方法を徹底解説

let numbers = [1, 2, 3, 4, 5, 6]

for number in numbers where number % 2 == 0 {
    print(number)
}

let age = 25

switch age {
case let x where x >= 18 && x <= 30:
    print("You are a young adult.")
default:
    print("Age does not fall into the target group.")
}

let names = ["Alice", "Bob", "Charlie", "Dave", "Eve"]

for name in names where name.contains("e") {
    print("\(name) contains the letter 'e'")
}

let numbers = [10, -5, 20, 0, -15]

for number in numbers {
    switch number {
    case let x where x > 0:
        print("\(x) is positive")
    case let x where x < 0:
        print("\(x) is negative")
    default:
        print("\(number) is zero")
    }
}

let scores = [65, 80, 90, 70, 55]

scores.forEach {
    if $0 >= 70 where $0 <= 90 {
        print("Score \($0) is within the target range")
    }
}

class Person {
    var name: String
    var age: Int

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

    func checkEligibility() {
        if age >= 18 where age <= 65 {
            print("\(name) is eligible for the program.")
        } else {
            print("\(name) is not eligible.")
        }
    }
}

let person1 = Person(name: "Alice", age: 25)
let person2 = Person(name: "Bob", age: 70)

person1.checkEligibility()  // Alice is eligible for the program.
person2.checkEligibility()  // Bob is not eligible.

struct Employee {
    var name: String
    var salary: Int

    func isHighEarner() {
        if salary >= 50000 where salary < 100000 {
            print("\(name) is a mid-level earner.")
        } else if salary >= 100000 {
            print("\(name) is a high-level earner.")
        } else {
            print("\(name) is a low-level earner.")
        }
    }
}

let employee1 = Employee(name: "John", salary: 75000)
let employee2 = Employee(name: "Doe", salary: 120000)

employee1.isHighEarner()  // John is a mid-level earner.
employee2.isHighEarner()  // Doe is a high-level earner.

protocol Displayable {
    associatedtype Item
    func display(item: Item)
}

struct StringDisplay: Displayable {
    typealias Item = String

    func display(item: String) {
        print("Displaying string: \(item)")
    }
}

struct NumberDisplay<T>: Displayable where T: Numeric {
    typealias Item = T

    func display(item: T) {
        print("Displaying number: \(item)")
    }
}

let stringDisplay = StringDisplay()
stringDisplay.display(item: "Hello")

let numberDisplay = NumberDisplay<Int>()
numberDisplay.display(item: 100)

protocol ComparableContainer {
    associatedtype Item: Comparable
    func compare(_ item1: Item, _ item2: Item) -> Bool
}

struct IntegerContainer: ComparableContainer {
    func compare(_ item1: Int, _ item2: Int) -> Bool {
        return item1 > item2
    }
}

struct StringContainer: ComparableContainer where Item == String {
    func compare(_ item1: String, _ item2: String) -> Bool {
        return item1 < item2
    }
}

let intContainer = IntegerContainer()
print(intContainer.compare(10, 5))  // true

let stringContainer = StringContainer()
print(stringContainer.compare("apple", "banana"))  // true

extension ComparableContainer where Item == Int {
    func isPositive(_ item: Item) -> Bool {
        return item > 0
    }
}

let anotherIntContainer = IntegerContainer()
print(anotherIntContainer.isPositive(5))  // true

protocol Identifiable {
    var id: String { get }
}

protocol EquatableContainer {
    associatedtype Item: Equatable
}

struct User: Identifiable, Equatable {
    var id: String
}

struct UserContainer<T: Identifiable & Equatable>: EquatableContainer where T == User {
    var users: [T]

    func findUser(byId id: String) -> T? {
        return users.first { $0.id == id }
    }
}

let user1 = User(id: "123")
let user2 = User(id: "456")
let container = UserContainer(users: [user1, user2])

if let foundUser = container.findUser(byId: "123") {
    print("Found user: \(foundUser.id)")  // Found user: 123
}

protocol Stackable {
    associatedtype Element
    var elements: [Element] { get set }
    mutating func push(_ element: Element)
    mutating func pop() -> Element?
}

extension Stackable where Element: Numeric {
    mutating func sum() -> Element {
        return elements.reduce(0, +)
    }
}

struct IntStack: Stackable {
    var elements = [Int]()

    mutating func push(_ element: Int) {
        elements.append(element)
    }

    mutating func pop() -> Int? {
        return elements.popLast()
    }
}

var stack = IntStack()
stack.push(10)
stack.push(20)
print(stack.sum())  // 30

func compareValues<T: Comparable>(_ a: T, _ b: T) -> Bool where T: Numeric {
    return a > b
}

let result1 = compareValues(10, 20)   // false
let result2 = compareValues(5.5, 2.3) // true

func processItems<T, U>(item1: T, item2: U) where T: Equatable, U: Comparable {
    print("Processing items \(item1) and \(item2)")
}

processItems(item1: "Hello", item2: 100)

class NumberContainer<T> where T: Numeric {
    var number: T

    init(number: T) {
        self.number = number
    }

    func add(_ value: T) -> T {
        return number + value
    }
}

let intContainer = NumberContainer(number: 10)
print(intContainer.add(5))  // 15

let doubleContainer = NumberContainer(number: 5.5)
print(doubleContainer.add(2.5))  // 8.0

protocol Stackable {
    associatedtype Element
    mutating func push(_ element: Element)
    mutating func pop() -> Element?
}

extension Stackable where Element: Equatable {
    func isTopElement(_ element: Element) -> Bool {
        return self.pop() == element
    }
}

struct IntStack: Stackable {
    var elements = [Int]()

    mutating func push(_ element: Int) {
        elements.append(element)
    }

    mutating func pop() -> Int? {
        return elements.popLast()
    }
}

var stack = IntStack()
stack.push(10)
stack.push(20)
print(stack.isTopElement(20))  // true

class Animal {
    var name: String
    init(name: String) {
        self.name = name
    }
}

class Dog: Animal {}

class Cat: Animal {}

func makeSound<T: Animal>(for animal: T) where T: Dog {
    print("\(animal.name) says: Woof!")
}

let dog = Dog(name: "Buddy")
makeSound(for: dog)  // Buddy says: Woof!

let optionalNumber: Int? = 42

if let number = optionalNumber where number > 40 {
    print("Number is greater than 40: \(number)")
} else {
    print("Number does not meet the condition or is nil.")
}

let optionalNumbers: [Int?] = [10, nil, 30, nil, 50]

for case let number? in optionalNumbers where number > 20 {
    print("Number greater than 20: \(number)")
}

let optionalAge: Int? = 25

switch optionalAge {
case let age? where age >= 18 && age <= 30:
    print("Age is within the target range: \(age)")
case nil:
    print("No age provided.")
default:
    print("Age is outside the target range.")
}

let optionalNames: [String?] = ["Alice", nil, "Bob", nil, "Charlie"]

let filteredNames = optionalNames.compactMap { $0 }.filter { $0.count > 3 }
print(filteredNames)  // ["Alice", "Charlie"]

func process(optionalName: String?) {
    guard let name = optionalName where name.count > 3 else {
        print("Invalid name or name is too short.")
        return
    }
    print("Processing name: \(name)")
}

process(optionalName: "Bob")    // Invalid name or name is too short.
process(optionalName: "Alice")  // Processing name: Alice

enum NetworkError: Error {
    case badURL
    case timeout(seconds: Int)
    case serverError(code: Int)
}

func fetchData(from url: String) throws {
    if url.isEmpty {
        throw NetworkError.badURL
    } else {
        throw NetworkError.timeout(seconds: 30)
    }
}

do {
    try fetchData(from: "")
} catch NetworkError.badURL {
    print("Invalid URL.")
} catch NetworkError.timeout(let seconds) where seconds > 20 {
    print("Timeout after \(seconds) seconds. Try again later.")
} catch {
    print("An unknown error occurred.")
}

enum ValidationError: Error {
    case tooShort
    case containsInvalidCharacters
}

func validateUsername(_ username: String?) throws {
    guard let username = username where username.count >= 5 else {
        throw ValidationError.tooShort
    }

    guard username.range(of: "[^a-zA-Z0-9]", options: .regularExpression) == nil else {
        throw ValidationError.containsInvalidCharacters
    }

    print("Username is valid.")
}

do {
    try validateUsername("user")
} catch ValidationError.tooShort {
    print("Username is too short.")
} catch ValidationError.containsInvalidCharacters {
    print("Username contains invalid characters.")
} catch {
    print("An unknown error occurred.")
}

enum FileError: Error {
    case fileNotFound
    case permissionDenied
}

func readFile(at path: String) -> Result<String, FileError> {
    if path.isEmpty {
        return .failure(.fileNotFound)
    } else {
        return .failure(.permissionDenied)
    }
}

let result = readFile(at: "")

switch result {
case .success(let content):
    print("File content: \(content)")
case .failure(let error) where error == .fileNotFound:
    print("Error: File not found.")
case .failure(let error) where error == .permissionDenied:
    print("Error: Permission denied.")
}

enum PaymentError: Error {
    case insufficientFunds(currentBalance: Double)
    case cardExpired(expirationDate: String)
}

func processPayment(amount: Double, balance: Double) throws {
    if balance < amount {
        throw PaymentError.insufficientFunds(currentBalance: balance)
    }
}

do {
    try processPayment(amount: 100, balance: 50)
} catch PaymentError.insufficientFunds(let balance) where balance < 20 {
    print("Insufficient funds and balance is critically low.")
} catch PaymentError.insufficientFunds {
    print("Insufficient funds.")
} catch {
    print("An unknown error occurred.")
}

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

let evenNumbers = numbers.filter { $0 % 2 == 0 }
print(evenNumbers)  // [2, 4, 6, 8, 10]

let studentsScores = ["Alice": 85, "Bob": 72, "Charlie": 90, "Dave": 65]

let passingStudents = studentsScores.filter { $0.value >= 75 }
print(passingStudents)  // ["Alice": 85, "Charlie": 90]

let fruits = ["Apple", "Banana", "Cherry", "Blueberry", "Grapes"]

for fruit in fruits where fruit.contains("e") {
    print(fruit)
}

func filterValues<T: Numeric & Comparable>(from array: [T], where condition: (T) -> Bool) -> [T] {
    return array.filter { condition($0) }
}

let numbers = [10, 15, 20, 25, 30]
let filteredNumbers = filterValues(from: numbers) { $0 > 20 }
print(filteredNumbers)  // [25, 30]

let names = ["John", "Alice", "Bob", "Charlie", "David"]

let filteredNames = names.filter { $0.contains("a") && $0.count >= 4 }
print(filteredNames)  // ["Alice", "Charlie", "David"]

struct Person {
    let name: String
    let age: Int
}

let people = [
    Person(name: "Alice", age: 25),
    Person(name: "Bob", age: 30),
    Person(name: "Charlie", age: 35)
]

let youngPeople = people.filter { $0.age < 30 }
print(youngPeople.map { $0.name })  // ["Alice"]

struct ContentView: View {
    @State private var age: Int = 25

    var body: some View {
        VStack {
            if age >= 18 where age < 30 {
                Text("You are a young adult.")
            } else if age >= 30 {
                Text("You are an adult.")
            } else {
                Text("You are a minor.")
            }
        }
    }
}

struct ContentView: View {
    let students = [
        "Alice": 85,
        "Bob": 72,
        "Charlie": 90,
        "Dave": 65
    ]

    var body: some View {
        List(students.filter { $0.value >= 75 }, id: \.key) { name, score in
            Text("\(name) scored \(score)")
        }
    }
}

struct ContentView: View {
    @State private var showAdults: Bool = false
    let people = [
        "Alice": 25,
        "Bob": 17,
        "Charlie": 35
    ]

    var body: some View {
        VStack {
            Button("Toggle Adults") {
                showAdults.toggle()
            }

            List(people.filter { showAdults ? $0.value >= 18 : true }, id: \.key) { name, age in
                Text("\(name) is \(age) years old")
            }
        }
    }
}

struct ContentView: View {
    let items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    var body: some View {
        VStack {
            ForEach(items.filter { $0 % 2 == 0 }, id: \.self) { item in
                Text("Even number: \(item)")
            }
        }
    }
}

struct ContentView: View {
    @State private var isOn: Bool = false

    var body: some View {
        VStack {
            Toggle("Switch", isOn: $isOn)

            if isOn where !isOn {
                Text("Toggle is OFF")
                    .transition(.slide)
            } else {
                Text("Toggle is ON")
                    .transition(.opacity)
            }
        }
        .animation(.default, value: isOn)
    }
}

struct User {
    let name: String
    let age: Int
    let isVIP: Bool
}

let users = [
    User(name: "Alice", age: 25, isVIP: false),
    User(name: "Bob", age: 35, isVIP: true),
    User(name: "Charlie", age: 17, isVIP: false),
    User(name: "David", age: 40, isVIP: false),
    User(name: "Eve", age: 29, isVIP: true)
]

for user in users {
    switch user {
    case let u where u.age >= 18 && u.age < 30:
        print("\(u.name) is a young adult.")
    case let u where u.age >= 30 && u.isVIP:
        print("\(u.name) is a VIP.")
    default:
        print("\(user.name) does not meet any special criteria.")
    }
}

Alice is a young adult.
Bob is a VIP.
Charlie does not meet any special criteria.
David does not meet any special criteria.
Eve is a young adult.

let vipUsers = users.filter { $0.age >= 30 && $0.isVIP }
print(vipUsers.map { $0.name })  // ["Bob"]

func filterUsers<T>(from array: [T], where condition: (T) -> Bool) -> [T] {
    return array.filter { condition($0) }
}

let filteredVIPs = filterUsers(from: users) { $0.age >= 30 && $0.isVIP }
print(filteredVIPs.map { $0.name })  // ["Bob"]

for user in users {
    switch user {
    case let u where u.age >= 40 && !u.isVIP:
        print("\(u.name) is an elder non-VIP.")
    case let u where u.age < 40 && u.isVIP:
        print("\(u.name) is a young VIP.")
    default:
        print("\(user.name) does not meet the criteria.")
    }
}

Alice does not meet the criteria.
Bob is a young VIP.
Charlie does not meet the criteria.
David is an elder non-VIP.
Eve is a young VIP.

let ageRange = 18...35
let dynamicFilteredUsers = users.filter { ageRange.contains($0.age) && $0.isVIP }
print(dynamicFilteredUsers.map { $0.name })  // ["Bob", "Eve"]