Delve into Swift programming for mobile app development, covering data types, OOP, logic, file management, and error handling. Gain foundational knowledge to advance in Apple platforms.

tarball.tar.gz

Build Swift

Swift is a modern and intuitive programming language that ranks among the top programming languages for mobile app development. 

Originally developed by Apple, Swift is now the recommended programming language for developing apps for all Apple platforms including iOS, iPadOS, macOS, tvOS, and watchOS. If you plan to write an app for an Apple device, you will need to learn to program in Swift.

In this course, you will cover topics ranging from basic data types, constants and variables, arrays, dictionaries, object-oriented programming, logic and control flow, file and file system management, and error handling.

On completion of this course, you will have sufficient foundational knowledge of Swift programming to begin learning other areas of Apple-based app development such as SwiftUI.

Swift Programming for Mobile App Development

Having covered the basics of functions and methods in Swift, it is now time to look at the concept of ***closures*** and ***closure expressions***. Although these terms are often used interchangeably, there are some key differences.

Closure expressions are self-contained blocks of code. The following code, for example, declares a closure expression and assigns it to a constant named `sayHello`, and then calls the function via the constant reference:

let sayHello = { print("Hello") }
sayHello()

Closure expressions may also be configured to accept parameters and return results. The syntax for this is as follows:

```swift
{(<para name>: <para type>, <para name> <para type>, ... ) -> <return type> in
         // Closure expression code here
}
```

The following closure expression, for example, accepts two integer parameters and returns an integer result:

let multiply = {(_ val1: Int, _ val2: Int) -> Int in 
    return val1 * val2 
} 

let result = multiply(10, 20)
print("result = \(result)")

> **Note:** Closure syntax is similar to that used for declaring Swift functions with the exception that the closure expression does not have a name, the parameters and return type are included within the braces, and the `in` keyword is used to indicate the start of the closure expression code. In fact, functions are just named closure expressions.

Closure expressions are often used when declaring completion handlers for asynchronous method calls. When developing iOS applications, for example, it will often be necessary to make calls to the operating system where the requested task is performed in the background allowing the application to continue with other tasks. Typically, in such a scenario, the system will notify the application of the completion of the task and return any results by calling the completion handler that was declared when the method was called. Frequently the code for the completion handler will be implemented in the form of a closure expression. Consider the following code example taken from an iOS application developed using Swift:

```swift
eventstore.requestAccess(to: .reminder, completion: {(granted: Bool, 
                    error: Error?) -> Void in
    if !granted {
            print(error!.localizedDescription)
    }
})
```

When the tasks performed by the ``requestAccess(to:)`` method call are complete, it will execute the closure expression declared as the `completion:` parameter. The completion handler is required by the method to accept a Boolean value and an `Error` object as parameters and return no results; hence, the following declaration:

```swift
{(granted: Bool, error: Error?) -> Void in
```

In actual fact, the Swift compiler already knows about the parameter and return value requirements for the completion handler for this method call and is able to infer this information without it being declared in the closure expression. This allows a simpler version of the closure expression declaration to be written:

```swift
eventstore.requestAccess(to: .reminder, completion: {(granted, error) in
    if !granted {
            print(error!.localizedDescription)
    }
})
```

Become proficient in writing and using Swift closure expressions.  In addition, explore examples and see how these expressions can be used in asynchronous programming.

Welcome to Swift

Swift Types, Constants, and Variables

Swift Operators and Expressions

Swift Control Flow

Swift Functions, Methods, and Closures

Swift Object-Oriented Programming

Swift Structures and Enumerations

Swift Property Wrappers

Swift Array and Dictionary Collections

Swift Error Handling

Working with Files and Directories in Swift

Continuing Your Journey into Swift

Appendix

Closure Expressions