Swift Fundamentals: A High-Level Overview for Aspiring iOS Developers
Tags: swift, ios, mobile, beginners
Published: 2023-03-27 16:38:37

---
canonical_url: https://ogtongm.medium.com/swift-fundamentals-a-high-level-overview-for-aspiring-ios-developers-32f74ee9a3c3
---
Hi there! I'm Matt, a self-taught developer who began learning iOS development in early 2022. Since then, I've had the opportunity to work professionaly as an iOS developer for the past year, and now I'm eagerly stepping into my next career phase with a leading telecommunications company. I've learned a lot in a relatively short time, but the more I learn, the more I realize how much there is still to discover in the dynamic and ever-evolving world of iOS development.

I'm deeply committed to and passionate about iOS development, so this article marks the first of hopefully many more where I share my knowledge, insights, and questions throughout my programming journey.

What better way to start than by providing a high-level overview of Swift fundamentals? In this article, I'll give you some of the groundwork needed to help you get started with iOS development and understanding Swift basics.

---

## Constants, Variables, and Basic Data Types
Let's kick things off by diving into Swift's basic types and how to declare constants and variables. Swift is a type-safe language, which means that it helps you be clear about the types of values your code can work with. This clarity enables you to catch and fix errors early in the development process. In Swift, you'll commonly work with basic types like `Int`, `Double`, `Float`, `String`, and `Bool`. 

Below is an example that demonstrates how to declare and use different basic types in Swift:

{% gist https://gist.github.com/matthewogtong/c2f9e82d64d69e0bb57a14927a008eb0 %}

We've used the let keyword to declare constants and the var keyword to declare variables. We also used the colon to explicitly define the type after the name.

### **_Additional Insights:_**

- Swift can infer types automatically, but it's good practice to explicitly specify the type for clarity.
- Variables and constants must be initialized before use.
- Swift uses a camelCase naming convention for both constants and variables.

## Control Flow: Conditional Statements
Now that you've dipped your toes into the world of Swift's basic types, it's time to gain some insight into decision-making with conditions. Conditions help you navigate through different possibilities based on specific criteria. 

Below is an example using if, else if, and else statements in Swift:

{% gist https://gist.github.com/matthewogtong/ef6e7310361aa17987de0e8bbef617ee %}

Here, we're using a variable named `appDownloads` to represent the number of downloads our app has. Based on different milestones, we print a message. Remember, the conditions are evaluated in sequence, and the first one to evaluate as true will have its corresponding code block executed.

### **_Additional Insights:_**

- The logical operators `&&` (and) and `||` (or) can be used to combine multiple conditions.
- You can use parentheses to group conditions and control the order of evaluation.
- The ternary conditional operator `(condition ? trueValue : falseValue)` offers a shorthand way to write simple if-else statements, making your code more concise in some cases.
- Swift's switch statement provides a more elegant way to handle multiple conditions when there are several possible values for a single variable.

## Arrays: Storing and Accessing Ordered Data

Now that we've covered some basic data types, let's explore a little into the realm of collections. Arrays are one of the most commonly used collection types in Swift. They store an ordered list of elements of the same type, allowing you to access and modify values by their index.

Here's an example of declaring an array, adding elements, and accessing them using their indices:

{% gist https://gist.github.com/matthewogtong/423f9cd5706aef5bc039c1dec318cc6f %}

Here, an array called `appNames` of type `[String]` is created and initialized with three elements. We then added another feature using the `append` function. Finally, we accessed the first element using its index (0).

### _**Additional Insights:**_

- Arrays in Swift are zero-indexed, which means the first element has an index of 0.
- The `count` property of an array returns the number of elements in the array.
- Use the `isEmpty` property to check if an array is empty or not.
- The `insert(_:at:)` function allows you to insert an element at a specific index.

## Tuples: Grouping Different Value Types

Let's move on to another collection type: tuples. Tuples allow grouping multiple values together into a single compound value, regardless of their types. They come in handy when working with temporary groupings of related data or returning multiple values from a function.

Consider this example of creating a tuple, accessing its elements, and decomposing it into separate constants:

{% gist https://gist.github.com/matthewogtong/b039d9d4d1c2ff743fb3fd355bb9f16a %}

In this example, a tuple called `appInfo` is created with three elements: a name, a version, and a rating. The individual elements of the tuple are accessed using dot notation. Finally, the tuple is decomposed into separate constants for easier handling of the individual values.

### Additional Insights:

- Tuples offer a simple and efficient way to group multiple values together temporarily.
- You can create tuples with or without named elements.
- Use the index of the element when accessing unnamed elements in a tuple (e.g., `appInfo.0`).
- Tuples are not recommended for complex data structures, as they lack the flexibility and functionality of classes and structs.

## Dictionaries: Storing Key-Value Pairs

Having discussed arrays and tuples, let's now delve into dictionaries, another commonly used collection type in Swift. Dictionaries store unordered key-value pairs, where each key is unique, and each value is associated with a specific key. They are particularly useful when organizing and accessing data based on keys rather than indices.

Here's an example of declaring a dictionary, adding key-value pairs, and accessing values using their keys:

{% gist https://gist.github.com/matthewogtong/70ae8403b96b54fdcb7a8eb4fce4365e %}

In this example, a dictionary called `userSettings` is created with three key-value pairs representing different settings for a user in an app. Then, a new key-value pair is added for notifications. Values are accessed and updated using their respective keys, and a key-value pair is removed by setting its value to `nil`.

### _**Additional Insights:**_

- Dictionary keys must conform to the `Hashable` protocol, which includes basic Swift types like `String`, `Int`, and `Double`.
- Use the `count` property to get the number of key-value pairs in a dictionary.
- Check for an empty dictionary using the `isEmpty` property.
- The `updateValue(_:forKey:)` method can be used to update a value and returns the previous value if the key already exists in the dictionary, or `nil` if it doesn't.

## Loops: Iterating Over Collection Types

Now that we've covered arrays, tuples, and dictionaries, it's time to explore loops in Swift. Loops are an essential tool for iterating over collection types or executing a block of code repeatedly. Swift offers several types of loops, including `for-in`, `while`, and `repeat-while`. In this section, we'll focus on using `for-in` loops to iterate over arrays, tuples, and dictionaries.

Here's an example of using `for-in` loops with arrays, tuples, and dictionaries:

{% gist https://gist.github.com/matthewogtong/1ee755bca45d8dc62700a96b3dc4ef7c %}

In these examples, the `for-in` loop iterates over an array of app feature descriptions, a tuple of app review data (username and rating), and a dictionary of user types and their respective count. In the case of the tuple and dictionary, both the keys and values are extracted using tuple decomposition.

### _**Additional Insights:**_

- The for-in loop is ideal for iterating over collection types such as arrays, tuples, and dictionaries.
- Use tuple decomposition to extract both keys and values when iterating over dictionaries.
- If you need to access the index while iterating over an array, use the enumerated() method to get both the index and the element.
- A while loop is useful when you need to execute a block of code as long as a condition remains true, while a repeat-while loop executes the block at least once and then continues as long as the condition is true.

## Functions & Closures: Crafting Modular and Reusable Code

Diving deeper into the world of Swift, let's explore how to craft modular, reusable code using functions. Functions in Swift act as first-class citizens, meaning you can assign them to variables, pass them as arguments, or even have them return from other functions. Closures, on the other hand, are quite similar to functions but with a twist - they're anonymous and can capture and store references to variables and constants from their surrounding context.

Let's look at a practical example that demonstrates how to define and call functions, as well as how to create and use closures:

{% gist https://gist.github.com/matthewogtong/31d3b89184f7826a242006dba698b765 %}

In this example, we defined a function named `totalDownloads` that calculates the total number of downloads for an array of apps. We called this function using an array of download numbers and printed the result. Additionally, we created a closure to sort an array of app names alphabetically with the help of the `sorted` function.

### _**Additional Insights:**_

- Functions in Swift can accept multiple input parameters and return a single value.
- You can provide default values for function parameters, allowing you to override them when calling the function.
- Functions can be nested within each other, giving inner functions access to the variables and parameters of their containing function.
- Closures can utilize a more concise syntax by inferring types and employing shorthand argument names such as `$0`, `$1`, and so on.

## Optionals: Handling the Absence of Values

As we continue our journey through the Swift language, it's time to explore the concept of optionals, which is one of my favorite features when working with Swift. Optionals in Swift are designed to help you safely and elegantly deal with the possibility of missing or absent values. By using optionals, you can avoid runtime crashes caused by unexpected nil values, as the Swift compiler forces you to explicitly handle these cases.

Let's dive into an example that showcases how to declare, unwrap, and use optionals in a safe manner:

{% gist https://gist.github.com/matthewogtong/0d0833bbf1c1ef6781aa4650f573bb3c %}

In this example, we declared an optional variable `favoriteApp` to store the user's favorite app. We then demonstrated two different ways of safely unwrapping the optional value: using an `if let` statement and a `guard` statement. Additionally, we utilized the nil-coalescing operator to provide a default value when the optional is nil.

### **_Additional Insights:_**

- Unwrapping optionals using if let or guard statements helps you avoid runtime crashes caused by unexpected nil values.
- The nil-coalescing operator (??) allows you to provide a default value when an optional is nil.
- Implicitly unwrapped optionals can be used when you're certain the optional will have a value before it's first used, but they should be used with caution, as accessing a nil value will result in a runtime crash.

## Structures: Flexible Building Blocks

As we delve further into Swift, it's essential to discuss structures, which are flexible building blocks that you can define and use to create custom data types. Structures in Swift can have properties, methods, and custom initializers, making them highly versatile and useful in numerous scenarios. I particularly enjoy working with structures, as they elegantly handle custom data types in Swift.

Let's take a look at an example that demonstrates how to create a structure, define its properties and methods, and use a custom initializer:

{% gist https://gist.github.com/matthewogtong/20aa4de24859e0c16adc02c451ae4a17 %}

In this example, we defined a structure called `User` with properties for the user's first name, last name, and age. We also provided a custom initializer and a method to display the user's full name. Then, we created an instance of the `User` structure and accessed its properties and methods.

### **_Additional Insights:_**

- Structures in Swift automatically receive a memberwise initializer if you don't define any custom initializers.
- Structures are value types, which means they're copied when passed around or assigned to a new variable or constant.
- The mutating keyword is used to indicate that a method can modify the properties of a structure.
- You can also define computed properties and property observers within structures.
- It's good practice to avoid force unwrapping optionals, except in certain situations.

## Classes: Powerful Inheritance and Polymorphism

Finally for our last topic to cover in this article, it's time to introduce classes, a crucial building block that enables inheritance and polymorphism. Classes allow you to create complex and sophisticated data structures by extending and building upon existing ones. I find that classes bring a whole new level of power and flexibility to Swift programming.

Let's examine an example that demonstrates how to create a class, define its properties and methods, and use inheritance and polymorphism:

{% gist https://gist.github.com/matthewogtong/1199c24d9e402a599f71daa7e2355964 %}

In this example, we defined a base class called `Animal` with a `name` property and a `makeSound()` method. We then created two subclasses, `Dog` and `Cat`, both inheriting from `Animal`. Each subclass overrides the `makeSound()` method to provide its own implementation. Finally, we created instances of the `Dog` and `Cat` classes and accessed their properties and methods.

### _**Additional Highlights:**_

- Classes are reference types, which means they're not copied when passed around or assigned to a new variable or constant.
- You can use the `final` keyword to prevent a class from being subclassed or a method from being overridden.
- Classes can have deinitializers, which are called when a class instance is deallocated.
- You can use the `super` keyword to access the superclass's implementation of a method or property.
- Use the `required` keyword to indicate that a particular initializer must be implemented by every subclass.

---


## Conclusion: More to Discover

While we've delved into constants, variables, basic data types, collections, loops, optionals, functions, closures, structures, and classes, there are other essential topics that we haven't had the chance to discuss. These include Enums, Protocols, Access Control, Error Handling, and many more. It's just too much to fit into one article!

So as we wrap up this whirlwind tour of Swift, it's important to remember that the topics we've covered here merely scratch the surface of this powerful and versatile language. There's so much more to explore and master, but these fundamentals should provide a solid foundation for you to build upon.

Also one more important aspect of Swift is its open-source nature, which allows developers worldwide to collaborate and contribute to its growth. One of my personal goals is to someday make my own meaningful contribution to the Swift language, adding a small piece to the puzzle that helps others unlock its full potential.

As someone who has been learning and growing in the realm of iOS development for about a year and half, I'm excited to continue sharing my knowledge and experiences on this exciting journey. Swift is a beautiful language with immense potential, and there's always something new to discover.

---

## Resources

{% embed https://www.swift.org %}
{% embed https://developer.apple.com/documentation/ %}
{% embed https://www.hackingwithswift.com/ %}