Swift if and switch

let temperature = 18
if temperature > 25 {
    print("Shorts weather")
} else if temperature > 15 {
    print("Bring a jumper")
} else {
    print("Coat on")
}

• No brackets are needed around the condition, but the braces are required, even for one line.
• The condition must be a real Bool; Swift won't treat a number as true or false.
• Only the first true branch runs.

The ternary operator picks between two values in one line: let label = score >= 50 ? "Pass" : "Fail". Keep it for simple choices; nested ternaries are hard to read.

switch day {
case "Sat", "Sun":
    print("Weekend")
case "Fri":
    print("Almost there")
default:
    print("Weekday")
}

• Each case lists one or more values, separated by commas.
• A switch must be exhaustive. For strings and numbers, that means a default case. For enums, listing every case is enough.
• There's no fallthrough: after a matching case runs, the switch ends. No break is needed.
• Every case must contain at least one statement; write break for a case that should do nothing.

Cases can match much more than single values:

switch score {
case 90...100: grade = "A"
case 75..<90:  grade = "B"
case 0..<75:   grade = "C"
default:       grade = "Invalid"
}

switch (x, y) {
case (0, 0):           print("Origin")
case (_, 0):           print("On the x-axis")
case (let a, let b) where a == b: print("On the diagonal")
default:               print("Somewhere else")
}

_ matches anything, let binds part of the value to a name, and where adds an extra condition to a case.

Since Swift 5.9, if and switch can produce a value directly when each branch is a single expression:

let fee = if isMember { 0.0 } else { 4.99 }

let advice = switch weather {
    case "sun": "Sun cream"
    case "rain": "Umbrella"
    default: "Check the forecast"
}

This avoids declaring a variable and assigning it in every branch. On older Swift versions, use the ternary operator or assign inside each branch.

Swift's switch never falls into the next case by accident, but you can ask for it with fallthrough. It runs the next case's body without checking that case's pattern:

let code = 404
switch code {
case 200..<300:
    print("Success")
case 404:
    print("Not found")
    fallthrough
case 400..<500:
    print("Client error")
default:
    print("Other")
}
// Not found
// Client error

You'll rarely need it; listing several values in one case is usually clearer.

When you only care about one pattern, a whole switch is heavy. if case tests a single pattern, using the same syntax as a case:

let rating = 4
if case 1...5 = rating { print("Valid rating") }

let point = (2, 0)
if case (_, 0) = point { print("On the x-axis") }

The pattern comes first and the value after =. It reads backwards at first, but it lets you use ranges, tuples and enum cases in an ordinary if.

An if can take a list of conditions separated by commas. They're checked left to right, and the block runs only if every one is true, much like &&:

if age >= 18, hasTicket, seat != nil {
    print("Come in")
}

The difference shows up with optionals: a comma list can mix let unwrapping with ordinary tests, as in if let seat, seat > 10, where && can't. The same rule applies to guard and while.