Omitting argument labels with _ in Swift - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does using an underscore (_) before a function parameter in Swift do?

It tells Swift to omit the argument label when calling the function, so you only pass the value without naming the parameter.

beginner

How do you define a Swift function that takes two integers without requiring argument labels when calling it?

Use underscores before both parameters like this:

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

intermediate

Why might you want to omit argument labels in Swift functions?

To make function calls shorter and cleaner when the meaning is clear without labels, similar to how some built-in Swift functions work.

beginner

What happens if you omit the underscore and call a Swift function without argument labels?

Swift will give a compile-time error because it expects argument labels by default unless you use an underscore to omit them.

beginner

Example: How do you call this function?

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

You call it without the argument label:

greet("Alice")

Not like greet(name: "Alice").

What does the underscore (_) before a parameter name in a Swift function mean?

A The argument label is omitted when calling the function

B The parameter is optional

C The parameter is a constant

D The parameter is ignored inside the function

Using _ before a parameter means you don't have to write the argument label when calling the function.

Given this function:

func multiply(_ x: Int, y: Int) -> Int { x * y }

How do you call it correctly?

A multiply(3, y: 4)

B multiply(x: 3, y: 4)

C multiply(3, 4)

D multiply(x: 3, 4)

The first parameter omits the label, so just pass the value. The second requires the label 'y:'.

What error will you get if you call a function with argument labels omitted but the function requires them?

A Runtime error

B Compile-time error

C No error, it works fine

D Warning only

Swift enforces argument labels at compile time unless you use _ to omit them.

Why might you NOT want to omit argument labels in Swift functions?

A To reduce memory usage

B To make the code run faster

C To improve code readability and clarity

D To avoid syntax errors

Argument labels help make function calls clear and understandable.

How do you define a function with no argument labels for all parameters?

A Use default values

B Omit parameter names entirely

C Use optional parameters

D Use _ before each parameter name

Placing _ before each parameter name tells Swift to omit argument labels for those parameters.

Explain how to omit argument labels in Swift functions and why you might want to do it.

Think about how you write function calls without labels.

Describe what happens if you call a Swift function without argument labels when the function expects them.

Consider Swift's strictness about argument labels.

Practice

1. What does the underscore _ do when used before a function parameter in Swift?

easy

A. It changes the parameter type to Any.

B. It makes the parameter optional.

C. It makes the parameter a constant inside the function.

D. It allows you to call the function without writing the argument label.

Solution

1. Step 1: Understand the role of underscore in parameters

   The underscore before a parameter name tells Swift to omit the argument label when calling the function.

2. Step 2: Effect on function call

   This means you can pass the argument directly without naming it, making the call shorter and simpler.

3. Final Answer:

   It allows you to call the function without writing the argument label. -> Option D

4. Quick Check:

   Underscore = omit argument label [OK]

Hint: Underscore means skip argument label when calling [OK]

Common Mistakes:

• Thinking underscore makes parameter optional
• Confusing underscore with type changes
• Assuming underscore affects parameter mutability

2. Which of the following function declarations correctly omits the argument label for the first parameter?

easy

A. func greet(_name: String) { print("Hello, \(_name)!") }

B. func greet(_ name: String) { print("Hello, \(name)!") }

C. func greet(name _ : String) { print("Hello, \(name)!") }

D. func greet(name: String) { print("Hello, \(name)!") }

Solution

1. Step 1: Identify correct underscore usage

   The underscore must appear before the parameter name with a space, like _ name: String.

2. Step 2: Check each option

   func greet(_ name: String) { print("Hello, \(name)!") } uses _ name: String correctly. func greet(name: String) { print("Hello, \(name)!") } uses a label. func greet(name _ : String) { print("Hello, \(name)!") } has wrong syntax. func greet(_name: String) { print("Hello, \(_name)!") } uses an invalid parameter name.

3. Final Answer:

   func greet(_ name: String) { print("Hello, \(name)!") } -> Option B

4. Quick Check:

   Correct underscore syntax = func greet(_ name: String) { print("Hello, \(name)!") } [OK]

Hint: Underscore must be alone before parameter name [OK]

Common Mistakes:

• Putting underscore after parameter name
• Adding spaces between underscore and name incorrectly
• Using underscore as part of parameter name

3. What is the output of this Swift code?

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

print(multiply(3, 4))

medium

A. 12

B. multiply(3, 4)

C. Error: Missing argument labels

D. 7

Solution

1. Step 1: Understand function parameters with underscore

   Both parameters have underscores, so argument labels are omitted when calling.

2. Step 2: Calculate the function result

   Calling multiply(3, 4) returns 3 * 4 = 12, which is printed.

3. Final Answer:

   12 -> Option A

4. Quick Check:

   3 * 4 = 12 [OK]

Hint: Underscore means call without labels, so multiply(3,4) works [OK]

Common Mistakes:

• Expecting argument labels in call
• Confusing output with string of function call
• Adding parameters incorrectly

4. Identify the error in this Swift function call:

func divide(_ numerator: Double, denominator: Double) -> Double {
    return numerator / denominator
}

divide(10, denominator: 2)

medium

A. Cannot mix omitted and required labels in parameters

B. Missing argument label for denominator

C. No error, code runs fine

D. Missing argument label for numerator

Solution

1. Step 1: Analyze parameter labels

   The first parameter uses underscore, so no label needed. The second requires label denominator.

2. Step 2: Check function call

   The call uses divide(10, denominator: 2), which matches the parameter labels correctly.

3. Final Answer:

   No error, code runs fine -> Option C

4. Quick Check:

   Underscore omits first label, second label required [OK]

Hint: First param no label, second param label required [OK]

Common Mistakes:

• Expecting both labels omitted
• Trying to omit second label incorrectly
• Confusing parameter order

5. You want to write a Swift function formatDate that takes a Date and a String format. You want to call it like formatDate(myDate, "yyyy-MM-dd") without argument labels. Which function declaration is correct?

hard

A. func formatDate(_ date: Date, _ format: String) -> String { /* implementation */ }

B. func formatDate(date: Date, format: String) -> String { /* implementation */ }

C. func formatDate(_ date: Date, format: String) -> String { /* implementation */ }

D. func formatDate(date: Date, _ format: String) -> String { /* implementation */ }

Solution

1. Step 1: Understand call without labels

   Calling formatDate(myDate, "yyyy-MM-dd") means both parameters must omit labels.

2. Step 2: Match function declaration

   Only func formatDate(_ date: Date, _ format: String) -> String { /* implementation */ } uses underscore for both parameters, allowing call without labels.

3. Final Answer:

   func formatDate(_ date: Date, _ format: String) -> String { /* implementation */ } -> Option A

4. Quick Check:

   Both params underscore = no labels in call [OK]

Hint: Use underscore for all params to omit all labels [OK]

Common Mistakes:

• Omitting only one label but calling without both
• Mixing labeled and unlabeled parameters incorrectly
• Forgetting underscore syntax