.svg){kind=small}
What are you searching for?
The Swift programming language is only five years old, but it is already becoming the main development language for iOS. Developing to version 5.2, Swift has become a complex and powerful language that meets both object-oriented and functional paradigm. And with each new release, it adds even more features.
But how well does the candidate really know Swift? In this article, you will find sample questions for a Swift interview.
Questions are divided into two groups:
Optional allows a variable of any type to present a "no value" situation. In Objective-C, "no value" was only available in reference types using the special nil value. Value types, such as int or float, did not have this capability.
Swift has extended the concept of "no value" to value types. The optional variable can contain either a value or nil, indicating the absence of a value.
Classes support inheritance, but structures do not.
Classes are a reference type, structures are a value type.
In Swift, you can use generics in classes, structures, and enumerations.
Generics fix code duplication. If you have a method that accepts parameters of one type, sometimes you have to duplicate code to work with parameters of another type.
For example, in this code, the second function is a “clone” of the first, except that it has string parameters, not integers.
func areIntEqual (_ x: Int, _ y: Int) -> Bool {
return x == y
}
func areStringsEqual (_ x: String, _ y: String) -> Bool {
return x == y
}
areStringsEqual ("ray", "ray") // true
areIntEqual (1, 1) // true
Using generics, you combine two functions in one and at the same time ensure type safety:
func areTheyEqual < T: Equatable> (_ x: T, _ y: T) -> Boo
return x == y
}
areStringsEqual ("ray", "ray")
areIntEqual (1, 1)
Since you are testing equality, you are restricting types to those that conform to the Equatable protocol. This code provides the desired result and prevents the transfer of parameters of the wrong type.
The most common reasons for using implicitly unwrapped optionals:
The most common reasons for using implicitly unwrapped optionals:
No, it is impossible. We can use extension to add new behavior to an existing type, but we cannot change the type itself or its interface. To store the new stored property, we need additional memory, and extension cannot do this.
A protocol is a type that defines an outline of methods, properties, etc. A class, structure, or enumeration can take a protocol to implement all of this. The protocol itself does not implement the functionality, but defines it.
struct Tutorial {
var difficulty: Int = 1
}
var tutorial1 = Tutorial ()
var tutorial2 = tutorial1
tutorial2.difficulty = 2
tutorial1.difficulty is 1, and tutorial2.difficulty is 2.
In Swift, structures are value types. They are copied, not referenced. The following line copies tutorial1 and assigns it to tutorial2:
var tutorial2 = tutorial1
Changes in tutorial2 do not affect tutorial1.
If Tutorial were a class, tutorial1.difficulty and tutorial2.difficulty would equal 2. Classes in Swift are reference types. When you change the tutorial1 property, you will see the same change for tutorial2 - and vice versa.
The iOS interview doesn't end there. Questions can be more complicated. Let’s move to the advanced level.
Swift is a hybrid language that supports both types. It implements the three basic principles of OOP: Encapsulation, Inheritance, Polymorphism.
As for Swift as a functional language, there are different, but equivalent ways of defining it.
One of the most common on Wikipedia runs as follows: "... a programming paradigm that considers computing as an estimate of mathematical functions, avoids changing states and mutable data."
It cannot be argued that Swift is a complete functional language, but the basics are present.
Sometimes an iOS interview includes tricky questions like this.
A constant is a variable initialized to a compile-time value or an expression allowed at compile time.
A constant created through let does not have to take a value at compile time, but there is still a condition: a value can only be determined once.
No, it is impossible. An extension can be used to add new behavior to an existing type, but not to change the type itself or its interface. If you add a saved property, you will need additional memory to store the new value. The extension is not designed for such tasks.
Trailing expressions are reference types.
A loop reference is possible when two instances contain strong references to each other, causing a memory leak, since neither of the two instances will ever be freed. The reason is that the instance cannot be freed as long as there is a strong reference to it.
You can solve the problem by replacing one of the strong links with weak or unowned.
Here is an example of such an enumeration that contains a Node variant with two associative types, T and
List: enum List <T> {
case node (T, List <T>)
} There will be a compilation error. What did we miss?
We forgot the indirect keyword, which allows similar recursive enumeration options:
enum List <T> {
indirect case node (T, List)
}
Core data is one of the most powerful frameworks provided by Apple for macOS and iOS apps. Core data is used for handling the model layer object in our applications. We can treat Core Data as a framework to filter, modify, save, track the data within the iOS apps. Core Data is not a relational database.
Using core data, we can easily map the objects in our app to the table records in the database without knowing any SQL. Core data is the M in MVC structure.
There are several ways to pass data in swift such as KVO, Delegate, NSNotification & Callbacks, Target-Action, etc.
We hope that the answers provided here would indeed be helpful in understanding the iOS swift basics and advanced topics. These Swift developer interview questions would assist you to check knowledge level of both juniors and experienced professionals.
