Swift Variables and Constants

let name = "Ada"        // constant: can't change
var score = 0           // variable: can change
score = 10
score += 5

• let values must be set once and never reassigned. name = "Grace" is a compile error: "cannot assign to value: 'name' is a 'let' constant".
• var values can be changed as often as you like, but always to a value of the same type.
• Use let by default, and switch to var only when the value really needs to change.

Swift infers the type from the value, so let age = 30 is an Int and let price = 9.99 is a Double. Add a type annotation with a colon when you want to be explicit, or when there's no value yet: var total: Double = 0 makes the 0 a Double, and let initial: Character = "A" makes a Character instead of a String.

• Names can include letters, digits and underscores, and even emoji, but can't start with a digit or contain spaces.
• Use lowerCamelCase: firstName, totalPrice, isLoggedIn.
• Names are case-sensitive: score and Score are different.
• Booleans read best as questions: isMember, hasTicket, canEdit.

Clear names matter more than short ones. let secondsPerMinute = 60 explains itself, while let s = 60 makes readers guess.

Swift never converts types automatically, not even Int to Double, which prevents subtle bugs. Convert explicitly:

let count = 3
let price = 2.5
let total = Double(count) * price      // 7.5
let whole = Int(9.99)                  // 9, decimals dropped
let text = String(count)               // "3"
let number = Int("42")                 // Optional(42): might fail

Turning text into a number might fail, so Int("42") returns an optional that you unwrap safely, as the optionals lesson explains.

A tuple groups a few values together: let point = (x: 3, y: 4), then point.x. Tuples are handy for returning two values from a function.

A let doesn't have to get its value on the same line. You can declare it with a type and assign it exactly once later, which is useful when the value depends on a decision:

let isMember = true
let message: String
if isMember {
    message = "Welcome back"
} else {
    message = "Sign up today"
}
print(message)       // Welcome back

The compiler checks every path. If one branch forgets to assign message, or tries to assign it twice, the code won't compile, and reading message before it has a value is also an error. This lets you keep a value constant even when working it out takes a few lines.

You can declare more than one variable in a single statement, separated by commas, and you can pull a tuple apart into separate names:

var a = 1, b = 2
let (x, y) = (3, 4)          // x is 3, y is 4
let (width, _) = (5, 6)      // _ ignores the second value
(a, b) = (b, a)              // swap: a is 2, b is 1

Pulling a tuple apart like this is called destructuring. The underscore _ means "I don't need this value", and you'll see it again in loops and functions. Swapping with a tuple needs no temporary variable, because Swift reads both values on the right before assigning either one.