Functions are one of the most important building blocks of Swift programming.
When you start learning Swift, you may initially write code line by line:
let firstNumber = 10
let secondNumber = 20
let total = firstNumber + secondNumber
print(total)
This works perfectly for a small program.
But what happens if you need to perform the same calculation 20 times?
Copying the same code repeatedly would make your program longer, harder to maintain, and more difficult to understand.
This is where Swift functions become useful.
A function allows you to group a set of instructions into a reusable block of code.
Instead of repeating the same logic, you define it once and call it whenever you need it.
In this complete beginner’s guide, you will learn:
- What a function is in Swift
- Why functions are important
- How to create and call functions
- Function parameters
- Multiple parameters
- Return values
- Multiple return values
- Argument labels
- Omitting argument labels
- Default parameter values
- Variadic parameters
inoutparameters- Function types
- Functions as parameters
- Functions as return values
- Nested functions
- Early exits with
guard - Throwing functions
- Async functions
- Functions vs methods
- Functions vs closures
- Common beginner mistakes
- Practical Swift function examples
By the end of this guide, you should be comfortable creating and using functions in your own Swift programs.
What Is a Function in Swift?
A function is a named, reusable block of code designed to perform a particular task.
Consider:
func sayHello() {
print("Hello!")
}
This creates a function named:
sayHello
The function contains:
print("Hello!")
However, defining a function does not automatically execute its code.
To run it, you call the function:
sayHello()
Output:
Hello!
The basic idea is:
Define Function
↓
Call Function
↓
Function Executes
↓
Result / Output
Why Do We Use Functions in Swift?
Functions provide several important benefits.
1. Code Reusability
Without a function:
print("Welcome to Swift!")
print("Welcome to Swift!")
print("Welcome to Swift!")
With a function:
func showWelcomeMessage() {
print("Welcome to Swift!")
}
showWelcomeMessage()
showWelcomeMessage()
showWelcomeMessage()
The logic is written once and reused.
2. Better Code Organization
Instead of placing everything in one large block, you can divide your program into smaller responsibilities.
For example:
func loginUser() {
// Login logic
}
func fetchUserProfile() {
// Profile logic
}
func logoutUser() {
// Logout logic
}
Each function has a clear purpose.
3. Easier Maintenance
Suppose the same calculation is repeated in ten different places.
If the calculation changes, you may have to update all ten copies.
If it exists inside one function, you usually update only that function.
4. Improved Readability
Compare:
let finalPrice = price - (price * discount / 100)
with:
let finalPrice = calculateDiscountedPrice()
A well-named function can explain the purpose of the code.
5. Easier Testing
Small functions with clear inputs and outputs are easier to test than large blocks containing many unrelated responsibilities.
Basic Swift Function Syntax
The basic syntax is:
func functionName() {
// Code
}
Swift uses the keyword:
func
to declare a function.
Example:
func greet() {
print("Hello Swift!")
}
Call it:
greet()
Output:
Hello Swift!
Understanding the Function Syntax
Consider:
func greet() {
print("Hello Swift!")
}
Let’s break it down.
func
Declares a function.
greet
The name of the function.
()
Contains the function’s parameter list.
This function doesn’t receive any parameters, so it is empty.
{ }
The function body.
Everything inside these braces belongs to the function.
Calling a Swift Function
After defining:
func greet() {
print("Hello!")
}
call it using:
greet()
You can call it multiple times:
greet()
greet()
greet()
Output:
Hello!
Hello!
Hello!
This demonstrates one of the main benefits of functions: reuse.
Functions with Parameters
A function becomes much more useful when you can send data into it.
Suppose we want to greet different users.
Instead of:
func greet() {
print("Hello Alex")
}
we can define:
func greet(name: String) {
print("Hello, \(name)!")
}
Now call:
greet(name: "Alex")
Output:
Hello, Alex!
Call it again:
greet(name: "John")
Output:
Hello, John!
The same function now works with different data.
What Is a Function Parameter?
In:
func greet(name: String) {
print("Hello, \(name)!")
}
this:
name: String
is a parameter.
It means the function expects a String value.
When you call:
greet(name: "Emma")
"Emma" is the value passed to the function.
Inside the function:
name
contains:
Emma
Functions with Multiple Parameters
A function can accept multiple parameters.
Example:
func introduce(name: String, age: Int) {
print("My name is \(name) and I am \(age) years old.")
}
Call:
introduce(name: "Alex", age: 25)
Output:
My name is Alex and I am 25 years old.
Another example:
func add(a: Int, b: Int) {
print(a + b)
}
Call:
add(a: 10, b: 20)
Output:
30
Functions with Return Values
So far, our functions have directly printed their results.
For example:
func add(a: Int, b: Int) {
print(a + b)
}
But in real applications, it is often better for a function to return a value.
Example:
func add(a: Int, b: Int) -> Int {
return a + b
}
Call:
let result = add(a: 10, b: 20)
print(result)
Output:
30
Understanding -> Int
Consider:
func add(a: Int, b: Int) -> Int
The:
-> Int
means:
This function returns an
Int.
For example:
func getName() -> String {
return "Alex"
}
The function returns a String.
Use it:
let name = getName()
print(name)
Output:
Alex
Returning Different Data Types
Functions can return many different types.
Return String
func getMessage() -> String {
return "Welcome to Swift"
}
Return Int
func getAge() -> Int {
return 25
}
Return Double
func getPrice() -> Double {
return 99.99
}
Return Bool
func isLoggedIn() -> Bool {
return true
}
Return Array
func getLanguages() -> [String] {
return ["Swift", "Kotlin", "Dart"]
}
Functions can also return custom structs, classes, enums, optionals, tuples, and many other Swift types.
Implicit Returns in Swift
For simple single-expression functions, Swift can often infer the return without explicitly writing return.
Instead of:
func square(number: Int) -> Int {
return number * number
}
you can write:
func square(number: Int) -> Int {
number * number
}
Use:
print(square(number: 5))
Output:
25
For beginners, writing return explicitly can sometimes make the intention easier to understand, but you should recognize both styles.
Function Without a Return Value
A function does not have to return a value.
Example:
func showMessage() {
print("Welcome!")
}
This function performs an action but does not provide a value for the caller to use.
You may also see its return behavior described using Void.
For example:
func showMessage() -> Void {
print("Welcome!")
}
The shorter version is normally preferred:
func showMessage() {
print("Welcome!")
}
Returning Multiple Values with Tuples
Swift functions can return multiple related values using a tuple.
Example:
func getUser() -> (name: String, age: Int) {
return ("Alex", 25)
}
Call:
let user = getUser()
print(user.name)
print(user.age)
Output:
Alex
25
This is useful when a function naturally produces a small group of related results.
Another Multiple Return Example
func calculate(a: Int, b: Int) -> (sum: Int, difference: Int) {
return (
sum: a + b,
difference: a - b
)
}
Use:
let result = calculate(a: 20, b: 10)
print(result.sum)
print(result.difference)
Output:
30
10
For larger or more meaningful data models, a struct may be clearer than a large tuple.
Swift Argument Labels
Swift functions have a useful feature called argument labels.
Consider:
func greet(person name: String) {
print("Hello, \(name)")
}
Call:
greet(person: "Alex")
Inside the function:
name
is used.
Outside the function:
person
is used.
Here:
person → Argument label
name → Parameter name
Argument labels help make function calls read naturally.
Why Argument Labels Matter
Consider:
func move(from start: String, to end: String) {
print("Moving from \(start) to \(end)")
}
Call:
move(from: "Home", to: "Office")
This reads almost like an English sentence:
move from Home to Office
Well-designed argument labels can make Swift APIs easier to understand.
Omitting Argument Labels
Sometimes an argument label is unnecessary.
Use _ to remove it.
Example:
func square(_ number: Int) -> Int {
return number * number
}
Now call:
let result = square(5)
instead of:
square(number: 5)
Output:
25
Another Example Without Argument Labels
func greet(_ name: String) {
print("Hello, \(name)")
}
greet("Alex")
Output:
Hello, Alex
Use unlabeled arguments when the function name and surrounding context already make the meaning obvious.
Default Parameter Values
Swift allows parameters to have default values.
Example:
func greet(name: String = "Guest") {
print("Hello, \(name)")
}
Call without an argument:
greet()
Output:
Hello, Guest
Or provide one:
greet(name: "Alex")
Output:
Hello, Alex
Multiple Default Parameters
Example:
func createProfile(
name: String,
country: String = "India",
isActive: Bool = true
) {
print("Name: \(name)")
print("Country: \(country)")
print("Active: \(isActive)")
}
Call:
createProfile(name: "Alex")
The default values are used automatically.
You can override them when required:
createProfile(
name: "John",
country: "Canada",
isActive: false
)
Default parameters are useful when most callers use the same value.
Variadic Parameters
What if a function should accept a variable number of values?
Swift provides variadic parameters.
Use:
...
Example:
func calculateTotal(numbers: Int...) -> Int {
var total = 0
for number in numbers {
total += number
}
return total
}
Call:
let result = calculateTotal(numbers: 10, 20, 30, 40)
print(result)
Output:
100
You can provide different numbers of arguments:
calculateTotal(numbers: 1, 2)
calculateTotal(numbers: 1, 2, 3)
calculateTotal(numbers: 1, 2, 3, 4, 5)
Inside the function, the variadic parameter behaves like an array of the specified type.
Function Parameters Are Constants by Default
Function parameters cannot normally be reassigned directly.
For example, this is not allowed:
func increase(number: Int) {
number += 1
}
If you need a local mutable value, create a variable:
func increase(number: Int) {
var updatedNumber = number
updatedNumber += 1
print(updatedNumber)
}
In-Out Parameters
Normally, Swift function arguments are passed in a way that prevents the function from directly replacing the caller’s variable.
Sometimes you intentionally want a function to modify a variable supplied by the caller.
Swift provides:
inout
Example:
func increase(number: inout Int) {
number += 1
}
Create a variable:
var score = 10
Call the function using &:
increase(number: &score)
print(score)
Output:
11
The & indicates that the function is receiving access to modify that variable through an inout parameter.
Use inout deliberately rather than making it the default design for every function.
Practical Inout Example: Swap Values
Swift already provides standard swapping functionality, but implementing a swap is a useful learning exercise.
func swapValues(a: inout Int, b: inout Int) {
let temporary = a
a = b
b = temporary
}
Use:
var first = 10
var second = 20
swapValues(a: &first, b: &second)
print(first)
print(second)
Output:
20
10
What Is a Function Type?
Functions themselves have types in Swift.
Consider:
func add(a: Int, b: Int) -> Int {
return a + b
}
Its function type can be represented as:
(Int, Int) -> Int
Meaning:
Two Int inputs
↓
One Int output
This allows functions to be stored in variables and passed around.
Store a Function in a Variable
Example:
func add(a: Int, b: Int) -> Int {
return a + b
}
var operation: (Int, Int) -> Int = add
Now call:
let result = operation(10, 20)
print(result)
Output:
30
This is an important concept because Swift supports functions as first-class values.
Pass a Function as a Parameter
A function can receive another function.
Example:
func add(_ a: Int, _ b: Int) -> Int {
return a + b
}
func calculate(
_ a: Int,
_ b: Int,
operation: (Int, Int) -> Int
) -> Int {
return operation(a, b)
}
Use:
let result = calculate(
10,
20,
operation: add
)
print(result)
Output:
30
This concept becomes extremely useful when learning:
- Closures
- Callbacks
- Collection operations
- Event handling
- Asynchronous programming
Return a Function from Another Function
Swift functions can also return functions.
Example:
func addOne(_ number: Int) -> Int {
return number + 1
}
func subtractOne(_ number: Int) -> Int {
return number - 1
}
func chooseOperation(increase: Bool) -> (Int) -> Int {
if increase {
return addOne
} else {
return subtractOne
}
}
Use:
let operation = chooseOperation(increase: true)
print(operation(10))
Output:
11
This is more advanced, but understanding it will make closures and functional programming concepts easier later.
Nested Functions
You can define a function inside another function.
Example:
func calculate(number: Int) -> Int {
func double(_ value: Int) -> Int {
return value * 2
}
return double(number)
}
Call:
print(calculate(number: 5))
Output:
10
The nested function is scoped to its containing function.
This can be useful when a helper function is only relevant to one specific operation.
Using Guard Inside Functions
Functions frequently validate data before continuing.
Swift’s guard statement is useful for early exits.
Example:
func login(username: String?) {
guard let username = username else {
print("Username is required")
return
}
print("Welcome, \(username)")
}
Call:
login(username: nil)
Output:
Username is required
Call:
login(username: "Alex")
Output:
Welcome, Alex
This pattern is very common in real Swift applications.
Returning Optionals from Functions
Sometimes a function may not be able to produce a valid result.
You can return an Optional.
Example:
func divide(a: Double, b: Double) -> Double? {
guard b != 0 else {
return nil
}
return a / b
}
Use:
if let result = divide(a: 10, b: 2) {
print(result)
} else {
print("Cannot divide")
}
Output:
5.0
Try:
divide(a: 10, b: 0)
The function returns nil rather than producing an invalid division result.
Functions with Arrays
Functions can receive arrays.
Example:
func printLanguages(_ languages: [String]) {
for language in languages {
print(language)
}
}
Call:
let languages = ["Swift", "Kotlin", "Dart"]
printLanguages(languages)
Output:
Swift
Kotlin
Dart
Return an Array from a Function
Example:
func getEvenNumbers(from numbers: [Int]) -> [Int] {
var evenNumbers: [Int] = []
for number in numbers {
if number % 2 == 0 {
evenNumbers.append(number)
}
}
return evenNumbers
}
Use:
let numbers = [1, 2, 3, 4, 5, 6]
let result = getEvenNumbers(from: numbers)
print(result)
Output:
[2, 4, 6]
Functions with Dictionaries
Example:
func printUser(user: [String: String]) {
let name = user["name"] ?? "Unknown"
let city = user["city"] ?? "Unknown"
print("Name: \(name)")
print("City: \(city)")
}
Call:
let user = [
"name": "Alex",
"city": "Jaipur"
]
printUser(user: user)
Functions with Custom Types
Real applications often pass custom models into functions.
Example:
struct User {
let name: String
let age: Int
}
Function:
func showProfile(user: User) {
print("Name: \(user.name)")
print("Age: \(user.age)")
}
Use:
let user = User(
name: "Alex",
age: 25
)
showProfile(user: user)
This is much more representative of production Swift code than using separate primitive parameters for every piece of data.
Throwing Functions in Swift
Some operations can fail for reasons that deserve explicit error handling.
Swift functions can throw errors.
First define an error:
enum LoginError: Error {
case emptyUsername
case invalidPassword
}
Now create a throwing function:
func login(
username: String,
password: String
) throws -> Bool {
guard !username.isEmpty else {
throw LoginError.emptyUsername
}
guard password == "1234" else {
throw LoginError.invalidPassword
}
return true
}
Notice:
throws
in the function declaration.
Calling a Throwing Function
Use try:
do {
let success = try login(
username: "Alex",
password: "1234"
)
print(success)
} catch {
print("Login failed: \(error)")
}
Throwing functions are common when working with:
- Networking
- File operations
- JSON decoding
- Databases
- Authentication
- Validation
Async Functions in Swift
Modern applications perform many operations that take time.
For example:
- Downloading API data
- Reading files
- Fetching database records
- Uploading images
Swift supports asynchronous functions using:
async
A simple example:
func fetchUser() async -> String {
return "Alex"
}
An asynchronous function is called from an appropriate asynchronous context using:
let user = await fetchUser()
Async Throwing Functions
A function can be both asynchronous and throwing.
Example:
func fetchUser() async throws -> String {
return "Alex"
}
Call from an appropriate async context:
do {
let user = try await fetchUser()
print(user)
} catch {
print("Failed to fetch user")
}
You will encounter this pattern frequently in modern Swift networking code:
async throws
Practical Example: Discount Calculator Function
Let’s create a reusable function.
func calculateDiscountedPrice(
price: Double,
discountPercentage: Double
) -> Double {
let discount = price * discountPercentage / 100
return price - discount
}
Use:
let finalPrice = calculateDiscountedPrice(
price: 1000,
discountPercentage: 20
)
print(finalPrice)
Output:
800.0
This function can now calculate discounts for any compatible price and percentage.
Practical Example: Age Eligibility
func canVote(age: Int) -> Bool {
return age >= 18
}
Use:
if canVote(age: 20) {
print("Eligible to vote")
} else {
print("Not eligible to vote")
}
Output:
Eligible to vote
Practical Example: Grade Calculator
func calculateGrade(marks: Int) -> String {
if marks >= 90 {
return "A"
} else if marks >= 75 {
return "B"
} else if marks >= 60 {
return "C"
} else if marks >= 50 {
return "D"
} else {
return "F"
}
}
Use:
let grade = calculateGrade(marks: 82)
print("Grade: \(grade)")
Output:
Grade: B
Practical Example: Full Name
func createFullName(
firstName: String,
lastName: String
) -> String {
return "\(firstName) \(lastName)"
}
Use:
let name = createFullName(
firstName: "Alex",
lastName: "Smith"
)
print(name)
Output:
Alex Smith
Practical Example: Password Validation
func isValidPassword(_ password: String) -> Bool {
guard password.count >= 8 else {
return false
}
return true
}
Use:
if isValidPassword("swift123") {
print("Valid password")
} else {
print("Password is too short")
}
In a real application, password requirements may involve additional validation.
Practical Example: Search an Array
func containsLanguage(
_ language: String,
in languages: [String]
) -> Bool {
return languages.contains(language)
}
Use:
let languages = [
"Swift",
"Kotlin",
"Dart"
]
if containsLanguage("Swift", in: languages) {
print("Swift found")
}
Output:
Swift found
Practical Example: Calculate Average
func calculateAverage(_ numbers: [Double]) -> Double? {
guard !numbers.isEmpty else {
return nil
}
let total = numbers.reduce(0, +)
return total / Double(numbers.count)
}
Use:
let scores = [80.0, 90.0, 70.0, 100.0]
if let average = calculateAverage(scores) {
print("Average: \(average)")
}
Output:
Average: 85.0
Returning nil for an empty collection avoids dividing by zero.
Functions vs Methods in Swift
Beginners often hear both terms.
A standalone function looks like:
func greet() {
print("Hello")
}
A function defined as part of a type is generally called a method.
Example:
struct User {
let name: String
func greet() {
print("Hello, \(name)")
}
}
Use:
let user = User(name: "Alex")
user.greet()
Here:
greet()
is a method of User.
A simple distinction is:
Standalone reusable function → Function
Function associated with a type → Method
Functions vs Closures
Functions and closures are closely related in Swift.
Named function:
func add(a: Int, b: Int) -> Int {
return a + b
}
Closure:
let add = { (a: Int, b: Int) -> Int in
return a + b
}
Use:
print(add(10, 20))
Both can represent executable behavior.
Closures are especially useful when passing behavior directly to another API.
For example:
let numbers = [1, 2, 3, 4]
let doubled = numbers.map { number in
number * 2
}
Understanding function types makes closures much easier to learn.
Function Naming Best Practices
Function names should clearly describe what they do.
Poor:
func doIt() {
}
Better:
func calculateTotalPrice() {
}
Poor:
func data() {
}
Better:
func fetchUserData() {
}
Useful function names often begin with verbs:
calculate
fetch
load
save
delete
update
validate
create
send
show
convert
format
Examples:
func calculateTax() { }
func fetchProducts() { }
func validateEmail() { }
func saveProfile() { }
func deleteAccount() { }
Keep Functions Focused
Avoid making one function responsible for everything.
For example:
func handleEverything() {
// Login
// Fetch profile
// Fetch products
// Calculate totals
// Save database
// Send notification
}
A better design might separate responsibilities:
func loginUser() {
}
func fetchProfile() {
}
func fetchProducts() {
}
func calculateTotal() {
}
func saveOrder() {
}
func sendNotification() {
}
This makes the code easier to:
- Read
- Debug
- Test
- Reuse
- Modify
Avoid Too Many Parameters
A function like:
func createUser(
name: String,
email: String,
age: Int,
city: String,
country: String,
phone: String,
address: String
) {
}
may become difficult to manage.
If these values naturally belong together, consider a model:
struct User {
let name: String
let email: String
let age: Int
let city: String
let country: String
let phone: String
let address: String
}
Then:
func createUser(_ user: User) {
}
This can make APIs cleaner and reduce mistakes.
Common Swift Function Mistakes
Mistake 1: Forgetting to Call the Function
Defining:
func greet() {
print("Hello")
}
does not execute it.
You still need:
greet()
Mistake 2: Missing Argument Label
Suppose:
func greet(name: String) {
print(name)
}
Correct:
greet(name: "Alex")
Not:
greet("Alex")
unless the function was defined using:
func greet(_ name: String)
Mistake 3: Wrong Parameter Type
Function:
func showAge(age: Int) {
print(age)
}
Incorrect:
showAge(age: "Twenty")
Correct:
showAge(age: 20)
Swift’s type system catches this at compile time.
Mistake 4: Forgetting to Return a Value
Incorrect:
func add(a: Int, b: Int) -> Int {
let result = a + b
}
The function promises to return an Int, but it does not provide one.
Correct:
func add(a: Int, b: Int) -> Int {
let result = a + b
return result
}
Mistake 5: Returning the Wrong Type
Incorrect:
func getAge() -> Int {
return "25"
}
The function promises an Int, but "25" is a String.
Correct:
func getAge() -> Int {
return 25
}
Mistake 6: Overusing inout
inout is useful, but don’t use it just to avoid returning a value.
Instead of unnecessarily mutating external state, a function such as:
func increasedValue(_ number: Int) -> Int {
return number + 1
}
is often easier to reason about.
Choose the design that communicates the operation most clearly.
Mistake 7: Making Functions Too Large
A function containing hundreds of lines and many unrelated tasks becomes difficult to maintain.
Break complex logic into smaller, meaningful functions when doing so improves clarity.
Swift Function Cheat Sheet
Basic Function
func greet() {
print("Hello")
}
Call Function
greet()
Parameter
func greet(name: String) {
print(name)
}
Multiple Parameters
func add(a: Int, b: Int) {
print(a + b)
}
Return Value
func add(a: Int, b: Int) -> Int {
return a + b
}
No Argument Label
func square(_ number: Int) -> Int {
return number * number
}
Custom Argument Label
func greet(person name: String) {
print(name)
}
Default Parameter
func greet(name: String = "Guest") {
print(name)
}
Variadic Parameter
func total(numbers: Int...) -> Int {
numbers.reduce(0, +)
}
Inout Parameter
func increase(number: inout Int) {
number += 1
}
Optional Return
func divide(a: Double, b: Double) -> Double? {
guard b != 0 else {
return nil
}
return a / b
}
Tuple Return
func getUser() -> (name: String, age: Int) {
("Alex", 25)
}
Throwing Function
func loadData() throws {
}
Async Function
func loadData() async {
}
Async Throwing Function
func loadData() async throws {
}
Function Type
(Int, Int) -> Int
Practice Exercises for Beginners
After reading this guide, try creating these functions yourself.
Exercise 1: Addition
Create:
func add(_ a: Int, _ b: Int) -> Int
Expected:
add(10, 20) → 30
Exercise 2: Full Name
Create a function that receives a first name and last name and returns the full name.
Exercise 3: Even Number Checker
Create:
func isEven(_ number: Int) -> Bool
Example:
isEven(10) → true
isEven(7) → false
Exercise 4: Maximum Number
Create a function that receives two integers and returns the larger value.
Exercise 5: Discount Calculator
Receive:
price
discountPercentage
and return the final price.
Exercise 6: Grade Calculator
Receive marks and return:
A
B
C
D
F
Exercise 7: Array Total
Create a function that receives an array of integers and returns their total.
Exercise 8: Safe Division
Create a function that returns nil when the divisor is zero.
Exercise 9: User Profile
Create a User struct and write a function that receives a User and prints their profile.
Exercise 10: Function as Parameter
Create two mathematical functions and pass them into a calculator function.
These exercises cover most of the fundamental concepts explained in this guide.
Frequently Asked Questions About Swift Functions
What is a function in Swift?
A function is a reusable block of Swift code designed to perform a particular task. Functions can receive input through parameters and can optionally return a result.
Which keyword creates a function in Swift?
Swift uses:
func
Example:
func greet() {
}
How do you call a function in Swift?
If the function is:
func greet() {
print("Hello")
}
call it with:
greet()
Can a Swift function return a value?
Yes.
Example:
func getAge() -> Int {
return 25
}
Can a function return multiple values?
Yes. One common approach is returning a tuple.
func getUser() -> (String, Int) {
return ("Alex", 25)
}
For larger models, a custom type such as a struct may be more appropriate.
What does -> mean in a Swift function?
It specifies the function’s return type.
For example:
func getAge() -> Int
means the function returns an Int.
What does _ mean in Swift function parameters?
It can remove an external argument label.
Example:
func square(_ number: Int) -> Int {
return number * number
}
Call:
square(5)
What is an inout parameter?
An inout parameter allows a function to modify a variable supplied by the caller.
Example:
func increase(number: inout Int) {
number += 1
}
Can functions be stored in variables?
Yes.
Swift functions are values and have function types.
For example:
var operation: (Int, Int) -> Int
can store a compatible function.
Can a function receive another function?
Yes.
Functions can be passed as parameters.
This is an important concept behind callbacks and higher-order functions.
Can Swift functions be asynchronous?
Yes.
Swift uses:
async
for asynchronous functions.
Can Swift functions throw errors?
Yes.
Use:
throws
when a function can throw an error.
A function can also be both:
async throws
What is the difference between a Swift function and a closure?
Both represent executable blocks of code.
Functions normally have names declared with func, while closure expressions provide inline blocks of functionality that can be stored and passed around.
Understanding functions first makes closures much easier to learn.
What Should You Learn After Swift Functions?
Once you understand functions, continue with:
Swift Functions
↓
Optionals
↓
Arrays, Sets & Dictionaries
↓
Structs
↓
Classes
↓
Enums
↓
Closures
↓
Protocols
↓
Extensions
↓
Error Handling
↓
Generics
↓
Async/Await
↓
SwiftUI
Functions are especially important before learning closures because many Swift APIs accept functions or closure expressions as arguments.
Final Thoughts
Functions are one of the foundations of Swift programming.
A simple function starts with:
func greet() {
print("Hello")
}
But Swift functions can become much more powerful:
Basic Function
↓
Parameters
↓
Return Values
↓
Argument Labels
↓
Default Parameters
↓
Variadic Parameters
↓
Inout Parameters
↓
Function Types
↓
Higher-Order Functions
↓
Throwing Functions
↓
Async Functions
As a beginner, focus first on mastering:
- Creating functions
- Calling functions
- Passing parameters
- Returning values
- Using clear function names
- Understanding argument labels
Then move into function types, closures, error handling, and asynchronous functions.
The most important principle is simple:
A good function should have a clear purpose, understandable inputs, and predictable behavior.
Once you understand functions properly, writing organized, reusable, and maintainable Swift code becomes much easier.
