Swift Functions Basics

Functions are one of the fundamental building blocks in Swift programming. They allow you to package code that performs a specific task so it can be reused throughout your program. In this guide, we'll explore the basics of Swift functions, from defining simple functions to working with parameters and return values.

What Are Functions?

A function is a self-contained block of code that performs a specific task. Think of functions like mini-programs within your main program - they take input, process it, and can produce output. Functions help you:

• Organize code by breaking it into manageable pieces
• Avoid repetition by making code reusable
• Make your code easier to test and debug
• Create cleaner, more readable programs

Defining Your First Function

Let's start with a simple function that prints a greeting:

swift

func sayHello() {
    print("Hello, Swift programmer!")
}

This function:

• Begins with the func keyword
• Has a name (sayHello)
• Has empty parentheses () indicating it takes no parameters
• Contains code within curly braces {}

Calling Functions

After defining a function, you can execute it by calling its name followed by parentheses:

swift

sayHello() // Output: Hello, Swift programmer!

Functions with Parameters

Parameters allow you to pass data into functions. Let's modify our greeting function to be more personalized:

swift

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

greet(person: "Alex") // Output: Hello, Alex!
greet(person: "Taylor") // Output: Hello, Taylor!

Multiple Parameters

Functions can accept multiple parameters, separated by commas:

swift

func greet(person: String, isFormally: Bool) {
    if isFormally {
        print("Good day to you, \(person).")
    } else {
        print("Hey, \(person)!")
    }
}

greet(person: "Robert", isFormally: true)  // Output: Good day to you, Robert.
greet(person: "Sam", isFormally: false)    // Output: Hey, Sam!

Parameter Labels and Argument Labels

Swift uses parameter labels to improve readability. You can even specify a different external name (argument label) for use when calling the function:

swift

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

greet(to: "Emma") // Output: Hello, Emma!

You can also omit parameter labels using an underscore:

swift

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

greet("Jamie") // Output: Hello, Jamie!

Default Parameter Values

You can give parameters default values that are used if no value is provided:

swift

func greet(_ person: String, greeting: String = "Hello") {
    print("\(greeting), \(person)!")
}

greet("Pat")                    // Output: Hello, Pat!
greet("Chris", greeting: "Hi")  // Output: Hi, Chris!

Functions with Return Values

Functions can return values using the -> syntax followed by the return type:

swift

func createGreeting(for name: String) -> String {
    return "Hello, \(name)!"
}

let greeting = createGreeting(for: "Jordan")
print(greeting) // Output: Hello, Jordan!

Returning Multiple Values with Tuples

Swift allows functions to return multiple values using tuples:

swift

func getPersonInfo() -> (name: String, age: Int, occupation: String) {
    return ("Alex", 28, "Developer")
}

let person = getPersonInfo()
print("Name: \(person.name)")         // Output: Name: Alex
print("Age: \(person.age)")           // Output: Age: 28
print("Occupation: \(person.occupation)") // Output: Occupation: Developer

You can also access tuple elements by index:

swift

let (name, age, _) = getPersonInfo() // Ignore occupation
print("\(name) is \(age) years old") // Output: Alex is 28 years old

Practical Examples

Calculator Function

Here's a practical example of a function that performs mathematical operations:

swift

func calculate(_ a: Double, _ b: Double, operation: String) -> Double? {
    switch operation {
    case "+":
        return a + b
    case "-":
        return a - b
    case "*":
        return a * b
    case "/":
        if b == 0 {
            return nil // Return nil if dividing by zero
        }
        return a / b
    default:
        return nil // Return nil for unknown operations
    }
}

if let result = calculate(10, 5, operation: "+") {
    print("10 + 5 = \(result)") // Output: 10 + 5 = 15.0
}

if let result = calculate(10, 2, operation: "/") {
    print("10 / 2 = \(result)") // Output: 10 / 2 = 5.0
}

Temperature Converter

Here's a function that converts temperatures between Celsius and Fahrenheit:

swift

func convertTemperature(degrees: Double, from inputScale: String, to outputScale: String) -> Double? {
    var result: Double?
    
    if inputScale == "Celsius" && outputScale == "Fahrenheit" {
        result = (degrees * 9/5) + 32
    } else if inputScale == "Fahrenheit" && outputScale == "Celsius" {
        result = (degrees - 32) * 5/9
    } else if inputScale == outputScale {
        result = degrees
    }
    
    return result
}

if let tempF = convertTemperature(degrees: 20, from: "Celsius", to: "Fahrenheit") {
    print("20°C = \(tempF)°F") // Output: 20°C = 68.0°F
}

if let tempC = convertTemperature(degrees: 68, from: "Fahrenheit", to: "Celsius") {
    print("68°F = \(tempC)°C") // Output: 68°F = 20.0°C
}

Summary

In this guide, we've covered:

• Defining and calling simple functions
• Adding parameters to functions
• Working with parameter labels and default values
• Returning values from functions
• Returning multiple values using tuples
• Practical examples showing functions in use

Functions are foundational to Swift programming, allowing you to create modular, reusable code. As you become more comfortable with these basics, you'll be ready to explore more advanced function concepts like variadic parameters, in-out parameters, and closures.

Practice Exercises

1. Create a function that calculates the area of a rectangle given its width and height.
2. Write a function that returns a personalized greeting based on the time of day (morning, afternoon, evening).
3. Create a function that checks if a number is prime and returns a boolean value.
4. Write a function that takes an array of integers and returns both the minimum and maximum values as a tuple.
5. Create a function that calculates the total cost of items with different tax rates.

Additional Resources

• Swift Documentation on Functions
• Swift Programming Language Guide
• Functions Playground on Hacking with Swift

Happy coding!