AI Reading
Quick summary of this article
Swift functions are reusable blocks of code that help organize programs into logical sections, making them easier to read and maintain. Functions can accept parameters, return values, and even be nested inside other functions. Closures are similar to functions but are anonymous blocks that can be stored and passed around, often used as callbacks or completion handlers.
- Functions are defined with the
funckeyword and can take parameters, return values, or both; for example,func square(number: Int) -> Intreturns the squared value of its input. - Parameters can have default values (like
name: String = "Guest") so callers can omit them, and variadic parameters (likeInt...) accept zero or more values of the same type. - Nested functions are allowed in Swift, meaning you can define a function inside another function and call it from within the outer function's scope.
- Closures use a compact syntax with
{ (parameters) -> ReturnType in code }and can be stored in variables, passed as function arguments, or used as completion handlers. - Shorthand closure syntax uses
$0,$1, etc., for parameters, making expressions like{ $0 + $1 }a quick way to write simple operations.
Module 4: Functions and Closures in Swift
Functions are reusable blocks of code that perform specific tasks. In Swift, functions help organize your code into logical sections, making it easier to read, debug, and maintain.
Defining a Function
Here’s the basic syntax to define a function in Swift:
func greet() {
print("Hello, Swift learner!")
}This function named greet takes no parameters and simply prints a message.
Calling a Function
To execute a function, call it by its name followed by parentheses:
greet()
// Output: Hello, Swift learner!Functions with Parameters and Return Values
Functions can accept inputs (parameters) and return a value.
Example: Function with Parameter
func greet(name: String) {
print("Hello, \(name)!")
}
greet(name: "John")
// Output: Hello, John!Example: Function with Return Value
func square(number: Int) -> Int {
return number * number
}
let result = square(number: 5)
print(result) // Output: 25Functions with Multiple Parameters
func add(a: Int, b: Int) -> Int {
return a + b
}
print(add(a: 3, b: 7)) // Output: 10Default Parameter Values
You can provide default values for parameters so callers can omit them.
func greet(name: String = "Guest") {
print("Welcome, \(name)!")
}
greet() // Output: Welcome, Guest!
greet(name: "Amy") // Output: Welcome, Amy!Variadic Parameters
Functions can accept zero or more values of the same type.
func sum(numbers: Int...) -> Int {
var total = 0
for number in numbers {
total += number
}
return total
}
print(sum(numbers: 1, 2, 3, 4)) // Output: 10Nested Functions
Swift allows defining functions inside other functions.
func outerFunction() {
func innerFunction() {
print("Inner function called")
}
innerFunction()
}
outerFunction()
// Output: Inner function calledWhat Are Closures?
Closures are self-contained blocks of functionality that can be passed around and used in your code. They are similar to anonymous functions or lambdas in other languages.
Basic Closure Syntax
let sayHello = {
print("Hello from closure!")
}
sayHello()
// Output: Hello from closure!Closures with Parameters and Return Values
let multiply = { (a: Int, b: Int) -> Int in
return a * b
}
print(multiply(4, 5)) // Output: 20Using Closures as Function Parameters
Closures are often used as callbacks or completion handlers.
func performOperation(_ operation: (Int, Int) -> Int, a: Int, b: Int) {
let result = operation(a, b)
print("Result: \(result)")
}
performOperation({ $0 + $1 }, a: 10, b: 20) // Output: Result: 30Shorthand Closure Syntax
performOperation({ $0 * $1 }, a: 3, b: 7) // Output: Result: 21Summary
- Functions are reusable code blocks defined with
func. - Functions can take parameters and return values.
- Parameters can have default values or accept multiple arguments (variadic).
- Closures are anonymous functions that can be stored in variables or passed around.
- Closures can simplify callbacks and functional programming patterns.