Swift Functions

This chapter introduces swift-functions , a powerful tool for organizing and reusing code. Functions allow developers to encapsulate logic, enhance readability, and simplify complex programs. Swift functions are versatile, supporting features like parameterization, return values, and even closures.

Chapter Goals

• Understand the purpose and benefits of functions in Swift.
• Learn how to declare and call functions.
• Explore advanced features such as parameters, return types, and overloading.
• Implement real-world examples to solidify understanding.

Key Characteristics of Swift Functions

• Reusable Logic: Functions encapsulate reusable code for efficiency and clarity.
• Parameterization: Accept input values via parameters to customize behavior.
• Return Values: Provide output for further use.
• Nested Functions: Support functions within functions for modular design.
• Closures: Treat functions as first-class citizens that can be passed or returned.

Basic Rules for Functions

• Functions are declared using the func keyword.
• Parameters and return types must be explicitly defined.
• Use meaningful names for functions and parameters to enhance readability.
• Avoid excessive nesting or complexity within functions.

Syntax Table

Syntax Explanation

1. Function Declaration

What is Function Declaration?

A function declaration defines a reusable block of code that encapsulates specific logic or tasks, making programs modular and easier to maintain. Functions serve as the building blocks of reusable and organized code, enabling efficient debugging and testing.

Syntax

func greet() {

    print(“Hello, World!”)

}

Detailed Explanation

• Use the func keyword followed by the function name.
• Enclose the code block within curly braces ({}).
• No parameters or return values are required for a basic function.
• Functions improve modularity by breaking complex tasks into smaller, reusable parts.

Example

func sayHello() {

    print(“Hello, Swift!”)

}

sayHello()

Example Explanation

• Declares the sayHello function.
• Calls the function to print “Hello, Swift!”.
• Demonstrates the simplicity of using functions for repetitive tasks.

2. Function with Parameters

What is a Function with Parameters?

Functions with parameters accept input values to customize behavior.

Syntax

func greet(name: String) {

    print(“Hello, \(name)!”)

}

Detailed Explanation

• Parameters are declared inside parentheses with a name and type.
• Use the parameter name within the function body to access its value.
• Parameters allow the same function to handle different inputs, enhancing flexibility.
• Multiple parameters can be used, separated by commas.

Example

func greetUser(name: String) {

    print(“Welcome, \(name)!”)

}

greetUser(name: “Alice”)

Example Explanation

• Declares the greetUser function with a name parameter.
• Calls the function with “Alice” as the argument.
• Prints “Welcome, Alice!”.
• Highlights how parameters can make functions adaptable.

3. Function with Return Value

What is a Function with Return Value?

Functions with return values produce an output for further use.

Syntax

func square(num: Int) -> Int {

    return num * num

}

Detailed Explanation

• Use -> followed by the return type to specify the function’s output.
• Use the return keyword to provide the value.
• Functions can return any type, including tuples and closures.
• Returning values allows functions to compute results that can be used elsewhere.

Example

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

    return a + b

}

let result = add(a: 5, b: 3)

print(result)

Example Explanation

• Declares the add function with two parameters and an Int return type.
• Returns the sum of a and b.
• Prints the result (8).
• Shows how returned values can be assigned to variables for further operations.

4. External Parameter Name

What is an External Parameter Name?

External parameter names improve function readability during calls.

Syntax

func greet(to name: String) {

    print(“Hello, \(name)!”)

}

Detailed Explanation

• Use an external name before the parameter name.
• The external name is used when calling the function, while the internal name is used within the function body.
• External names make function calls self-documenting and easier to understand.

Example

func send(message: String, to recipient: String) {

    print(“Sending ‘\(message)’ to \(recipient)”)

}

send(message: “Hi”, to: “Bob”)

Example Explanation

• Declares the send function with external parameter names.
• Improves call clarity by specifying “to” and “message”.
• Helps maintain readability, especially in functions with multiple parameters.

5. Variadic Parameters

What are Variadic Parameters?

Variadic parameters accept a variable number of arguments.

Syntax

func sum(numbers: Int…) {

    print(numbers.reduce(0, +))

}

Detailed Explanation

• Use … after the parameter type to declare a variadic parameter.
• The parameter is treated as an array of values within the function.
• Only one variadic parameter is allowed per function.
• Variadic parameters are ideal for functions that aggregate or process a list of inputs.

Example

func calculateSum(numbers: Int…) -> Int {

    return numbers.reduce(0, +)

}

let total = calculateSum(numbers: 1, 2, 3, 4)

print(total)

Example Explanation

• Declares the calculateSum function with a variadic parameter.
• Sums the provided arguments and returns the result.
• Prints the total (10).
• Demonstrates how variadic parameters simplify handling multiple inputs.

Real-Life Project: BMI Calculator

Project Goal

Develop a BMI calculator using Swift functions.

Code for This Project

func calculateBMI(weight: Double, height: Double) -> Double {

    return weight / (height * height)

}




func assessBMI(bmi: Double) -> String {

    switch bmi {

    case ..<18.5:

        return "Underweight"

    case 18.5..<24.9:

        return "Normal weight"

    case 25..<29.9:

        return "Overweight"

    default:

        return "Obesity"

    }

}




let weight = 70.0

let height = 1.75

let bmi = calculateBMI(weight: weight, height: height)

print("BMI: \(bmi), Category: \(assessBMI(bmi: bmi))")

Steps

1. Define a function to calculate BMI based on weight and height.
2. Implement a function to assess BMI category using a switch statement.
3. Call the functions with sample data and print the results.

Save and Run

Steps to Save and Run

1. Write the code in your Swift IDE (e.g., Xcode).
2. Save the file using Command + S (Mac) or the appropriate save command.
3. Click “Run” or press Command + R to execute the program.

Benefits

• Demonstrates parameterization and return values.
• Validates data dynamically based on user input.
• Provides an interactive real-world application of functions.

Best Practices

Why Use Functions?

• Encapsulate logic for reusability and clarity.
• Simplify debugging and testing by isolating functionality.
• Enhance maintainability with clear naming and parameterization.

Key Recommendations

• Use descriptive names for functions and parameters.
• Limit functions to a single responsibility.
• Avoid excessive parameters; use structs for complex inputs.

Example of Best Practices

func isValidEmail(email: String) -> Bool {

    return email.contains(“@”) && email.contains(“.”)

}

let email = “example@domain.com”

print(isValidEmail(email: email))

Insights

Swift functions are versatile and powerful, enabling code reuse and modular design. By mastering functions, developers can create concise, maintainable, and scalable applications.

Key Takeaways

• Functions organize and encapsulate reusable logic.
• Parameterization and return values enhance function flexibility.
• Advanced features like external parameter names and variadic parameters improve clarity and usability.