Top 72 Swift Interview Questions And Answers

Question 1

Determine the value of `x` in the Swift code below. Explain your answer.

Accepted Answer

In Swift, arrays are implemented as structs, making them value types rather than reference types (i.e., classes). When a value type is assigned to a variable as an argument to a function or method, a copy is created and assigned or passed. As a result, the value of `x` or the count of array `a1` remains equal to `5` (**answer**) while the count of array `a2` is equal to `6`, appending the integer `6` onto a _copy_ of the array `a1`. The arrays appear in the box below.

```swift
a1 = [1, 2, 3, 4, 5]
a2 = [1, 2, 3, 4, 5, 6]
```

Question 2

What is a _Serial Queue_?

Accepted Answer

A **Serial Queue** allows us to perform only one task at a time, no matter the way of execution, i.e. `Synchronous` or `Asynchronous`. In short, the code executed by **Serial DispatchQueue** is not parallel and has to wait for the first task to complete. This way of execution is also known as **First In, First Out (FIFO)**.

All the queues need to wait for the completion of the previous queue. By default, **DispatchQueue** is a _serial_ queue.

Consider:

```swift
let queue = DispatchQueue(label: "com.swiftpal.dispatch.serial")

queue.async() {
    Thread.sleep(forTimeInterval: 3) // Wait for 3 seconds
    print("Task 1 Done")
}

queue.async() {
    Thread.sleep(forTimeInterval: 1) // Wait for 1 second.
    print("Task 2 Done")
}

/* Output:
 Task 1 Done
 Task 2 Done
*/
```

Question 3

How to iterate a loop with index and element in Swift?

Accepted Answer

Swift 5 provides a method called [`enumerated()`](https://developer.apple.com/documentation/swift/array/1687832-enumerated) for `Array`:

```swift
let list = ["Car", "Bike", "Plane", "Boat"]
for (index, element) in list.enumerated() {
    print(index, ":", element)
}

/*
prints:
0 : Car
1 : Bike
2 : Plane
3 : Boat
*/
```

Question 4

What’s the difference between `==` and `===`?

Accepted Answer

* **`==`** operator checks if the **values** are the same, comparing **value types**. **`"equal to"`**
* **`===`** operator checks if the **references** point the same instance (both point to the same memory address), comparing **reference types**. **`"identical to"`**

Question 5

What is the difference between _Upcast_ and _Downcast_ in Swift?

Accepted Answer

* The **upcast**, going from a derived class to a base class, can be checked at compile time and will never fail.
* However, **downcasts** can fail since you can’t always be sure about the specific class. If you have a UIView, it’s possible it’s a UITableView or maybe a UIButton.
  *  downcasts must be either optional with `as?` or 
  * “forced failable” with `as!` when sure about the type

Question 6

What are _Extensions_ used for in Swift?

Accepted Answer

**Extensions** add new functionality to an existing class, structure, enumeration, or protocol type. This includes the ability to extend types for which you do not have access to the original source code. Extensions are similar to categories in Objective-C

Extensions in Swift can:

- Add computed instance properties and computed type properties
- Define instance methods and type methods
- Provide new initializers
- Define subscripts
- Define and use new nested types
- Make an existing type conform to a protocol

Question 7

What’s the difference between a _protocol_ and a _class_ in Swift?

Accepted Answer

In their basic form, a protocol describes what an unknown type of object can do. You might say it has two or three properties of various types, plus methods. But that protocol never includes anything _inside_ the methods, or provides actual storage for the properties.

In a more advanced form, you can write extensions on your protocols that provide default implementations of the methods. You still can’t provide storage for properties, however.

In comparison, classes are concrete things. While they might adopt protocols – i.e., say they implement the required properties and methods – they aren’t required to do that. You can create objects from classes, whereas protocols are just type definitions. Try to think of protocols as being abstract definitions, whereas classes and structs are real things you can create.

Question 8

What does the Swift `mutating` keyword mean?

Accepted Answer

Being the value type structs are immutable. Meaning other variables can not change the values for instance of structure at any given point.

The mutating word is required for changing the values of self variables inside structure's function only.

For. e.g

```swift
struct MyStruct {
    var abc: String = "initila value"

func changeValue() {
        abc = "some other value". //Compile time error: Cannot assign to property: 'self' is immutable. Mark method 'mutating' to make 'self' mutable.
    }
}
```

Here as we are trying to change value of variable abc inside function declared in struct itself, we get the compile time error.

So here we need to make function mutating to make change value inside structure. Hence the correct code will be:

```swift
struct MyStruct {
    var abc: String = "initila value"

mutating func changeValue() {
        abc = "some other value"
   }
}
```

Question 9

Why and how to use associated values in enums?

Accepted Answer

Enums with _associated_ values let you associate extra data with an enum case. This helps make them significantly more useful, because we can create **gradations** of cases rather than have them be absolute.

Consider:

```swift
enum Weather {
    case sunny
    case cloudy(coverage: Int)
    case windy(speed: Int)
    case rainy(chance: Int)
}

let london = Weather.cloudy(coverage: 90)
let gusty = Weather.windy(speed: 10)
let guaranteedRain = Weather.rainy(chance: 100)
```

Question 10

Rewrite this code in a Swift way

Accepted Answer

Yeap, the way to do it is:

```swift
let list = [Int](1...5)
let arrayOfTuples = Array(list.enumerated())
print(arrayOfTuples) // prints [(offset: 0, element: 1), (offset: 1, element: 2), (offset: 2, element: 3), (offset: 3, element: 4), (offset: 4, element: 5)]
```
or with `map`:
```swift
let list = [Int](1...5)
let arrayOfDictionaries = list.enumerated().map { (a, b) in return [a : b] }
print(arrayOfDictionaries) // prints [[0: 1], [1: 2], [2: 3], [3: 4], [4: 5]]
```

Top 72 Swift Interview Questions

What are Extensions used for in Swift?

What is a Serial Queue?

What is the difference between Upcast and Downcast in Swift?

What’s the difference between == and ===?

When would you use self in a method?

When to use @objc attribute?

What is a good use case for an inout parameter?

What is trailing closure syntax?

What is the difference between a computed property and a property set to a closure?

What is difference between as?, as! and as in Swift?

What is typecasting?

In Swift enumerations, what’s the difference between raw values and associated values?

When to use a set rather than an array in Swift?

What Classes and Structs have in common in Swift and what are their differences?

What’s a strong reference, and why do we need it?

What's the difference between Self vs self?

What does the required keyword in Swift mean?

When to use strong, weak and unowned references?

What's the main difference between the Array, Set and Dictionary collection type?

What does the Swift mutating keyword mean?

What is the difference between let and var in Swift?

Explain the defer usage in Swift

What are the differences between functions and methods in Swift?

How to sort array of custom objects by property value in Swift?

Explain the difference between DispatchQueue.main.async and DispatchQueue.main.sync?

When should I use deinit?

What’s the difference between a protocol and a class in Swift?

What is the autoclosure attribute and when to use it?

What is the difference between ARC (automatic reference counting) and GC (garbage collection)?

What’s the difference between a static variable and a class variable?

What is QoS (Quality of Service) in GCD?

What is the difference between open and public keywords in Swift?

What is the difference between functions and closures?

Can you rewrite this code using mutating function?

What is the difference between static func and class func in Swift?

Are there any differences between Protocol in Swift vs Interface in Java?

Is there a way to create an abstract class in Swift?

What is the difference between fileprivate and private?

What’s the difference between Any and AnyObject?

When to use fileprivate access modifier in Swift?

Explain when to use different Swift casting operators?

What's wrong with this code?

When should you use Structs over Classes?

When should you use Classes over Structs?

What is Copy on Write (Cow) in Swift?

Explain the difference between weak and unowned references. Provide an example.

When is it safe to use an unowned reference?

What's the difference between marking a method as @objc vs dynamic, when would you do one vs the other?

Explain usage of Concurrent vs Serial Queues with async and sync blocks

Explain how that code will behave for different Swift versions?

What is the difference between @escaping and @nonescaping Closures in Swift?

What are the benefits of using DispatchWorkItem in Swift?

Explain what is DispatchGroup?

Explain the use case when ARC won't help you to release memory (but GC will)?

Why can not we just use weak everywhere and forget about unowned?

Do we need to use [weak self] or [unowned self] in this closure?

What is the Never return type? When to use it over Void?

What’s the difference between init?() and init()?

What is the use of Hashable protocol?

Determine the value of x in the Swift code below. Explain your answer.

How to iterate a loop with index and element in Swift?

How can I check if an object is of a given type in Swift?

Rewrite this code in a Swift way

Why and how to use associated values in enums?

How to append one array to another array in Swift?

How to break out of multiple loop levels?

Provide an example of code with a memory leak

Explain what will be the output of this code?

What to use: [String: Any] or [String: AnyObject]?

How to add a custom initializer to a struct without losing its memberwise initializer?

How to optimize this code?

How to deal with retain cycles in Closures? Provide an example.

What’s the difference between `==` and `===`?

When would you use `self` in a method?

When to use `@objc` attribute?

What is a good use case for an `inout` parameter?

What is difference between `as?`, `as!` and `as` in Swift?

What's the difference between `Self` vs `self`?

What does the `required` keyword in Swift mean?

When to use `strong`, `weak` and `unowned` references?

What's the main difference between the `Array`, `Set` and `Dictionary` collection type?

What does the Swift `mutating` keyword mean?

What is the difference between `let` and `var` in Swift?

Explain the `defer` usage in Swift

Explain the difference between `DispatchQueue.main.async` and `DispatchQueue.main.sync`?

When should I use `deinit`?

What is the `autoclosure` attribute and when to use it?

What’s the difference between a `static` variable and a `class` variable?

What is the difference between `open` and `public` keywords in Swift?

Can you rewrite this code using `mutating` function?

What is the difference between `static func` and `class func` in Swift?

Are there any differences between `Protocol` in Swift vs `Interface` in Java?

What is the difference between `fileprivate` and `private`?

What’s the difference between `Any` and `AnyObject`?

When to use `fileprivate` access modifier in Swift?

Explain the difference between `weak` and `unowned` references. Provide an example.

When is it safe to use an `unowned` reference?

What's the difference between marking a method as `@objc` vs `dynamic`, when would you do one vs the other?

Explain usage of Concurrent vs Serial Queues with `async` and `sync` blocks

What is the difference between `@escaping` and `@nonescaping` Closures in Swift?

What are the benefits of using `DispatchWorkItem` in Swift?

Why can not we just use `weak` everywhere and forget about `unowned`?

Do we need to use `[weak self]` or `[unowned self]` in this closure?

What is the `Never` return type? When to use it over `Void`?

What’s the difference between `init?()` and `init()`?

What is the use of `Hashable` protocol?

Determine the value of `x` in the Swift code below. Explain your answer.

What to use: `[String: Any]` or `[String: AnyObject]`?