Learn Swift: A Comprehensive Guide For Aspiring Developers

Learning Swift is an exciting journey into the world of iOS, macOS, watchOS, and tvOS app development. At learns.edu.vn, we provide a comprehensive guide on How To Learn Swift effectively, covering everything from the basics to advanced techniques. This guide will provide you with the knowledge to build high-quality applications. Explore new programming paradigms and enhance your coding skills with our resources.

1. Understanding the Basics of Swift Programming

To begin your Swift learning journey, it’s crucial to understand the foundational concepts. Let’s dive into the basics that will set you up for success.

1.1. What is Swift?

Swift is a powerful and intuitive programming language developed by Apple. It’s designed to be safer, faster, and more modern than its predecessor, Objective-C. Swift is used to build apps for iOS, macOS, watchOS, and tvOS, making it a versatile choice for developers. According to Apple’s official documentation, Swift combines the best in modern language thinking with wisdom gleaned from the broad Apple engineering culture and the diverse contributions from its open-source community.

1.2. Setting Up Your Development Environment

Before you start coding, you need to set up your development environment. Here’s how:

Install Xcode: Xcode is Apple’s integrated development environment (IDE) and is essential for Swift development. You can download it for free from the Mac App Store.
Create a New Project: Open Xcode and create a new project by selecting “Create a new Xcode project.” Choose the appropriate template for your desired platform (iOS, macOS, etc.).
Explore the Xcode Interface: Familiarize yourself with the Xcode interface, including the editor, navigator, debugger, and build tools.

1.3. Basic Syntax and Data Types

Understanding the basic syntax of Swift is fundamental. Here are some key elements:

Variables and Constants: Use var to declare variables (values that can change) and let to declare constants (values that cannot change).
```
var name = "John" // Variable
let age = 30      // Constant
```
Data Types: Swift is a type-safe language, meaning every variable has a specific type. Common data types include:
- Int: Integers (e.g., 1, 100, -50)
- Double: Floating-point numbers (e.g., 3.14, 2.0)
- String: Textual data (e.g., “Hello, world”)
- Bool: Boolean values (e.g., true, false)
Operators: Swift supports standard operators like +, -, *, /, and % for arithmetic operations.
```
let sum = 5 + 3  // Addition
let product = 4 * 2 // Multiplication
```

Control Flow: Use if, else if, and else statements for conditional execution.

let score = 85
if score >= 90 {
    print("Excellent")
} else if score >= 70 {
    print("Good")
} else {
    print("Needs improvement")
}

Loops: Swift provides for and while loops for repetitive tasks.

for i in 1...5 {
    print("Number: (i)")
}

var count = 0
while count < 3 {
    print("Count: (count)")
    count += 1
}

1.4. Working with Functions

Functions are essential for organizing and reusing code. Here’s how to define and use functions in Swift:

Function Definition: Use the func keyword to define a function, specify its parameters, and define its return type.
```
func greet(name: String) -> String {
    return "Hello, (name)!"
}
```
Calling Functions: To use a function, call it by its name and pass the required arguments.
```
let greeting = greet(name: "Alice")
print(greeting) // Output: Hello, Alice!
```

1.5. Understanding Optionals

Optionals are a unique feature of Swift that handle the absence of a value. An optional can either contain a value or be nil.

Declaring Optionals: Use a question mark ? after the type to declare an optional.
```
var age: Int? // `age` can be an `Int` or `nil`
age = 30
age = nil
```
Unwrapping Optionals: To access the value inside an optional, you need to unwrap it safely. There are several ways to do this:
- Forced Unwrapping: Use the exclamation mark ! to force unwrap an optional. However, this can cause a runtime error if the optional is nil.
```
var name: String? = "Bob"
print(name!) // Forced unwrapping (use with caution)
```
- Optional Binding: Use if let or guard let to safely unwrap an optional.
```
var city: String? = "New York"
if let cityName = city {
    print("The city is (cityName)")
} else {
    print("City is unknown")
}
```

1.6. Working with Collections

Collections are used to store multiple values in a single variable. Swift provides three primary collection types:

Arrays: An ordered collection of values of the same type.

var numbers: [Int] = [1, 2, 3, 4, 5]
print(numbers[0]) // Accessing elements

Dictionaries: An unordered collection of key-value pairs, where each key is unique.

var ages: [String: Int] = ["Alice": 30, "Bob": 25]
print(ages["Alice"]!) // Accessing values

Sets: An unordered collection of unique values of the same type.
```
var colors: Set<String> = ["Red", "Green", "Blue"]
```

1.7. Object-Oriented Programming (OOP) in Swift

Swift is an object-oriented programming language, which means it supports concepts like classes, objects, inheritance, and polymorphism.

Classes and Objects: A class is a blueprint for creating objects. An object is an instance of a class.

class Dog {
    var name: String
    var breed: String

    init(name: String, breed: String) {
        self.name = name
        self.breed = breed
    }

    func bark() {
        print("Woof!")
    }
}

let myDog = Dog(name: "Buddy", breed: "Golden Retriever")
myDog.bark()

Inheritance: A class can inherit properties and methods from another class (its superclass).

class Animal {
    func makeSound() {
        print("Generic animal sound")
    }
}

class Cat: Animal {
    override func makeSound() {
        print("Meow!")
    }
}

let myCat = Cat()
myCat.makeSound()

Protocols: A protocol defines a blueprint of methods, properties, and other requirements that suit a particular task or piece of functionality.

protocol Greetable {
    func greet() -> String
}

struct Person: Greetable {
    let name: String
    func greet() -> String {
        return "Hello, my name is (name)."
    }
}

let person = Person(name: "Charlie")
print(person.greet())

Understanding these basics is crucial for building a solid foundation in Swift. As you progress, you’ll delve deeper into more advanced topics, but mastering these fundamentals will make your journey smoother and more enjoyable.

2. Setting Up Your Development Environment

A well-configured development environment is essential for efficient and productive Swift development. Here’s a detailed guide on how to set up your environment.

2.1. Installing Xcode

Xcode is Apple’s official integrated development environment (IDE) for macOS. It includes everything you need to develop, test, and debug Swift applications.

Download Xcode:
- Open the Mac App Store on your Mac.
- Search for “Xcode.”
- Click “Get” and then “Install.”
- You may be prompted to enter your Apple ID credentials.
Install Command Line Tools:
- After Xcode is installed, open Terminal (found in /Applications/Utilities/).
- Type the following command and press Enter:
```
xcode-select --install
```
- Follow the prompts to install the command line tools. These tools are necessary for various development tasks, including building and running command-line applications.
Verify Installation:
- Open Xcode from the Applications folder.
- Agree to the terms and conditions.
- Xcode may prompt you to install additional components. Follow the instructions to complete the installation.

2.2. Creating Your First Swift Project

Now that you have Xcode installed, let’s create your first Swift project:

Open Xcode: Launch Xcode from the Applications folder.
Create a New Project:
- Click “Create a new Xcode project.”
- Choose a template based on the type of application you want to build (e.g., “iOS App,” “macOS App,” “Command Line Tool”).
- Click “Next.”
Configure Project Settings:
- Product Name: Enter a name for your project (e.g., “HelloWorld”).
- Organization Identifier: Enter a unique identifier for your organization (e.g., “com.example”).
- Interface: Choose “Storyboard” or “SwiftUI” for the user interface.
- Language: Make sure “Swift” is selected.
- Click “Next.”
Choose a Location:
- Select a location on your Mac to save the project.
- Click “Create.”

2.3. Understanding the Xcode Interface

The Xcode interface is divided into several key areas:

Navigator Area: Located on the left side of the Xcode window, the Navigator Area provides access to various navigators:
- Project Navigator: Displays the project’s file structure.
- Source Control Navigator: Manages source control operations (e.g., Git).
- Symbol Navigator: Lists symbols (e.g., classes, functions) in your project.
- Find Navigator: Allows you to search for text within your project.
- Issue Navigator: Displays warnings, errors, and other issues.
- Test Navigator: Manages unit tests and UI tests.
- Debug Navigator: Provides debugging tools and information.
- Breakpoint Navigator: Manages breakpoints in your code.
- Report Navigator: Displays build and test reports.
Editor Area: The central area where you write and edit your code. Xcode provides syntax highlighting, code completion, and other features to enhance your coding experience.
Inspector Area: Located on the right side of the Xcode window, the Inspector Area displays information about the currently selected item in the Editor Area or Navigator Area. It is divided into several inspectors:
- Attributes Inspector: Configures the attributes of UI elements (e.g., buttons, labels).
- Size Inspector: Adjusts the size and position of UI elements.
- Connections Inspector: Manages connections between UI elements and code.
- Identity Inspector: Displays information about the selected item’s class and identity.
- File Inspector: Displays information about the selected file.
Toolbar: Located at the top of the Xcode window, the Toolbar provides quick access to common actions:
- Run: Builds and runs your application.
- Stop: Stops the running application.
- Scheme: Selects the target and build configuration for your application.
- Devices: Selects the device or simulator to run your application on.
- Library: Accesses code snippets, media files, and UI elements.
Console Area: Located at the bottom of the Xcode window, the Console Area displays output from your application, including log messages, errors, and debugging information.

2.4. Running Your First Application

Let’s run your first Swift application:

Select a Device or Simulator: In the Toolbar, choose a device or simulator to run your application on. If you have a physical iOS device, connect it to your Mac and select it from the list. Otherwise, select a simulator (e.g., “iPhone 13”).
Build and Run: Click the “Run” button (or press Command + R) to build and run your application. Xcode will compile your code, launch the simulator (if selected), and install the application.
See the Result: Your application should now be running on the selected device or simulator. If you created a “Hello, World” application, you should see the text “Hello, World” displayed on the screen.

2.5. Using Swift Playgrounds

Swift Playgrounds is an interactive environment that makes it easy to learn Swift. It’s available as an app for iPad and Mac.

Open Swift Playgrounds: Launch Swift Playgrounds from the Applications folder (if you’re using a Mac) or from the Home screen (if you’re using an iPad).
Create a New Playground:
- Click “Get Started with Code” or “More Playgrounds.”
- Choose a template (e.g., “Blank”).
- Click “Create.”
Write Swift Code: In the playground, you can write Swift code and see the results immediately. Playgrounds are great for experimenting with new concepts, testing code snippets, and learning the basics of Swift.
```
import UIKit

var str = "Hello, playground"
print(str)
```
Explore Interactive Lessons: Swift Playgrounds also includes interactive lessons that guide you through the basics of Swift programming. These lessons are a great way to learn Swift in a fun and engaging way.

2.6. Managing Dependencies with Swift Package Manager

As your projects grow, you’ll likely need to use external libraries and frameworks. Swift Package Manager (SPM) is a tool for managing dependencies in Swift projects.

Create a Package.swift File: In your project directory, create a file named Package.swift.

Define Dependencies: In the Package.swift file, define the dependencies for your project.

// swift-tools-version:5.3
import PackageDescription

let package = Package(
    name: "MyProject",
    dependencies: [
        .package(url: "https://github.com/Alamofire/Alamofire.git", from: "5.0.0"),
    ],
    targets: [
        .target(
            name: "MyProject",
            dependencies: ["Alamofire"]),
    ]
)

Resolve Dependencies: Open Terminal, navigate to your project directory, and run the following command:
```
swift package resolve
```
Use Dependencies in Xcode: Open your Xcode project, go to “File” > “Swift Packages” > “Add Package Dependency,” and enter the repository URL.

Setting up your development environment correctly is a crucial step in becoming a proficient Swift developer. Take the time to configure Xcode, explore Swift Playgrounds, and learn how to manage dependencies with Swift Package Manager. This will set you up for success as you continue your Swift learning journey.

3. Core Concepts in Swift Programming

Mastering the core concepts of Swift programming is essential for building robust and efficient applications. This section will delve into the most important concepts every Swift developer should know.

3.1. Data Structures

Data structures are ways of organizing and storing data in a computer so that it can be used efficiently. Swift provides several built-in data structures:

Arrays: Arrays are ordered collections of values of the same type. They are useful for storing lists of items.
```
var numbers: [Int] = [1, 2, 3, 4, 5]
print(numbers[0]) // Accessing elements
```
- Usage: Storing lists of items, such as a list of user names or a sequence of numbers.
- Best Practices: Use arrays when the order of elements matters and you need to access elements by index.
Dictionaries: Dictionaries are unordered collections of key-value pairs, where each key is unique. They are useful for storing data that can be accessed by a specific key.
```
var ages: [String: Int] = ["Alice": 30, "Bob": 25]
print(ages["Alice"]!) // Accessing values
```
- Usage: Storing data that can be accessed by a unique key, such as user profiles or configuration settings.
- Best Practices: Use dictionaries when you need to quickly look up values by key and the order of elements does not matter.
Sets: Sets are unordered collections of unique values of the same type. They are useful for storing a collection of items where uniqueness is required.
```
var colors: Set<String> = ["Red", "Green", "Blue"]
```
- Usage: Storing a collection of unique items, such as a list of unique user IDs or a set of permissions.
- Best Practices: Use sets when you need to ensure that all elements are unique and the order of elements does not matter.
Tuples: Tuples are ordered collections of values of different types. They are useful for returning multiple values from a function or storing related pieces of data.
```
let person = (name: "Alice", age: 30)
print(person.name) // Accessing tuple elements
```
- Usage: Returning multiple values from a function or storing related pieces of data.
- Best Practices: Use tuples when you need to group a small number of related values together.

3.2. Control Flow

Control flow statements allow you to control the order in which code is executed. Swift provides several control flow statements:

Conditional Statements: if, else if, and else statements allow you to execute different blocks of code based on certain conditions.
```
let score = 85
if score >= 90 {
    print("Excellent")
} else if score >= 70 {
    print("Good")
} else {
    print("Needs improvement")
}
```
- Usage: Executing different blocks of code based on certain conditions, such as checking user input or determining the state of an application.
- Best Practices: Use conditional statements to handle different scenarios and ensure that your code behaves correctly in all cases.
Loops: for and while loops allow you to execute a block of code repeatedly.
```
for i in 1...5 {
    print("Number: (i)")
}

var count = 0
while count < 3 {
    print("Count: (count)")
    count += 1
}
```
- Usage: Executing a block of code repeatedly, such as iterating over a collection of items or performing a task until a certain condition is met.
- Best Practices: Use loops to automate repetitive tasks and make your code more efficient.
Switch Statements: switch statements allow you to execute different blocks of code based on the value of a variable.
```
let day = "Monday"
switch day {
case "Monday":
    print("Start of the week")
case "Friday":
    print("End of the week")
default:
    print("Mid-week")
}
```
- Usage: Executing different blocks of code based on the value of a variable, such as handling different user actions or processing different types of data.
- Best Practices: Use switch statements when you have multiple possible values for a variable and you want to handle each value differently.

3.3. Functions and Closures

Functions are reusable blocks of code that perform a specific task. Closures are self-contained blocks of code that can be passed around and used in your code.

Functions: Functions are defined using the func keyword. They can take parameters and return values.
```
func greet(name: String) -> String {
    return "Hello, (name)!"
}

let greeting = greet(name: "Alice")
print(greeting) // Output: Hello, Alice!
```
- Usage: Encapsulating reusable blocks of code that perform a specific task, such as calculating a value or processing data.
- Best Practices: Use functions to organize your code and make it more readable and maintainable.
Closures: Closures are similar to functions, but they can be defined inline and passed around as variables.
```
let add: (Int, Int) -> Int = { (a, b) in
    return a + b
}

let sum = add(5, 3)
print(sum) // Output: 8
```
- Usage: Passing blocks of code to functions, such as defining a custom sorting function or handling asynchronous tasks.
- Best Practices: Use closures to create flexible and reusable code that can be easily adapted to different situations.

3.4. Object-Oriented Programming (OOP)

Swift is an object-oriented programming language, which means it supports concepts like classes, objects, inheritance, and polymorphism.

Classes and Objects: A class is a blueprint for creating objects. An object is an instance of a class.
```
class Dog {
    var name: String
    var breed: String

    init(name: String, breed: String) {
        self.name = name
        self.breed = breed
    }

    func bark() {
        print("Woof!")
    }
}

let myDog = Dog(name: "Buddy", breed: "Golden Retriever")
myDog.bark()
```
- Usage: Modeling real-world entities and their behavior, such as creating a class for a user or a product.
- Best Practices: Use classes to organize your code and make it more modular and reusable.
Inheritance: A class can inherit properties and methods from another class (its superclass).
```
class Animal {
    func makeSound() {
        print("Generic animal sound")
    }
}

class Cat: Animal {
    override func makeSound() {
        print("Meow!")
    }
}

let myCat = Cat()
myCat.makeSound()
```
- Usage: Creating a hierarchy of classes that share common properties and methods, such as creating a base class for animals and subclasses for specific types of animals.
- Best Practices: Use inheritance to avoid code duplication and make your code more maintainable.

Polymorphism: Polymorphism allows objects of different classes to be treated as objects of a common type.

class Animal {
    func makeSound() {
        print("Generic animal sound")
    }
}

class Dog: Animal {
    override func makeSound() {
        print("Woof!")
    }
}

class Cat: Animal {
    override func makeSound() {
        print("Meow!")
    }
}

let animals: [Animal] = [Dog(), Cat()]
for animal in animals {
    animal.makeSound()
}

Usage: Writing code that can work with objects of different classes in a uniform way, such as creating a function that can process any type of animal.
Best Practices: Use polymorphism to make your code more flexible and extensible.

3.5. Error Handling

Error handling is the process of responding to and recovering from error conditions in your program. Swift provides a built-in error handling mechanism that allows you to throw, catch, and propagate errors.

Throwing Errors: Functions can throw errors using the throw keyword.
```
enum DivisionError: Error {
    case divideByZero
}

func divide(a: Int, b: Int) throws -> Int {
    if b == 0 {
        throw DivisionError.divideByZero
    }
    return a / b
}
```
- Usage: Indicating that an error has occurred in a function, such as attempting to divide by zero or accessing an invalid resource.
- Best Practices: Use enums to define specific error types and provide meaningful error messages.
Catching Errors: Errors can be caught using the do-catch statement.
```
do {
    let result = try divide(a: 10, b: 0)
    print("Result: (result)")
} catch DivisionError.divideByZero {
    print("Cannot divide by zero")
} catch {
    print("An unexpected error occurred")
}
```
- Usage: Handling errors that may occur in your code, such as displaying an error message to the user or retrying an operation.
- Best Practices: Use do-catch statements to handle errors gracefully and prevent your application from crashing.

3.6. Memory Management

Swift uses Automatic Reference Counting (ARC) to manage memory. ARC automatically frees up memory that is no longer being used by your program. However, it is still important to understand how ARC works to avoid memory leaks and other memory-related issues.

Strong References: Strong references are the default type of reference in Swift. They keep an object alive as long as there is at least one strong reference to it.
Weak References: Weak references do not keep an object alive. They are used to avoid retain cycles, which can cause memory leaks.
Unowned References: Unowned references are similar to weak references, but they are assumed to always have a value. They are used when you are sure that the referenced object will not be deallocated before the referencing object.

Understanding these core concepts is crucial for becoming a proficient Swift developer. By mastering data structures, control flow, functions, OOP, error handling, and memory management, you’ll be well-equipped to build robust and efficient Swift applications.

4. Advanced Swift Concepts

Once you have a solid grasp of the basics, diving into advanced Swift concepts can significantly enhance your programming skills and open up new possibilities for building sophisticated applications. Let’s explore some of these concepts in detail.

4.1. Generics

Generics enable you to write flexible and reusable code that can work with any data type. They allow you to define functions, classes, and structures that can operate on different types without having to write separate implementations for each type.

Generic Functions: Generic functions can work with any type. You define a generic function by using type parameters, which are placeholders for the actual types that will be used when the function is called.
```
func swapValues<T>(a: inout T, b: inout T) {
    let temp = a
    a = b
    b = temp
}

var num1 = 5
var num2 = 10
swapValues(a: &num1, b: &num2)
print("num1: (num1), num2: (num2)") // Output: num1: 10, num2: 5

var str1 = "Hello"
var str2 = "World"
swapValues(a: &str1, b: &str2)
print("str1: (str1), str2: (str2)") // Output: str1: World, str2: Hello
```
- Usage: Writing functions that can operate on different types without having to write separate implementations for each type, such as a function that sorts an array of any type.
- Best Practices: Use generics to create flexible and reusable code that can be easily adapted to different situations.

Generic Types: Generic types are classes, structures, or enums that can work with any type. You define a generic type by using type parameters, which are placeholders for the actual types that will be used when the type is instantiated.

struct Stack<T> {
    var items: [T] = []

    mutating func push(_ item: T) {
        items.append(item)
    }

    mutating func pop() -> T? {
        if !items.isEmpty {
            return items.removeLast()
        } else {
            return nil
        }
    }
}

var intStack = Stack<Int>()
intStack.push(5)
intStack.push(10)
print(intStack.pop()!) // Output: 10

var stringStack = Stack<String>()
stringStack.push("Hello")
stringStack.push("World")
print(stringStack.pop()!) // Output: World

Usage: Creating data structures that can store any type of data, such as a stack or a queue.
Best Practices: Use generics to create type-safe data structures that can be used with different types without compromising type safety.

4.2. Protocols and Protocol-Oriented Programming

Protocols define a blueprint of methods, properties, and other requirements that suit a particular task or piece of functionality. Protocol-oriented programming (POP) is a programming paradigm that emphasizes the use of protocols to define interfaces and behaviors.

Defining Protocols: Protocols are defined using the protocol keyword.
```
protocol Greetable {
    func greet() -> String
}
```
- Usage: Defining a set of requirements that a type must conform to, such as a set of methods that a class must implement.
- Best Practices: Use protocols to define clear interfaces and ensure that different types can work together seamlessly.
Protocol Conformance: Types can conform to protocols by implementing the required methods and properties.
```
struct Person: Greetable {
    let name: String
    func greet() -> String {
        return "Hello, my name is (name)."
    }
}

let person = Person(name: "Charlie")
print(person.greet())
```
- Usage: Implementing the requirements defined by a protocol, such as implementing the greet() method for a Person struct.
- Best Practices: Ensure that your types conform to protocols correctly and provide the required functionality.
Protocol Extensions: Protocol extensions allow you to add default implementations of methods and properties to protocols.
```
extension Greetable {
    func farewell() -> String {
        return "Goodbye!"
    }
}

struct Dog: Greetable {
    let name: String
    func greet() -> String {
        return "Woof, my name is (name)."
    }
}

let dog = Dog(name: "Buddy")
print(dog.greet())    // Output: Woof, my name is Buddy.
print(dog.farewell()) // Output: Goodbye!
```
- Usage: Providing default implementations of methods and properties for protocols, such as providing a default implementation of the farewell() method for the Greetable protocol.
- Best Practices: Use protocol extensions to provide default implementations of methods and properties and make your code more reusable.

4.3. Concurrency and Asynchronous Programming

Concurrency and asynchronous programming allow you to perform multiple tasks at the same time without blocking the main thread. This is important for building responsive and efficient applications.

DispatchQueues: DispatchQueues are used to execute tasks concurrently. You can create serial queues (which execute tasks in order) or concurrent queues (which execute tasks in parallel).

let serialQueue = DispatchQueue(label: "com.example.serial")
let concurrentQueue = DispatchQueue(label: "com.example.concurrent", attributes: .concurrent)

serialQueue.async {
    print("Task 1 started")
    Thread.sleep(forTimeInterval: 2)
    print("Task 1 finished")
}

concurrentQueue.async {
    print("Task 2 started")
    Thread.sleep(forTimeInterval: 1)
    print("Task 2 finished")
}

concurrentQueue.async {
    print("Task 3 started")
    Thread.sleep(forTimeInterval: 1)
    print("Task 3 finished")
}

Usage: Executing tasks concurrently, such as performing network requests or processing data in the background.
Best Practices: Use serial queues for tasks that need to be executed in order and concurrent queues for tasks that can be executed in parallel.

Grand Central Dispatch (GCD): GCD is a low-level API for managing concurrent tasks. It provides a simple and efficient way to execute tasks asynchronously.
Async/Await: Async/Await is a modern approach to asynchronous programming that makes it easier to write and read asynchronous code.
```
func fetchData() async -> String {
    // Simulate fetching data from a server
    try? await Task.sleep(nanoseconds: 2_000_000_000) // 2 seconds
    return "Data fetched successfully"
}

func processData() async {
    print("Starting data fetch")
    let result = await fetchData()
    print("Data processing: (result)")
}

Task {
    await processData()
}
```
- Usage: Writing asynchronous code that is easy to read and maintain, such as fetching data from a server or processing data in the background.
- Best Practices: Use Async/Await to simplify your asynchronous code and make it more readable.

4.4. Memory Management and ARC

Strong References: Strong references are the default type of reference in Swift. They keep an object alive as long as there is at least one strong reference to it.
Weak References: Weak references do not keep an object alive. They are used to avoid retain cycles, which can cause memory leaks.
```
class Person {
    let name: String
    weak var car: Car? // Weak reference to avoid
```