Swift Functions — Default Parameters

#programming #swift #swiftui #ios

In the last article, we touched on default parameters with the findDirections example. This time, let's slow down and really dig into why they exist, when to reach for them, and a few places they show up that you might not expect. 🍥

The Problem Default Parameters Solve

Imagine you're writing a function for an anime training montage generator 🥋:

func startTraining(student: String, intensity: String, withMusic: Bool) {
    print("\(student) begins training at \(intensity) intensity!")
    if withMusic {
        print("🎵 Dramatic music plays 🎵")
    }
}

startTraining(student: "Naruto", intensity: "extreme", withMusic: true)

Now imagine 90% of your training montages are "extreme intensity, with music" — because of course they are. Calling this function with all three parameters every single time gets repetitive fast.

This is exactly the gap default parameters fill: let the common case be short, and the unusual case still possible.

func startTraining(student: String, intensity: String = "extreme", withMusic: Bool = true) {
    print("\(student) begins training at \(intensity) intensity!")
    if withMusic {
        print("🎵 Dramatic music plays 🎵")
    }
}

startTraining(student: "Naruto")
startTraining(student: "Sakura", intensity: "moderate")
startTraining(student: "Rock Lee", intensity: "extreme", withMusic: false)

All three calls are valid. The first uses both defaults, the second overrides just intensity, and the third overrides both extra parameters. 🎉

The Rule: Defaults Go Last (Usually)

Swift doesn't strictly require default parameters to come last, but it's strongly recommended — and here's why.

func describeCharacter(name: String, power: String = "unknown", age: Int) {
    print("\(name) is \(age) years old with \(power) power.")
}

This compiles, but calling it gets awkward:

describeCharacter(name: "Goku", age: 30)

This actually works fine here because both power and age have labels — Swift matches by label, not position, for parameters after the first. But the moment you mix in unlabeled parameters (using _), putting a default in the middle can create confusing or even invalid call sites. The convention exists to keep things predictable: put your "always changes" parameters first, and your "rarely changes" parameters with defaults at the end.

func describeCharacter(name: String, age: Int, power: String = "unknown") {
    print("\(name) is \(age) years old with \(power) power.")
}

describeCharacter(name: "Goku", age: 30)
describeCharacter(name: "Goku", age: 30, power: "Kamehameha")

Much cleaner. ✨

Default Parameters Are Everywhere in Swift's Standard Library

This is the part that clicked for me once I started noticing it: Swift itself uses default parameters constantly, and once you know to look for them, a lot of "magic" behavior makes more sense.

Example 1 — `removeAll(keepingCapacity:)`

var characters = ["Lana", "Pam", "Ray", "Sterling"]
characters.removeAll()
// same as:
characters.removeAll(keepingCapacity: false)

keepingCapacity defaults to false, because most of the time when you clear an array, you're done with that memory. But if you're about to refill it with a similar number of items, removeAll(keepingCapacity: true) avoids Swift having to re-allocate memory from scratch.

Example 2 — String comparison

let name = "naruto"
name.compare("Naruto") // default options
name.compare("Naruto", options: .caseInsensitive)

compare(_:options:) has a default empty options set, so the simple case (case-sensitive comparison) needs no extra arguments — but case-insensitive comparison is one parameter away when you need it.

Example 3 — `print()` itself!

You've been using default parameters this whole time without realizing it:

print("Hello")
print("Hello", separator: " ", terminator: "\n")

print has default values for separator (a single space) and terminator (a newline). That's why print("a", "b", "c") outputs a b c with a line break at the end — and why you can override terminator: "" if you want multiple prints to appear on the same line.

print("Loading", terminator: "")
print("...", terminator: "")
print("done!")
// Output: Loading...done!

A Quick Gotcha: Defaults Don't Mean "Optional"

It's easy to mentally lump default parameters together with optionals (Int?, String?), but they're solving different problems:

A default parameter means "if the caller doesn't specify this, use this fallback value." The parameter inside the function is never nil — it's always a real value (either what was passed, or the default).
An optional means "this value might genuinely not exist, and the function needs to handle that."

// Default parameter — always has a real value inside the function
func greet(name: String = "friend") {
    print("Hello, \(name)!")
}

// Optional — might be nil, function must check
func greet(name: String?) {
    if let name = name {
        print("Hello, \(name)!")
    } else {
        print("Hello, friend!")
    }
}

Both greet() calls above can produce "Hello, friend!" — but they get there very differently, and mixing up which one you need can lead to unnecessary if let checks when a default parameter would've done the job.

Wrap Up

Default parameters are one of those features that feel small at first but show up everywhere once you start looking — both in your own code and throughout Swift's standard library. The core idea is simple: make the common case effortless, while keeping the door open for customization.

A good rule of thumb when designing your own functions: if you find yourself passing the same value to a parameter 90% of the time, that's a strong candidate for a default. 🍥

I know these Swift concepts well from hands-on practice — I use AI to help draft and organize my explanations, and every example and structure choice is something I've reviewed and stand behind.