Swift

Swift is a powerful and intuitive general-purpose programming language developed by Apple for building apps for iOS, Mac, Apple TV, and Apple Watch. It was designed to be fast, safe, and modern, replacing much of the older Objective-C codebase.

• Safety: Swift eliminates entire classes of unsafe code. Variables are always initialized before use, and arrays/integers are checked for overflow.
• Speed: Swift uses the LLVM compiler technology to transform Swift code into optimized machine code.
• Optionals: A unique feature that handles the existence (or absence) of a value, preventing "null pointer" crashes.
• Type Inference: You don't always have to specify types; Swift can often figure them out from the context.
• Closures: Self-contained blocks of functionality that can be passed around and used in your code.

In Swift, you use let for constants (values that never change) andvar for variables (values that can change).

• Constant: let pi = 3.14159
• Variable: var currentScore = 0

An Optional is a type that can hold either a value or nil (no value). It is declared by adding a question mark ? after the type.

Swift provides "Optional Binding" using if let or guard let to check for and extract a value safely.

Both are used to create custom data types, but they have key differences:

• Structs: Value types. When you copy a struct, you get a unique copy of the data. They do not support inheritance.
• Classes: Reference types. Multiple variables can point to the same instance. They support inheritance.

A protocol defines a blueprint of methods, properties, and other requirements that suit a particular task or piece of functionality. Classes, structs, or enums can then "adopt" or "conform" to that protocol.

Think of it like an Interface in other languages. It defines what an object should do, but not how it does it.

Optional chaining allows you to call properties, methods, and subscripts on an optional that might currently be nil. If the optional contains a value, the call succeeds; if it is nil, the call returns nil.

Closures are self-contained blocks of code that can be passed around. They are similar to "lambdas" in Python or Javascript.

Swift uses Automatic Reference Counting (ARC). It automatically tracks and manages your app's memory usage so you don't have to manually allocate or deallocate memory. It keeps an instance in memory as long as at least one strong reference to it exists.

In Swift, nil is fundamentally different from NULL in languages like C or Objective-C. While both represent the absence of a value, their underlying mechanics and safety profiles differ significantly.

In most languages, NULL is a pointer that points to an empty or non-existent memory address. In Swift, nil is not a pointer; it is the absence of a value of a certain type.

• Optional Wrapper: In Swift, only types explicitly marked as Optional (e.g., Int?, String?) can be nil. This forces the developer to handle the "empty" case before accessing the data, preventing the common "Null Pointer Exception."
• Value Types: Swift allows value types (like Int, Struct, or Enum) to be nil if they are wrapped in an Optional. In languages like C, NULL is typically reserved for pointers, and a standard integer cannot be NULL.
• Compile-Time Checking: The Swift compiler will not allow you to use a nil value where a non-optional value is expected. This shifts the discovery of potential bugs from the user's device (runtime) to the developer's computer (compile-time).
• Objective-C Interop: When Swift interacts with Objective-C, it translates NULL or nil pointers into Swift Optionals automatically to maintain safety standards.

Type Inference is a feature of the Swift compiler that allows it to automatically deduce the data type of a specific expression at compile-time. Instead of the developer explicitly stating the type (e.g., String or Int), the compiler examines the provided initial value to determine the type.

Swift is a statically typed language, meaning every variable must have a type. However, you don't always have to write it out.

• Cleaner, More Readable Code: Reduces "boilerplate" code. The syntax stays lightweight and "script-like" while maintaining the power of a compiled language.
• Faster Development: You can declare variables and constants quickly without constantly typing out long class or protocol names.
• Maintainability: If you change a function's return type, the variables receiving that data often update their inferred types automatically (provided they remain compatible with the rest of the code).
• Safety without Effort: Even though you aren't writing the type, the compiler still enforces strict type-checking. Once a type is inferred, it cannot be changed to a different type later.

• Initial Value Required: Type inference only works if you provide an initial value at the time of declaration. If you declare a variable without a value, you must use a type annotation (e.g., var price: Double).
• Default Logic: Swift has "preferred" types for literals. For example, a decimal number like 3.14 will always be inferred as a Double rather than a Float unless specified otherwise.

A Tuple is a lightweight grouping of multiple values into a single compound value. Unlike arrays, the values within a tuple can be of different types, and their size is fixed once defined.

While both group data, they serve different architectural purposes.

You can access data inside a tuple using positional indices or named elements .

• By Index: response.0 returns 404.
• By Name: let user = (name: "Alice", age: 30); print(user.name)
• Decomposition: ```swift let (code, message) = response print("Status: (code)")

Use a Tuple when:

• Returning Multiple Values: Ideal for a function that needs to return more than one piece of data without the overhead of defining a new class or struct.
• Temporary Grouping: Useful for local operations, like iterating through a dictionary where you get a (key, value) tuple.
• Pattern Matching: Highly effective in switch statements to check multiple conditions at once.

• Modeling Data: If the data represents a "thing" in your app (e.g., User, Product, Post).
• Persistence: If you need to pass the data between many different parts of your app.
• Encapsulation: If you need the data to perform actions (methods) or have complex validation logic.

Generics are a powerful tool in Swift that allow you to write flexible, reusable functions and types that can work with any type, subject to requirements you define. They avoid code duplication by using "placeholders" instead of specific types (like Int or String).

Without generics, you would have to write multiple versions of the same logic for different data types. With generics, you write the logic once.

• Type Parameters: Represented by a placeholder name (often <T>, <Element>, or <Key>) inside angle brackets.
• Generic Functions: A single function that can accept different types of arguments.
• Generic Types: Structures, classes, and enumerations that can work with any type (e.g., Swift's Array and Dictionary are actually generic collections).
• Type Constraints: You can limit generics to only work with types that inherit from a specific class or conform to a protocol (e.g., <T: Equatable>).

A "Stack" is a classic example. Instead of creating an IntStack and a StringStack, you create one Stack<Element>.

• Flexibility: It can hold integers, strings, or custom objects.
• Consistency: Once you define a Stack<Int>, Swift ensures you only push integers into it, maintaining strict type safety.

The Nil-Coalescing Operator (??) is a shorthand operator used to safely unwrap an Optional. It attempts to access the value inside an optional, but provides a default value to fall back on if the optional is nil.

The operator is placed between two values: a ?? b.

• a: An optional value (the value you'd like to use).
• b: A non-optional value (the backup if a is empty).

It effectively compresses a multi-line if-else statement into a single line of code.

• The "Long" Way:
• The Swift Way (??):

• Readability: It makes code much more concise and easier to follow, especially when dealing with multiple optionals.
• Type Safety: The operator ensures that the resulting variable is a non-optional type, meaning you can use it immediately without further checking.
• Short-Circuiting: If the first value is not nil, the second expression is never even evaluated, which can save processing time if the default value requires a function call to generate.

In Swift, these three primary collection types are used to store groups of values. While they all hold data, they differ significantly in how they organize that data and the performance of their operations.

1. Arrays

Use an Array when the order of your data matters (e.g., a list of high scores or a queue of tasks).

• Access: let firstItem = items[0]
• Characteristics: Elements are stored in a linear sequence. Accessing an element by its index is very fast ($O(1)$), but searching for a specific value requires checking every item ($O(n)$).

2. Sets

Use a Set when you need to ensure an item only appears once or when you need to perform high-speed membership testing.

• Requirements: Elements must conform to the Hashable protocol.
• Math Operations: Sets excel at mathematical operations like intersection, union, and subtracting.
• Access: if mySet.contains("Apple") { ... }

3. Dictionaries

Use a Dictionary when you want to associate a specific identifier (key) with a piece of data (value) (e.g., a user ID associated with a profile).

• Requirements: Keys must be Hashable.
• Access: let age = ages["John"]
• Result: Accessing a value by a key returns an Optional, because the key might not exist in the dictionary.

• Array: A "To-Do" list where the first task should stay at the top.
• Set: A list of unique "tags" for a blog post where you don't care about the order.
• Dictionary: A "Glossary" where you look up a definition (Value) using a word (Key).

Both if let and guard let are used for Optional Binding (unwrapping an optional safely). However, they differ in their control flow and how they handle the scope of the unwrapped variable.

1. if let (The "Conditional" Approach)

Use if let when you want to perform an action only if the optional contains a value, but you also want the function to continue even if the value is nil.

• Logic: "If this value exists, do this specific thing with it."
• Example:

Use guard let to ensure a value exists before proceeding with the rest of the function. It is often used at the beginning of functions to handle "unhappy paths" first.

• Logic: "This value MUST exist for me to continue; otherwise, I'm stopping right here."
• Example:

• Use guard let for inputs and requirements. It makes your "happy path" (the main logic) easier to read by getting error handling out of the way early.
• Use if let for quick, one-off checks where the rest of the function doesn't depend on that specific variable.

In Swift, the switch statement is far more powerful than in other languages. It isn't limited to simple equality checks; it uses Pattern Matching to inspect complex data structures and extract values simultaneously.

Swift can match patterns based on ranges, types, and tuple compositions.

1. Tuple and Value Binding

You can use a switch to decompose a tuple and use its internal values immediately. You can use an underscore (_) as a wildcard to ignore specific parts of the pattern.

A where clause allows you to refine a match with extra logic. This ensures a case only executes if a specific condition is met, even if the pattern matches.

In Swift, switch statements must be exhaustive. This means you must cover every possible value of the type being switched.

• If you are switching on an Enum, you must cover all cases.
• If you are switching on an Int or String, you almost always need a default case to handle the infinite remaining possibilities.

Unlike C or Java, Swift does not "fall through" to the next case by default. Once a match is found, the code executes and exits the switch. If you explicitly want the next case to run, you must use the fallthrough keyword.

In Swift, properties associate values with a particular class, structure, or enumeration. The primary distinction lies in whether the property actually holds data or calculates it on the fly.

1. Stored Properties

These are the most common properties. They store constant or variable values as part of an instance.

• Example: A User struct storing a username string.
• Property Observers: You can add willSet or didSet to react when the value changes.

2. Computed Properties

These provide a getter and an optional setter to retrieve and set other properties indirectly.

• The Getter (get): Required. It defines how to calculate the property's value.
• The Setter (set): Optional. It allows you to update other properties when this property is assigned a value. If no setter is provided, it is a read-only computed property.

Imagine a Square struct where the area depends entirely on the side length.

• Use Stored Properties for the "Source of Truth"—the fundamental data that defines your object (e.g., a person's birthdate).
• Use Computed Properties for data that can be derived from existing information (e.g., a person's current age based on their birthdate) or to provide a simpler interface for complex data.

Property Observers observe and respond to changes in a property’s value. They are called every time a property's value is set, even if the new value is the same as the current value.

They are primarily used on Stored Properties to keep other parts of your app in sync or to perform validation/logging when data changes.

You define these blocks inside the curly braces of a stored property declaration.

• Not for Initializers: Observers are not called when the property is first initialized. They only trigger during subsequent assignments.
• Avoid Infinite Loops: You can assign a value to the property within its own didSet. While this won't trigger the observer again (preventing a loop), it should be used sparingly for things like value clamping.
• Inheritance: You can add observers to an inherited property (whether stored or computed) by overriding the property in a subclass.
• Default Parameter Names: If you don't provide a custom name (like newSteps in the example above), Swift provides the defaults newValue for willSet and oldValue for didSet.

• UI Updates: Automatically refreshing a Label or View when the underlying data model changes.
• Data Validation: Checking if a value (like a percentage) is within a valid range (0-100) and correcting it if necessary.
• Synchronization: Updating a database or saving to UserDefaults as soon as a variable is modified.
• Logging: Tracking state changes for debugging purposes.

In Swift, self is a property that refers to the current instance of a class, structure, or enumeration. It is essentially the object saying, "I am talking about my own property or method."

In most cases, Swift allows you to omit self because the compiler assumes you are referring to a property of the current instance. However, there are specific scenarios where the compiler requires it to prevent ambiguity or to handle memory safely.

1. Disambiguation (Initializers)

If your initializer has a parameter name that matches a property name, you must use self to tell the compiler which is which.

When using an @escaping closure (a block of code that runs later, like a network request), you must use self. This forces you to think about memory management.

• Why: The closure needs to "capture" the instance to ensure it still exists when the code finally runs.
• Syntax: self.property = value or [weak self].

In a mutating method of a struct, you can assign a completely new instance to self.

When you want to refer to the type itself rather than an instance of the type, you use .self.

• Example: UITableViewCell.self refers to the class type, often used for registering cells in lists.

Apple’s official style guidelines suggest not using self unless it is required. This makes the code cleaner and highlights the specific places where self is actually necessary (like in closures), making those critical memory-management spots easier to spot.

Extensions in Swift allow you to add new functionality to an existing class, structure, enumeration, or protocol type. This includes types you didn’t write yourself, such as built-in Swift types (e.g., String, Int) or Apple's frameworks (e.g., UIButton).

Extensions are a primary tool for "Clean Code" in Swift. They allow you to break down large files into logical, manageable sections.

• You CAN add:
• Computed properties (read-only or read-write).
• New instance and type methods.
• New initializers (specifically "convenience" initializers for classes).
• Subscripts.
• Nested types.
• Protocol conformances.
• You CANNOT add:
• Stored properties (Extensions cannot increase the memory footprint of an instance).
• Property observers (willSet/didSet) to existing stored properties.
• Designated initializers to a class (only convenience ones).

Instead of having one giant ProfileViewController, you can split it by responsibility:

• Readability: Using // MARK: - with extensions creates a visual map in Xcode’s Jump Bar, making navigation easier.
• Retroactive Modeling: You can make a type conform to a protocol even if you don't have access to the original source code.
• Reusability: You can create a library of extensions (e.g., a String+Validation.swift file) and share it across multiple projects.

Protocol-Oriented Programming is a design paradigm introduced by Apple at WWDC 2015. While Object-Oriented Programming (OOP) focuses on what an object is (inheritance), POP focuses on what an object can do (behavior). It leverages protocols and protocol extensions to create flexible, modular, and reusable code.

In traditional OOP, you often end up with a deep inheritance tree where a subclass inherits properties it doesn't need. POP solves this by allowing types to "pick and choose" behaviors via protocols.

• Protocol Extensions: The "secret sauce" of POP. You can provide a default implementation for protocol methods. This means any type conforming to the protocol gets that functionality for free without writing a single line of code.
• Composition over Inheritance: Instead of one giant Superclass, you create small protocols like Flyable, Runnable, and Swimmable. A Duck struct can conform to all three, while a Dog only conforms to Runnable and Swimmable.
• Value Type Friendly: Unlike inheritance (which requires Classes), protocols work perfectly with Structs, which are safer and faster in Swift.

• Avoids the "Pyramid of Doom": You don't get stuck with rigid parent-child relationships that are hard to change later.
• Testability: Since protocols define an interface, it is much easier to create "Mock" objects for unit testing.
• Clean Code: It promotes the "Interface Segregation Principle," meaning no type is forced to depend on methods it does not use.

In Swift, Enums with Associated Values allow you to store additional information alongside each case. While a standard enum simply represents a choice (e.g., North, South, East, West), an enum with associated values can attach specific data to those choices.

Think of a standard enum as a list of labels, and an enum with associated values as a list of containers. Each container can hold different types and amounts of data.

Consider a "Result" from a network request. You want to know if it succeeded (with data) or failed (with an error message).

To get the data out of an enum case, you use a switch statement or an if case let statement with pattern matching.

• Using Switch:
• Using If Case Let:

• Contextual Information: You don't just know what happened; you know the details why or how it happened.
• Type Safety: The compiler ensures you handle the correct data types associated with each specific case.
• State Management: Highly effective for managing UI states (e.g., .empty, .error(String), .populated([User])) in a single, clean variable.

A Failable Initializer is an initializer that can return nil if initialization fails. In Swift, you define this by adding a question mark after the init keyword (init?).

It is used when the input parameters might be invalid, or when an external requirement (like a file or database) is missing, preventing the object from being created successfully.

A common example is a Person struct that requires a non-empty name. If an empty string is provided, the initializer "fails" and returns nil.

• Return nil: You must explicitly write return nil at the point where you determine initialization should fail.
• Propagation: A failable initializer can delegate to another failable initializer. If the delegate fails, the whole initialization process fails immediately.
• Overriding: A failable initializer can be overridden by a non-failable one in a subclass, but a non-failable one cannot be overridden by a failable one.
• Native Examples: Swift’s built-in types use this often. For example, Int("ABC") returns nil because "ABC" cannot be converted to a number.

• Data Validation: When creating an object from a Dictionary or JSON where a required key might be missing.
• Range Checks: When an input must be within a specific range (e.g., an Age struct that only accepts 0-120).
• Resource Availability: When an object depends on a file or hardware resource that may not be available.