Interview Questions and Answers

Swift is a programming language developed by Apple for iOS, macOS, watchOS, tvOS, and Linux applications.

Optionals are a type in Swift that represents either a wrapped value or nil, indicating the absence of a value.

'let' is used to declare constants, and 'var' is used to declare variables.

A closure is a self-contained block of functionality that can be passed around and used in your code.

Property observers are used to observe and respond to changes in a property's value, providing a way to execute code before or after the value changes.

The 'static' keyword in Swift is used to define type-level properties and methods that are associated with the type itself, rather than an instance of the type.

Swift Package Manager is a tool for managing the distribution of Swift code as source or binary packages.

'DispatchQueue' is used for managing the execution of tasks serially or concurrently in a multithreaded environment.

'self' is used to refer to the instance of the current type, and it's often required to distinguish between instance variables and parameters with the same name.

'lazy' is used to delay the initialization of a property until it's accessed for the first time.

'frame' represents a view's location and size in its superview's coordinate system, while 'bounds' represents a view's location and size in its own coordinate system.

'throws' is used to indicate that a function can potentially throw an error, and it must be marked with 'try' when called.

The 'UIApplicationDelegate' is a protocol in Swift that defines methods for handling app lifecycle events, such as app launch, termination, and background execution.

A typealias is used to create a named alias for an existing type. It is useful for making code more readable and for simplifying complex type declarations.

A value type is copied when it's assigned to a new variable or passed as an argument, while a reference type refers to the same instance of the data.

ARC is a memory management feature in Swift that automatically tracks and manages the memory usage of your app.

Swift uses a combination of 'try', 'catch', 'throw', and 'do' keywords for error handling using the Swift Error protocol.

The 'guard' statement is used to transfer control out of a scope if certain conditions aren't met, ensuring that a set of requirements is satisfied.

The Codable protocol is used for encoding and decoding data between Swift types and external data formats, such as JSON or Property Lists.

Lazy loading is a technique in Swift where a property is not initialized until it's accessed for the first time.

Synchronous tasks block the current thread until they are completed, while asynchronous tasks allow the program to continue executing other tasks without waiting.

The 'unowned' keyword is used in Swift to declare a reference that does not keep a strong hold on the instance it refers to, and it is assumed to always have a value.

Generics allow you to write flexible, reusable functions and types that can work with any type, subject to requirements that you define.

Swift uses Automatic Reference Counting (ARC) for memory management, eliminating the need for manual memory management in Objective-C.

Structs are value types, while classes are reference types. Structs are copied when assigned or passed, whereas classes share a reference to the same instance.

Type casting is the process of converting one type to another, and it can be done in Swift using 'as', 'as?', and 'as!' operators.

To create a custom delegate in Swift, define a protocol, adopt it in the delegating class, and use optional delegate methods to notify the delegate of events.

Value semantics mean that the value of a type is copied when assigned to a new variable or passed as an argument, ensuring that each instance is independent.

In Swift, the equivalent to 'NSRunLoop' is 'RunLoop', which is used for managing input sources on a thread.

'==' is used to check for value equality, '===' is used to check for reference equality, and 'isEqual' is typically used for comparing objects in Objective-C and is bridged to '==' in Swift.

An 'escaping' closure is a closure that is called after the function it was passed to has returned. It's necessary when the closure is stored or outlives the scope of the function.

'defer' is used to execute a block of code just before the scope is exited, while 'finally' is not used in Swift. Instead, error handling with 'defer' and 'catch' is more idiomatic.

'inout' parameters allow a function to modify the value of the parameter directly, and any changes made inside the function affect the original value outside the function.

A closure capture list specifies how variables and constants are captured and held by a closure. It's useful to prevent strong reference cycles, especially when capturing 'self' in closures.

The 'autoreleasepool' is used to manage the lifecycle of objects in memory, especially in performance-critical code or when working with Objective-C APIs.

The 'NSCoding' protocol is used for encoding and decoding objects, typically for archiving and unarchiving data in iOS and macOS apps.

Key paths provide a way to reference properties in a type-safe manner. They are used in KVO, functional programming, and the 'Codable' protocol.

Swift has five access control levels: 'open', 'public', 'internal', 'fileprivate', and 'private'. They control the visibility of classes, methods, and properties.

The 'init?' initializer is a failable initializer, which means it can return nil if the initialization fails.

The 'async/await' pattern is used for asynchronous programming in Swift, allowing you to write asynchronous code in a more sequential manner.

Protocol-oriented programming is a programming paradigm in Swift that emphasizes the use of protocols to define the structure and behavior of types.

The '@escaping' keyword is used in Swift to indicate that a closure passed as a parameter to a function may be stored beyond the lifetime of that function.

The 'defer' statement is used to execute a block of code just before the current scope is exited, regardless of how the scope is exited.

Swift is a modern, safer, and more concise language compared to Objective-C. It introduces optionals, type inference, generics, and is memory-safe with Automatic Reference Counting (ARC).

Swift does not support multiple inheritance directly. Instead, it uses protocols to achieve similar functionality through protocol-oriented programming.

Generics with associated types allow you to define protocols with placeholders for associated types, enabling you to use generic types conforming to the protocol.

In Swift, KVO is achieved using the '@objc dynamic' modifier for properties and the 'addObserver(_:forKeyPath:options:context:)' method.

Method swizzling is a technique used to exchange the implementation of methods at runtime. It's often used for extending or modifying the behavior of existing classes.

Swift uses Automatic Reference Counting (ARC) to manage memory, but memory leaks can still occur if strong reference cycles are created. Common causes include strong reference cycles between objects.