Swift Function: Syntax, Usage, and Examples

A function in Swift lets you write reusable blocks of code that perform specific tasks. You can define functions with input parameters, return values, or simply execute code without returning anything.

How to Write a Function in Swift

You define a function using the func keyword, followed by a name, optional parameters, and an optional return type.

Defining and Calling a Function

This function prints a simple greeting message when you call it.

func greet() {
    print("Hello, Swift!")
}

greet() // Calls the function

Function with Parameters

You can pass values into a function to make it more flexible.

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

greet(name: "Alice") // Output: Hello, Alice!

Function with Return Value

A function can return a value using the -> symbol before the return type.

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

let sum = add(a: 5, b: 3) // sum = 8

When to Use Functions in Swift

You should use functions when you want to organize, reuse, or simplify your code.

Reducing Repetitive Code

If you find yourself writing the same code multiple times, define a function instead.

func printWelcomeMessage() {
    print("Welcome to the app!")
}

printWelcomeMessage()
printWelcomeMessage()

Processing Data

A function lets you take input, process it, and return a result.

func square(number: Int) -> Int {
    return number * number
}

let result = square(number: 4) // Output: 16

Handling Callbacks

You can use functions as callbacks to execute code when an event occurs.

func fetchData(completion: () -> Void) {
    print("Fetching data...")
    completion()
}

fetchData {
    print("Data fetched successfully!")
}

Examples of Functions in Swift

Using Default Parameter Values

You can set default values for parameters so they become optional when calling the function.

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

greet() // Output: Hello, Guest!
greet(name: "Bob") // Output: Hello, Bob!

Returning Multiple Values with Tuples

A function can return multiple values by using a tuple.

func getUser() -> (name: String, age: Int) {
    return ("Alice", 30)
}

let user = getUser()
print("Name: \(user.name), Age: \(user.age)")

Passing a Function as an Argument

You can pass functions as parameters to other functions.

func operateOnNumbers(a: Int, b: Int, operation: (Int, Int) -> Int) -> Int {
    return operation(a, b)
}

let result = operateOnNumbers(a: 10, b: 5, operation: { $0 - $1 }) // Output: 5

Nesting Functions

You can define functions inside other functions to keep helper logic contained.

func outerFunction() {
    func innerFunction() {
        print("Inner function called!")
    }

    innerFunction()
}

outerFunction()

Using Functions in a Class

A class function belongs to a class and is called using the class name.

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

let product = Math.multiply(a: 3, b: 4) // Output: 12

Learn More About Functions in Swift

Functions in Swift come with advanced features like closures, generics, and different ways to pass data.

Closures vs. Functions

Closures are anonymous functions that capture surrounding variables.

let multiply = { (a: Int, b: Int) -> Int in
    return a * b
}

let result = multiply(4, 5) // Output: 20

Generic Functions

Generic functions let you write flexible, type-safe code that works with different data types.

func swapValues<T>(a: inout T, b: inout T) {
    let temp = a
    a = b
    b = temp
}

var x = 10, y = 20
swapValues(a: &x, b: &y)
print(x, y) // Output: 20, 10

Using Functions with Structs

Functions can accept and return structs.

struct User {
    var name: String
    var age: Int
}

func printUser(user: User) {
    print("User: \(user.name), Age: \(user.age)")
}

let user = User(name: "Alice", age: 25)
printUser(user: user)

Enum Functions

Enums can contain functions to provide additional functionality.

enum Direction {
    case north, south, east, west

    func description() -> String {
        switch self {
        case .north: return "Going north"
        case .south: return "Going south"
        case .east: return "Going east"
        case .west: return "Going west"
        }
    }
}

let move = Direction.east
print(move.description()) // Output: Going east

Global Functions

Global functions are functions that exist outside of classes or structs and can be called from anywhere.

func sayHello() {
    print("Hello, world!")
}

sayHello()

Returning a Function

A function can return another function as a result.

func makeMultiplier(multiplier: Int) -> (Int) -> Int {
    return { number in number * multiplier }
}

let double = makeMultiplier(multiplier: 2)
print(double(5)) // Output: 10

Best Practices for Functions in Swift

• Use clear and descriptive names that explain what the function does.
• Keep functions small and focused on a single task.
• Use default parameter values to make functions more flexible.
• Return tuples when you need to return multiple values.