What is Swift?

Swift is a powerful and intuitive programming language developed by Apple for iOS, macOS, watchOS, and tvOS app development. It offers modern features, safe programming patterns, and performance advantages. Swift is designed to work seamlessly with Objective-C, allowing developers to integrate existing code while building new functionality.

What are the key features of Swift?

Key features of Swift include:

• Safe and fast code execution
• Modern syntax that is easy to read and write
• Optionals to handle the absence of values
• Type inference for cleaner code
• Closures, generics, and tuples for powerful coding patterns
• Interoperability with Objective-C

Explain Optionals in Swift.

Optionals in Swift are used to handle the absence of a value. They indicate that a variable can hold either a value or no value (nil). Declaring an optional is done using a question mark (e.g., 'var name: String?'). Optionals help prevent runtime crashes by safely unwrapping values using optional binding or the nil-coalescing operator.

What is optional binding?

Optional binding is a safe way to unwrap optional in Swift. It uses constructs like 'if let' or 'guard let' to check if an optional contains a value. If it does, the value is unwrapped and assigned to a constant or variable, making it safe to use without risking a runtime error.

What is the difference between let and var in Swift?

In Swift, let and var are used to declare constants and variables, respectively:

Feature	let	var
Declaration	Constant	Variable
Mutability	Immutable (value cannot change)	Mutable (value can change)
Usage Example	let maximumAttempts = 5	var currentAttempt = 1
Immutability Benefit	Ensures value consistency and thread safety	Allows flexibility to change the value as needed
Type Inference	Supported	Supported
Reassignment	Not allowed	Allowed

How do you handle errors in Swift?

Swift provides robust error handling using the 'do-catch' statement, the 'try' keyword, and error types conforming to the 'Error' protocol. You can throw errors in functions and handle them using 'do-catch' blocks to manage different error cases gracefully and maintain clean, readable code.

What are closures in Swift?

Closures are self-contained blocks of functionality that can be passed around and used in your code. They can capture and store references to variables and constants within their context. Closures are similar to lambdas or anonymous functions in other programming languages, and they support features like capturing values, inline declaration, and concise syntax.

Explain generics in Swift.

Generics allow you to write flexible and reusable code by enabling functions and types to work with any data type. By using placeholders instead of specific types, generics help create functions, methods, classes, and structures that can operate on various data types while maintaining type safety.

What is a tuple in Swift?

A tuple is a group of multiple values combined into a single compound value. Tuples can contain values of different types and are useful for returning multiple values from a function. They provide an easy way to group related values without creating a custom data structure.

What is a protocol in Swift?

Protocols define a blueprint of methods, properties, and other requirements that suit a particular task or piece of functionality. Classes, structures, and enums can conform to protocols to implement these requirements. Protocols enable polymorphism and are a key feature in Swift’s protocol-oriented programming.

How do you declare and use a protocol in Swift?

To declare a protocol, use the 'protocol' keyword followed by the protocol name and requirements. To use a protocol, a class, struct, or enum must adopt and conform to the protocol by implementing its requirements. This can be done using the ': ProtocolName' syntax after the type name.

What is protocol extension in Swift?

Protocol extensions allow you to add functionality to existing protocols. By extending a protocol, you can provide default implementations of its methods and properties, making them available to all conforming types. Protocol extensions help reduce code duplication and enhance the capabilities of protocols.

Explain the concept of protocol-oriented programming in Swift.

Protocol-oriented programming (POP) is a design paradigm that emphasizes the use of protocols and protocol extensions to define and share behaviour across types. POP promotes composition over inheritance, leading to more modular, reusable, and testable code. Swift’s powerful protocol features make it a natural fit for this approach.

What is the difference between class and struct in Swift?

In Swift, both classes and structs are used to create custom data types, but they have some key differences. 

Feature	Class	Struct
Type	Reference type	Value type
Memory Allocation	Stored in heap memory	Stored in stack memory
Inheritance	Supports inheritance	Does not support inheritance
Copy Behavior	Copies the reference	Copies the value
Identity	Can be checked for identity using ===	Cannot be checked for identity
Initializers	Can have deinitializers (deinit)	Cannot have deinitializers
Mutability	Mutability controlled by var or let on properties	Mutability controlled by var or let on the instance
ARC (Automatic Reference Counting)	Managed by ARC	Not managed by ARC

What are enums in Swift?

Enums, short for enumerations, define a common type for a group of related values and enable you to work with those values in a type-safe way. Enums can have associated values, which allow you to store additional information along with the enum cases, and they support methods and computed properties.

What is the significance of 'self' in Swift?

'self' refers to the current instance of a class, struct, or enum within its own methods. It’s used to distinguish between instance properties and local variables or parameters. In closures, 'self' must be explicitly captured to avoid retain cycles, making it crucial for memory management in certain contexts.

What is type inference in Swift?

Type inference allows Swift to automatically deduce the type of a variable or constant based on the assigned value. This feature reduces the need to explicitly specify types, leading to cleaner and more concise code. For example, 'let number = 42' infers 'number' as an 'Int'.

What is typecasting in Swift?

Type casting in Swift is used to check the type of an instance or to treat it as a different superclass or subclass type. The 'as?' operator attempts a conditional cast, returning an optional, while the 'as!' operator forces a cast and can cause a runtime error if it fails.

How does Swift handle memory management?

Swift uses Automatic Reference Counting (ARC) for memory management, which automatically tracks and manages the app’s memory usage. ARC ensures that instances are only deallocated when they are no longer needed, preventing memory leaks. Developers must manage strong, weak, and unowned references to avoid retain cycles.

What is a retain cycle and how do you prevent it in Swift?

A retain cycle occurs when two or more objects hold strong references to each other, preventing them from being deallocated. To prevent retain cycles, use weak or unowned references. 'weak' references are optional and set to nil when the referenced object is deallocated, while 'unowned' references are non-optional and expected to always have a valid reference.

Explain the difference between weak and unowned references.

In Swift, weak and unowned references are used to avoid retain cycles, which can lead to memory leaks. Both are used to manage the ownership and lifecycle of instances, but they have distinct behaviors and use cases.

Feature	weak	unowned
Optional	Always optional (nil if deallocated)	Non-optional (assumes always valid)
Memory Management	Sets to nil when the referenced object is deallocated	Does not set to nil
Use Case	When the reference might become nil during its lifecycle	When the reference should never be nil after initialization
Common Scenario	Used in delegate patterns, to avoid retain cycles between objects with strong references	Used when both objects have the same lifecycle or the referenced object is guaranteed to outlive the reference
Example Declaration	weak var delegate: SomeDelegate?	unowned var owner: SomeOwner
Safety	Safe to use, automatically handles deallocation	Less safe, can cause runtime crashes if the object is deallocated

What is a delegate in Swift?

A delegate is a design pattern in Swift where one object (the delegate) acts on behalf of another object (the delegator) to handle specific tasks or events. Delegates are typically defined using protocols, allowing the delegator to communicate with the delegate in a decoupled and flexible manner.

How do you declare a delegate protocol and use it in Swift?

To declare a delegate protocol, use the 'protocol' keyword followed by the protocol name and requirements. A class or struct then conforms to the protocol by implementing its methods. The delegator holds a reference to the delegate and calls its methods to communicate and delegate tasks.

What are the main differences between Objective-C and Swift?

Objective-C and Swift are both programming languages used for iOS, macOS, watchOS, and tvOS app development, but they have significant differences in syntax, features, and ecosystem. 

Aspect	Objective-C	Swift
Safety	Manual memory management, less safe	Strongly-typed language with optionals, type inference, and memory safety features
Memory Management	Manual retain-release cycles	Automatic Reference Counting (ARC)
Interoperability	Fully interoperable with C and C++	Interoperable with Objective-C, allowing mixed-language development
Functional Programming	Limited support	Strong support with features like higher-order functions and closures
Open Source	Proprietary	Open-source language and runtime
Performance	Generally good performance	Often faster due to modern compiler and runtime

What is the significance of '@IBOutlet' and '@IBAction' in Swift?

The @IBOutlet and @IBAction are attributes used in Swift for connecting user interface elements with code in Interface Builder:

• @IBOutlet: Connects user interface elements from Interface Builder to Swift code, allowing programmatic interaction with them.
• @IBAction: Links user interaction events from Interface Builder (e.g., button tap) to Swift methods, enabling code to respond to those events.

What is 'guard' in Swift and how does it differ from 'if'?

The 'guard' statement in Swift is used for early exits in functions or loops when certain conditions are not met. It ensures that the conditions are true before proceeding unlike 'if', 'guard' requires an 'else' block and exits the current scope if the condition fails, promoting clearer and safer code.

Explain the use of 'defer' in Swift.

The 'defer' statement in Swift allows you to execute a block of code just before the current scope exits. It’s useful for cleanup tasks, such as closing files or releasing resources. Deferred statements are executed in reverse order of their appearance, ensuring that cleanup code is always run, even if an error occurs.

What is a lazy property in Swift?

A lazy property is a property whose initial value is not calculated until the first time it is accessed. It is declared using the 'lazy' keyword. Lazy properties are useful for properties that require complex or resource-intensive initialization, as they delay this process until it is actually needed.

How do you make a class conform to multiple protocols in Swift?

To make a class conform to multiple protocols, list the protocol names separated by commas after the class name. For example: 'class MyClass: ProtocolA, ProtocolB'. The class must then implement all the requirements of the listed protocols, ensuring it adheres to their contracts.

What is the 'didSet' and 'willSet' in Swift?

'didSet' and 'willSet' are property observers in Swift that allow you to run code in response to changes in a property's value. 'willSet' is called just before the value changes, and 'didSet' is called immediately after. They provide hooks for performing additional actions when a property's value is modified.

What is the difference between 'Array', 'Set', and 'Dictionary' in Swift?

Some key difference between Array, Set, and Dictionary in in Swift:

Feature	Array	Set	Dictionary
Ordered	Yes	No	No
Duplicates	Allowed	Not allowed	Not allowed (unique keys)
Access	Index-based	No direct index-based access	Key-based
Usage	General-purpose, ordered collection	Ensuring uniqueness, no particular order	Key-value pairs, efficient lookups

How do you perform pattern matching in Swift?

Pattern matching in Swift is done using the 'switch' statement, which can match values against various patterns, such as ranges, tuples, enums, and custom conditions. The 'switch' statement provides a powerful way to handle different cases, ensuring all possible values are covered and improving code readability.

What is the difference between synchronous and asynchronous tasks in Swift?

Some key difference between synchronous and asynchronous tasks in Swift:

Aspect	Synchronous Tasks	Asynchronous Tasks
Execution Order	Executes sequentially, blocking the current thread	Can execute concurrently, allowing the thread to continue while the task runs
Blocking	Blocks the current thread until completion	Does not block the current thread, allowing it to continue execution
Performance	May lead to UI unresponsiveness or performance issues if tasks are long or numerous	Enhances app responsiveness and performance by allowing concurrent execution of tasks
Usage	Suitable for short, quick tasks or when order of execution matters	Ideal for long-running tasks like network requests, file I/O, or heavy computations, or when UI responsiveness is critical

How do you handle concurrency in Swift?

Concurrency in Swift can be handled using Grand Central Dispatch (GCD) and operation queues. GCD provides low-level APIs for managing background tasks, while operation queues offer higher-level abstractions with dependencies and priority management. Swift’s async/await feature (introduced in Swift 5.5) further simplifies writing asynchronous code.

What is a completion handler in Swift?

A completion handler is a closure passed as an argument to a function, which is called when the function’s task completes. It allows for asynchronous execution and the handling of results or errors once the task finishes. Completion handlers are commonly used in networking and other time-consuming operations.

Explain the use of 'map', 'filter', and 'reduce' in Swift.

Some use of 'map', 'filter', and 'reduce' in Swift:

• map: Transforms each element in a collection using a provided closure, returning a new collection of the transformed elements. It applies the same operation to each element and returns a collection of the results.
• filter: Selects elements from a collection that satisfy a specified condition, returning a new collection containing only the elements that meet the criteria.
• reduce: Combines all elements in a collection into a single value using a specified closure. It iterates over the collection, applying the closure to each element and accumulating the result into a single value.

What is a higher-order function in Swift?

A higher-order function is a function that takes one or more functions as arguments or returns a function as its result. Swift’s 'map', 'filter', and 'reduce' are examples of higher-order functions. They enable concise and expressive code by allowing functions to be used as parameters and return types.

What are extensions in Swift?

Extensions add new functionality to existing classes, structs, enums, or protocols without modifying the original source code. They can add methods, computed properties, initializers, and conformances to protocols. Extensions promote code modularity and reusability, allowing developers to extend types in a clean and organized manner.

What is a custom initializer in Swift?

A custom initializer is a method in a class, struct, or enum that sets up an instance with specific values. Custom initializers can be used to perform additional setup or validation during instance creation. They are defined using the 'init' keyword and can include parameters to customize the initialization process.

How do you handle JSON parsing in Swift?

JSON parsing in Swift can be done using the 'JSONDecoder' class, which decodes JSON data into Swift types. Define your Swift struct or class to match the JSON structure, and use 'JSONDecoder' to convert the JSON data into instances of your types. Error handling ensures robust parsing and data integrity.

What is Codable in Swift?

Codable is a protocol in Swift that combines the Encodable and Decodable protocols. Types that conform to Codable can be easily encoded to and decoded from external representations, such as JSON. Swift’s Codable API simplifies serialization and deserialization, reducing boilerplate code and ensuring type safety.

What is the use of '@escaping' in Swift?

The '@escaping' attribute is used in Swift to indicate that a closure passed as a parameter to a function can outlive the function’s execution. This is necessary for closures that are stored or executed asynchronously, ensuring that the closure is retained and not deallocated before it is called.

Explain the use of access control in Swift.

Access control restricts access to parts of your code to improve encapsulation and modularity. Swift provides five access levels: open, public, internal, fileprivate, and private. These levels control the visibility of types, properties, and methods, ensuring that implementation details are hidden and only exposed as needed.

What is the difference between 'open' and 'public' access levels in Swift?

Some key difference between the open and public access levels in Swift:

Aspect	open	public
Inheritance	Allows subclassing and overriding from any module	Allows use within any module, but restricts subclassing and overriding to the defining module
Overridability	Can be subclassed and overridden outside the defining module	Can be subclassed and overridden only within the defining module
Example	Often used for framework classes or methods that developers may need to extend or override	Typically used for exposing API to other modules while retaining control over subclassing and overriding

What are property wrappers in Swift?

Property wrappers are a feature in Swift that allows you to define reusable code for managing property values. They encapsulate behavior, such as validation or transformation, and can be applied to properties using the '@' syntax. Property wrappers promote code reuse and simplify property management.

What is Combine in Swift?

Combine is a framework introduced by Apple to handle asynchronous events and data streams in a declarative way. It provides a unified approach for dealing with asynchronous tasks, offering publishers, subscribers, and operators to process and transform data. Combine simplifies reactive programming and improves code readability.

Explain the use of '@State' in SwiftUI.

'@State' is a property wrapper in SwiftUI that allows a view to manage its state. It creates a source of truth for data that can change over time. When the state changes, the view automatically updates to reflect the new data, ensuring that the UI is always in sync with the underlying state.

What is the difference between '@ObservedObject' and '@StateObject' in SwiftUI?

Some key difference between @ObservedObject and @StateObject in SwiftUI:

Aspect	@ObservedObject	@StateObject
Initialization	External object passed into the view	Object created and managed by the view
Lifetime Management	Object's lifecycle managed externally	Object's lifecycle managed by SwiftUI
Reinitialization	Object can be reinitialized when view updates	Object initialized only once during view's lifetime
Use Case	For observing external objects, such as view models	For managing objects within the view, like timers or network controllers
Example	@ObservedObject var viewModel: MyViewModel	@StateObject var timer = TimerController()

How do you perform dependency injection in Swift?

Dependency injection in Swift can be achieved using various techniques, such as constructor injection, property injection, or method injection. These techniques involve passing dependencies into a class or struct, rather than creating them internally. Dependency injection promotes loose coupling, testability, and flexibility in your code.

What is the significance of '@MainActor' in Swift?

'@MainActor' is an attribute in Swift that ensures that the annotated code runs on the main thread. It is used to mark classes, functions, or properties that must be accessed or modified on the main thread, typically for updating the UI. This attribute simplifies concurrency management and ensures thread safety.

What are Result types in Swift?

The 'Result' type in Swift represents the outcome of an operation, encapsulating a success or failure with associated values. It’s an enum with 'success' and 'failure' cases, allowing for clear and concise error handling. 'Result' types improve code readability and robustness by making error handling explicit.

Explain the use of 'Task' and 'TaskGroup' in Swift.

Somke key points about Task and TaskGroup in Swift:

Task:

• Represents an asynchronous unit of work.
• Executes code concurrently and asynchronously.
• Allows tasks to run in the background while the main thread continues its execution.
• Provides a structured way to manage and coordinate asynchronous tasks.

TaskGroup:

• Allows creation of a group of tasks that can run concurrently.
• Provides a mechanism for spawning multiple tasks.
• Enables waiting for all tasks to complete before continuing execution.
• Facilitates parallel processing and efficient handling of asynchronous operations.

What is the difference between 'async' and 'await' in Swift?

Some key difference between async and await in Swift presented in Swift:

Aspect	async	await
Purpose	Marks a function or method as asynchronous	Suspends execution to wait for async operation to complete
Function Type	Can be applied to functions, methods, and closures	Used within async functions to wait for async operations
Execution	Enables asynchronous execution without blocking the calling thread	Pauses execution until the awaited operation completes
Usage	Marks functions that can perform asynchronous work	Used within async functions to retrieve results of asynchronous operations
Example	func fetchData() async { ... }	let data = await fetchData()