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

S## The Swift `self` keyword

Programmers familiar with other object-oriented programming languages may be in the habit of prefixing references to properties and methods with `self` to indicate that the method or property belongs to the current class instance. The Swift programming language also provides the `self` property type for this purpose and it is, therefore, perfectly valid to write code that reads as follows:

```swift
class MyClass {
    var myNumber = 1
 
    func addTen() {
        self.myNumber += 10
    }
}
```

In this context, the `self` prefix indicates to the compiler that the code is referring to a property named `myNumber` which belongs to the `MyClass` class instance. When programming in Swift, however, it is no longer necessary to use `self` in most situations since this is now assumed to be the default for references to properties and methods. "The Swift Programming Language" guide published by Apple says, “In practice you don’t need to write self in your code very often.” The function from the above example, therefore, can also be written as follows with the `self` reference omitted:

```swift
func addTen() {
    myNumber += 10
}
```

# Using self in closure expressions

In most cases, the use of `self` is optional in Swift. With that being said, one situation where it is still necessary to use `self` is when referencing a property or method from within a closure expression. The use of `self`, for example, is mandatory in the following closure expression:

```swift
document?.openWithCompletionHandler({(success: Bool) -> Void in
    if success {
        self.ubiquityURL = resultURL
    }
})
```

It is also necessary to use `self` to resolve ambiguity, such as when a function parameter has the same name as a class property. In the following code, for example, the first `print` statement will output the value passed through to the function via the `myNumber` parameter, while the second print statement outputs the number assigned to the `myNumber` class property (in this case 10):

Learn how to use Swift's self keyword when writing object-oriented classes, and how that use differs from most of the other object-oriented programming languages.

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

Using Self in Swift