Eduzan

Eduzan / Swift

Swift Additional Topics

Error handling refers to the process of responding to issues that arise during the execution of a function. A function can raise an error when it encounters an exceptional condition. The error can then be caught and addressed appropriately. Essentially, error handling allows us to deal with errors gracefully without abruptly exiting the code or application.

In this explanation, we’ll focus on what happens when an error is raised versus when it is not. Below is an example of a function, canThrowAnError(), demonstrating error handling implemented outside the loop in Swift.

Example 1:

func canThrowAnError() throws {
    // This function may or may not throw an error
}

do {
    try canThrowAnError()
    // No error was thrown
}
catch {
    // An error was thrown
}

Real-world Scenario

Case 1: The function throws an error.

For example, the function startCar() will raise an error if the seatbelt is not fastened or the fuel is low. Since startCar() can throw an error, it is wrapped in a try expression. When such a function is used within a do block, any errors it throws can be caught and handled using the appropriate catch clauses.

Case 2: The function does not throw an error.

If no error is raised when the function is called, the program continues executing without interruption. However, if an error occurs, it will be matched to a specific catch clause. For instance:

If the error corresponds to the carError.noSeatBelt case, the blinkSeatBeltSign() function will be called.
If the error matches the carError.lowFuel case, the goToFuelStation(_:) function will be invoked, using the associated fuel-related details provided by the catch pattern.

Example:

func startCar() throws {
    // Logic to start the car, which may throw an error
}

do {
    try startCar()
    turnOnAC()
}
catch carError.noSeatBelt {
    blinkSeatBeltSign()
}
catch carError.lowFuel(let fuel) {
    goToFuelStation(fuel)
}

Output:

1. If no error is thrown:

The car starts, and the air conditioner is turned on.

2. If an error is thrown:

For carError.noSeatBelt, the seatbelt sign blinks.
For carError.lowFuel, the function goToFuelStation(_:) is executed with the relevant fuel information.

Exception Handling in Swift

In any programming language, exception handling is essential for maintaining code reliability and stability. With Swift’s rise as a robust and versatile language, developers encounter new methods and opportunities for managing errors and unexpected scenarios. This article provides an overview of how Swift handles exceptions effectively.

Similar to other languages, Swift includes keywords to address undefined behaviors or exceptions in a program. Swift provides three distinct ways to manage errors using the keywords try, try?, and try!.

Example:

import Swift

func foo() throws -> Int? {
    print("I am inside foo()")
    throw SomeError // Part of the code that will throw an exception
}

Try

The first approach for handling exceptions in Swift is using the try keyword within a do block. This method is comparable to try-catch blocks in other languages like Java. The code that might throw an error is enclosed in a do block with try preceding the function call. If an error is thrown, it is caught by the accompanying catch block.

Example:

do {
    let x = try foo()
    print("This will be printed if there isn't any error.")
} catch {
    print("Caught an error while calling function foo()!")
}

Output:

If no error is thrown: This will be printed if there isn’t any error.
If an error is thrown: Caught an error while calling function foo()!

Try?

The second method involves using try?. When used, try? transforms errors into optional values. If an error occurs, the value becomes nil, allowing the program to continue execution without disruption.

Example 1:

let x = try? foo()

if let safex = x {
    print("x has a value which is \(safex)")
} else {
    print("x has a nil value")
}

Try!

The third method, try!, is used when the programmer is confident that the function will not throw an error. If an error occurs, the program will halt execution. The exclamation mark (!) indicates a forceful approach, bypassing error handling and focusing solely on program flow.

Example:

let x = try! foo()
print("Execution will never reach here! Program halts above this line.")

Output:

If no error is thrown: [Execution proceeds normally]
If an error is thrown: Program terminates immediately.

A variable is a named container used to store a value. Each value has a type, known as a data type, which is a classification of data that tells the compiler how the data is intended to be used. Data types can be categorized as primitive, user-defined, and derived. Swift provides specific data types like Int for integers, Float or Double for decimal values, and String for text. Many programming languages offer a way to refer to data types with alternate names or aliases. In Swift, the keyword typealias is used for this purpose.

Type Alias in Swift

Swift allows creating aliases for existing data types, offering a new name to refer to a data type without creating a new type. The typealias keyword serves this purpose and is similar to the typedef keyword in C++. Multiple aliases can be defined for a single data type.

Syntax:

typealias myDataType = dataType

Here:

typealias is the keyword.
dataType refers to a primitive, user-defined, or complex data type.
myDataType is the alias, which can now be used interchangeably with dataType.

1. Type Alias for Primitive Data Types: Swift allows aliases for primitive data types like Int, Float, and Double. Internally, typealias does not create new data types but provides alternate names for existing ones.

Syntax:

typealias myDataType = dataType

Example:

// Swift program demonstrating typealias for primitive data types

// Defining aliases

typealias myInt = Int
typealias myFloat = Float
typealias myDouble = Double
typealias myCharacter = Character
typealias myString = String

// Using aliases
var integerNumber: myInt = 5
print("integerNumber:", integerNumber)

var floatNumber: myFloat = 5.12345
print("floatNumber:", floatNumber)

var doubleNumber: myDouble = 5.123456789
print("doubleNumber:", doubleNumber)

var character: myCharacter = "A"
print("character:", character)

var string: myString = "Hello, Swift!"
print("string:", string)

Output:

integerNumber: 5
floatNumber: 5.12345
doubleNumber: 5.123456789
character: A
string: Hello, Swift!

2. Type Alias for User-Defined Data Types: User-defined data types like structures, arrays, and classes can also be assigned aliases. This is particularly useful for simplifying complex types.

Syntax:

typealias myDataType = dataType

Example:

// Swift program demonstrating typealias for user-defined data types

struct Employee {
    var employeeName: String
    var employeeId: Int

    init(employeeName: String, employeeId: Int) {
        self.employeeName = employeeName
        self.employeeId = employeeId
    }
}

typealias employees = Array<Employee>

// Creating an array of Employee objects
var myArray: employees = []

// Adding Employee objects
myArray.append(Employee(employeeName: "Alice", employeeId: 101))
myArray.append(Employee(employeeName: "Bob", employeeId: 102))
myArray.append(Employee(employeeName: "Charlie", employeeId: 103))

// Printing array elements
for element in myArray {
    print("Employee Name:", element.employeeName, ", Employee ID:", element.employeeId)
}

Output:

Employee Name: Alice , Employee ID: 101
Employee Name: Bob , Employee ID: 102
Employee Name: Charlie , Employee ID: 103

3. Type Alias for Complex Data Types: Complex data types consist of multiple primitive types or involve functions. Swift allows defining aliases for such types as well.

Syntax:

// Swift program demonstrating typealias for complex types

typealias functionType = (Int, Int) -> Int

// Function for multiplication
func multiply(a: Int, b: Int) -> Int {
    return a * b
}

// Using the alias for function type
var myFunction: functionType = multiply

let number1 = 7
let number2 = 8
let result = myFunction(number1, number2)

print("Multiplication of", number1, "and", number2, "is", result)

Output:

Multiplication of 7 and 8 is 56

Swift Structures

Swift structures are a fundamental feature of the Swift programming language. They enable the grouping of related data into a single unit. While similar to classes, structures have notable differences:

Value Types: Structures in Swift are value types, which means assigning or passing them creates a copy, ensuring the original structure remains unchanged. This behavior can lead to improved performance and avoids unintended modifications.
Memberwise Initializers: Swift automatically provides memberwise initializers, simplifying the initialization of structure properties.
No Inheritance: Structures cannot inherit properties or behavior from other structures or classes, making them more lightweight and focused.
Methods and Properties: Swift structures can define both methods and properties, enabling encapsulation of data and behavior.
Performance: Structures can be faster than classes because they avoid dynamic dispatch and reference counting overhead.

Example:

// Defining a structure
struct Car {
    var make: String
    var model: String
    var year: Int
}

// Creating a structure instance
var car = Car(make: "Toyota", model: "Camry", year: 2020)

print("\(car.make) \(car.model) was manufactured in \(car.year).")

// Modifying a property
car.year = 2022

print("\(car.make) \(car.model) is now updated to year \(car.year).")

Output:

Toyota Camry was manufactured in 2020.
Toyota Camry is now updated to year 2022.

Structures

In C, structures are composite data types used to group variables of different types under one name. Each variable within the structure is called a member. Structures are commonly used for organizing related data, simplifying management and readability in programs.

Example:

#include <stdio.h>
#include <string.h>

// Defining a structure
struct Book {
    char title[50];
    char author[50];
    int year;
};

int main() {
    // Creating a structure instance
    struct Book book;

    // Initializing members
    strcpy(book.title, "The C Programming Language");
    strcpy(book.author, "Brian W. Kernighan and Dennis M. Ritchie");
    book.year = 1978;

    // Displaying structure data
    printf("Title: %s\nAuthor: %s\nYear: %d\n", book.title, book.author, book.year);

    return 0;
}

Output:

Title: The C Programming Language
Author: Brian W. Kernighan and Dennis M. Ritchie
Year: 1978

Differences Between Swift Structures and C Structures

Swift Additional Topics
Feature	Swift Structures	C Structures
Inheritance	Not supported.	Not supported.
Methods and Properties	Support both methods and properties.	Only contain members (data fields).
Initialization	Provide automatic memberwise initializers and allow custom initializers.	Require manual initialization for each member.
Pass by Value	Always passed by value.	Can be passed by value or by reference.
Type Safety	Strong typing ensures type safety.	Relatively loose typing.
Memory Management	Managed automatically with ARC (Automatic Reference Counting).	Requires manual memory management.
Mutability	Properties are immutable unless declared as `var`.	Members are mutable by default.
Named vs Anonymous	Structures must have a name.	Can be anonymous and embedded within other structures.
Type Aliasing	Can be type-aliased for better code readability.	Type aliasing is not directly supported.

End of lesson.

Back to Swift

Swift Additional Topics

Swift Errors

Real-world Scenario

Difference between Try, Try?, and Try! in Swift

Exception Handling in Swift

Try

Try?

Try!

Swift Typealias

Type Alias in Swift

Output:

Difference between Swift Structures and C Structure

Swift Structures

Structures

Differences Between Swift Structures and C Structures