Interview: Swift. Questions and answers

The Swift programming language is only four years old, but it is already becoming the main development language for iOS. Developing to version 5.0, Swift has become a complex and powerful language that responds to both the object-oriented and functional paradigm. And with each new release it adds even more features.

But how well do you really know Swift? In this article you will find examples of questions for an interview on Swift.

You can use these questions to interview candidates to test their knowledge or you can test your own. If you do not know the answer, do not worry: there is an answer to every question.

Questions are divided into three groups:
')

Beginner : for beginners. You read a couple of books and used Swift in your own applications.
Intermediate : suitable for those who are really interested in the language. You have already read a lot about it and often experiment.
Advanced : suitable for the most advanced developers - those who like to get into the jungle of syntax and use advanced techniques.

For each level there are two types of questions:

written : suitable for testing by email, as they imply writing code.
verbal : you can use when talking on the phone or in person, as there is enough answer in words.

While reading the article, keep an open playground to be able to check the code from the question. All responses were tested on Xcode 10.2 and Swift 5 .

Beginner
written questions
Question 1
Consider the following code:

struct Tutorial { var difficulty: Int = 1 } var tutorial1 = Tutorial() var tutorial2 = tutorial1 tutorial2.difficulty = 2

What are the values of tutorial1.difficulty and tutorial2.difficulty ? Would there be any difference if the Tutorial were a class? Why?

answer
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 are not reflected in tutorial1 .

If Tutorial were a class, tutorial1.difficulty and tutorial2.difficulty would be 2. Classes in Swift are reference types. When you change the tutorial1 property, you will see the same change in tutorial2 - and vice versa.
Question 2
You declared view1 with var , and view2 with let . What is the difference and will the last line be compiled?

import UIKit var view1 = UIView() view1.alpha = 0.5 let view2 = UIView() view2.alpha = 0.5 // ?

answer
Yes, the last line will compile. view1 is a variable, and you can assign its value to a new instance of UIView. Using let , you can assign a value only once, so the following code will not compile:

view2 = view1 // : view2 is immutable

However, UIView is a class with reference semantics, so you can change the properties of view2 - which means that the code will compile .
Question 3
This code sorts the array alphabetically. Simplify the closure as much as possible.

var animals = ["fish", "cat", "chicken", "dog"] animals.sort { (one: String, two: String) -> Bool in return one < two } print(animals)

answer
Swift automatically determines the type of the closure parameters and the return type, so you can remove them :

animals.sort { (one, two) in return one < two }

You can replace parameter names using the $ i notation:

animals.sort { return $0 < $1 }

Closures consisting of a single statement may not contain the keyword return . The value of the last statement executed becomes the return result of the closure:

animals.sort { $0 < $1 }

Finally, since Swift knows that the elements of an array conform to the Equatable protocol, you can simply write:

animals.sort(by: <)
Question 4
This code creates two classes: Address and Person . It also creates two instances of the Person class ( Ray and Brian ).

class Address { var fullAddress: String var city: String init(fullAddress: String, city: String) { self.fullAddress = fullAddress self.city = city } } class Person { var name: String var address: Address init(name: String, address: Address) { self.name = name self.address = address } } var headquarters = Address(fullAddress: "123 Tutorial Street", city: "Appletown") var ray = Person(name: "Ray", address: headquarters) var brian = Person(name: "Brian", address: headquarters)

Suppose that Brian has moved to a new address and you want to update his entry as follows:

brian.address.fullAddress = "148 Tutorial Street"

It compiles and runs without errors. But, if you check Ray’s address now, you will see that he, too, “moved . ”

What happened here and how can we fix it?

answer
Address is a class and possesses reference semantics . Thus, the headquarters is the same instance of the class, which is shared by ray and brian. A change of headquarters will change the address of both.
To fix this, you can create a new instance of the Address class and assign it to Brian, or declare Address as a struct instead of a class .
oral questions
Question 1
What is optional and what problems do they solve?

answer
optional allows any type of variable to represent a " no value " situation. In Objective-C, “lack of value” was only available in reference types using the special nil value. For value types, like int or float , this was not possible.
Swift extended the concept of "missing value" to value types. The optional variable can contain either a value or nil , signaling the absence of a value.

Question 2
Briefly list the main differences between structure and class .

answer
Classes support inheritance, but structures do not.
Classes are a reference type, structures are type-value.
Question 3
What is generics and what are they for?

answer
In Swift, you can use generics in classes, structures, and enumerations.

Generics eliminate the problem of code duplication. If you have a method that takes parameters of one type, sometimes you have to duplicate the code to work with parameters of another type.

For example, in this code, the second function is the “clone” of the first, except that it has string parameters, not integer.

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 provide type safety:

func areTheyEqual<T: Equatable>(_ x: T, _ y: T) -> Bool { return x == y } areTheyEqual("ray", "ray") areTheyEqual(1, 1)

Since you are testing equality, you limit the types to those that comply with the Equatable protocol. This code provides the desired result and prevents the transfer of parameters of the wrong type.
Question 4
In some cases, implicitly unwrapped optionals cannot be avoided. When and why?

answer
The most common reasons for using implicitly unwrapped optionals are:

when you cannot initialize a property that is not nil at the time of creation. A typical example is the outlet for Interface Builder, which is always initialized after its owner. In this special case, if everything is configured correctly in Interface Builder, you are guaranteed that the outlet is non-nil before it is used.
to solve the strong link cycle problem when two instances of classes link to each other and a non-nil reference to another instance is required. In this case, you mark the link on one side as unowned , and on the other side use the implicit deployment optional.
Question 5
What ways can I deploy optional? Rate them in terms of security.

var x : String? = "Test"

Hint: only 7 ways.

answer
Forced deployment (forced unwrapping) - is unsafe.

let a: String = x!

Implicit deployment when declaring a variable is insecure.

var a = x!

Optional binding is safe.

if let a = x { print("x was successfully unwrapped and is = \(a)") }

Optional chaining is safe.

let a = x?.count

Nil coalescing operator is safe.

let a = x ?? ""

Operator Guard is safe.

guard let a = x else { return }

Optional pattern is safe.

if case let a? = x { print(a) }
Intermediate
written questions
Question 1
What is the difference between nil and .none ?

answer
There is no difference, Optional.none (briefly .none ) and nil are equivalent.
In fact, the following statement returns true :

nil == .none

Using nil is more generally accepted and recommended.
Question 2
Here is a model of a thermometer in the form of a class and structure. The compiler complains about the last line. What is wrong there?

public class ThermometerClass { private(set) var temperature: Double = 0.0 public func registerTemperature(_ temperature: Double) { self.temperature = temperature } } let thermometerClass = ThermometerClass() thermometerClass.registerTemperature(56.0) public struct ThermometerStruct { private(set) var temperature: Double = 0.0 public mutating func registerTemperature(_ temperature: Double) { self.temperature = temperature } } let thermometerStruct = ThermometerStruct() thermometerStruct.registerTemperature(56.0)

answer
ThermometerStruct is correctly declared with the mutating function to change the internal variable. The compiler complains that you call the registerTemperature method of an instance that was created with let , thus this instance is immutable. Changing let to var will correct the compilation error.

In structures, you must mark methods that modify internal variables as mutating , but you cannot call these methods using an immutable instance.
Question 3
What will this code print and why?

var thing = "cars" let closure = { [thing] in print("I love \(thing)") } thing = "airplanes" closure()

answer
Will be printed: I love cars. The capture list will create a copy of the variable at the time the closure is declared. This means that the captured variable will not change its value, even after assigning a new value.

If you omit the capture list in a closure, the compiler will use the link, not the copy. Calling the closure will reflect the change in the variable:

var thing = "cars" let closure = { print("I love \(thing)") } thing = "airplanes" closure() // Prints: "I love airplanes"
Question 4
This is a function that counts the number of unique values in an array:

func countUniques<T: Comparable>(_ array: Array<T>) -> Int { let sorted = array.sorted() let initial: (T?, Int) = (.none, 0) let reduced = sorted.reduce(initial) { ($1, $0.0 == $1 ? $0.1 : $0.1 + 1) } return reduced.1 }

It uses sorted, so it uses only types that comply with the Comparable protocol.

You can call her like this:

countUniques([1, 2, 3, 3]) // 3

Rewrite this function as an Array extension so that you can use it like this:

[1, 2, 3, 3].countUniques() // 3

translator's note
Something painfully monstrous function. Why not so:

func countUniques<T: Hashable>(_ array: Array<T>) -> Int { return Set(array).count }

answer
extension Array where Element: Comparable { func countUniques() -> Int { let sortedValues = sorted() let initial: (Element?, Int) = (.none, 0) let reduced = sortedValues.reduce(initial) { ($1, $0.0 == $1 ? $0.1 : $0.1 + 1) } return reduced.1 } }
Question 5
Here is a function that divides two optional doubles. There are three conditions that must be met:
the dividend should not be nil
divider must not be nil
the divider must not be 0

func divide(_ dividend: Double?, by divisor: Double?) -> Double? { if dividend == nil { return nil } if divisor == nil { return nil } if divisor == 0 { return nil } return dividend! / divisor! }

Rewrite this function using the guard operator and not using forced unwrapping.
answer
The guard operator, which appeared in Swift 2.0, provides a way out if the condition is not met. Here is an example:

guard dividend != nil else { return nil }

You can also use the guard operator for optional binding , after which the expanded variable will be available outside the guard operator :

guard let dividend = dividend else { return .none }

So you can rewrite the function like this:

func divide(_ dividend: Double?, by divisor: Double?) -> Double? { guard let dividend = dividend else { return nil } guard let divisor = divisor else { return nil } guard divisor != 0 else { return nil } return dividend / divisor }

Notice the lack of forced unpacking, since we have already unpacked the dividend and the divisor and placed them in non-optional immutable variables.

Note also that the result of the unpacked optionals in the guard statement is also available outside the guard statement.

You can further simplify the function by grouping guard operators:

func divide(_ dividend: Double?, by divisor: Double?) -> Double? { guard let dividend = dividend, let divisor = divisor, divisor != 0 else { return nil } return dividend / divisor }
Question 6
Rewrite the method from question 5 using the if let statement .

answer
The if let statement allows you to unpack optionals and use this value inside this block of code. Outside of it, these values will not be available.

func divide(_ dividend: Double?, by divisor: Double?) -> Double? { if let dividend = dividend, let divisor = divisor, divisor != 0 { return dividend / divisor } else { return nil } }
oral questions
Question 1
In Objective-C, you declare a constant like this:

const int number = 0;

And so in Swift:

let number = 0

What is the difference?

answer
In Objective-C, the constant is initialized at compile time by a value that should be known at this stage.

The immutable value created with let is a constant defined at run time . You can initialize it with a static or dynamic expression. Therefore, we can do this:

let higherNumber = number + 5

Please note: such an assignment is possible only once.
Question 2
To declare a static property or function for value types, use the static modifier. Here is an example for the structure:

struct Sun { static func illuminate() {} }

And for classes it is possible to use static or class modifiers. The result is the same, but there is a difference. Describe it.

answer
static makes a property or function static and non-overlapping . Using the class will allow overriding a property or function.

Here the compiler will swear at trying to block illuminate () :

class Star { class func spin() {} static func illuminate() {} } class Sun : Star { override class func spin() { super.spin() } // error: class method overrides a 'final' class method override static func illuminate() { super.illuminate() } }
Question 3
Is it possible to add stored property to a type using an extension ? How or why not?

answer
No, It is Immpossible. We can use extension to add a new behavior to an existing type, but we cannot change the type or its interface. To store the new stored property, we need additional memory, and the extension cannot do this.

Question 4
What is a protocol in Swift?

answer
A protocol is a type that defines a sketch of methods, properties, etc. A class, structure, or enumeration can adopt a protocol to implement all of this. The protocol itself does not implement the functionality, but defines it.
Advanced
written questions
Question 1
Suppose we have a structure that defines a thermometer model:

public struct Thermometer { public var temperature: Double public init(temperature: Double) { self.temperature = temperature } }

To create an instance, we write:

var t: Thermometer = Thermometer(temperature:56.8)

But it would be much more convenient for something like this:

var thermometer: Thermometer = 56.8

Is it possible? How?

answer
Swift defines protocols that allow initialization of a type using assignment literals. Applying the appropriate protocol and providing a public initializer will allow initialization using literals. In the case of the Thermometer, we implement the ExpressibleByFloatLiteral :

extension Thermometer: ExpressibleByFloatLiteral { public init(floatLiteral value: FloatLiteralType) { self.init(temperature: value) } }

Now we can create an instance like this:

var thermometer: Thermometer = 56.8
Question 2
Swift has a set of predefined operators for arithmetic and logical actions. It also allows you to create your own operators, both unary and binary.

Define and implement your own exponentiation operator (^^) for the following requirements:
takes as parameters two int
returns the result of raising the first parameter to the power of the second
correctly processes the order of algebraic operations
ignores possible overflow errors

answer
Creating a new operator occurs in two stages: declaration and implementation.

The declaration uses the operator keyword to specify the type (unary or binary), to specify the sequence of characters for the new operator, its associativity and precedence.

Here the operator is ^^ and its type is infix (binary). Associativity right.

Swift has no predefined precedence for exponentiation. In algebra, exponentiation must be computed before multiplication / division. Thus, we create a custom execution order by placing the exponentiation above the multiplication.

This announcement:

precedencegroup ExponentPrecedence { higherThan: MultiplicationPrecedence associativity: right } infix operator ^^: ExponentPrecedence

This is the implementation:

func ^^(base: Int, exponent: Int) -> Int { let l = Double(base) let r = Double(exponent) let p = pow(l, r) return Int(p) }
Question 3
The following code defines the Pizza structure and the Pizzeria protocol with an extension for implementing the default makeMargherita () method:

struct Pizza { let ingredients: [String] } protocol Pizzeria { func makePizza(_ ingredients: [String]) -> Pizza func makeMargherita() -> Pizza } extension Pizzeria { func makeMargherita() -> Pizza { return makePizza(["tomato", "mozzarella"]) } }

Now we define the Lombardis restaurant:

struct Lombardis: Pizzeria { func makePizza(_ ingredients: [String]) -> Pizza { return Pizza(ingredients: ingredients) } func makeMargherita() -> Pizza { return makePizza(["tomato", "basil", "mozzarella"]) } }

The following code creates two instances of Lombardis . In which of them make margarita with basil?

let lombardis1: Pizzeria = Lombardis() let lombardis2: Lombardis = Lombardis() lombardis1.makeMargherita() lombardis2.makeMargherita()

answer
In both. The Pizzeria protocol declares the makeMargherita () method and provides a default implementation. The Lombardis implementation overrides the default method. Since we declared the method in the protocol in two places, the correct implementation will be called.

And what if the protocol did not declare the makeMargherita () method, and the extension still provided the default implementation, like this:

protocol Pizzeria { func makePizza(_ ingredients: [String]) -> Pizza } extension Pizzeria { func makeMargherita() -> Pizza { return makePizza(["tomato", "mozzarella"]) } }

In this case, only lombardis2 would have pizza with basil, whereas lombardis1 would have no, because he would use the method defined in the extension.
Question 4
The following code is not compiled. Can you explain what's wrong with him? Offer solutions to the problem.

struct Kitten { } func showKitten(kitten: Kitten?) { guard let k = kitten else { print("There is no kitten") } print(k) }

Hint: There are three ways to correct the error.

answer
The else block of the guard statement requires an exit option, either using return , throwing an exception or calling @noreturn . The simplest solution is to add a return statement .

func showKitten(kitten: Kitten?) { guard let k = kitten else { print("There is no kitten") return } print(k) }

This solution will throw an exception:

enum KittenError: Error { case NoKitten } struct Kitten { } func showKitten(kitten: Kitten?) throws { guard let k = kitten else { print("There is no kitten") throw KittenError.NoKitten } print(k) } try showKitten(kitten: nil)

Finally, here is the call to fatalError () , @noreturn -function.

struct Kitten { } func showKitten(kitten: Kitten?) { guard let k = kitten else { print("There is no kitten") fatalError() } print(k) }
oral questions
Question 1
Is closure a reference type or value type?

answer
Closures are a reference type. If you assign a closure to a variable, and then copy to another variable, you copy the reference to the same closure and its capture list.
Question 2
You use the UInt type to store an unsigned integer. It implements an initializer for converting from the whole with the sign:

init(_ value: Int)

However, the following code will not compile if you specify a negative value:

let myNegative = UInt(-1)

Signed integers cannot be negative by definition. However, it is possible to use the representation of a negative number in memory to convert it to unsigned.

How can I convert a negative integer to a UInt while keeping its representation in memory?

answer
For this there is an initializer:

UInt(bitPattern: Int)

And use:

let myNegative = UInt(bitPattern: -1)
Question 3
Describe circular references in Swift? How can they be fixed?

answer
Cyclic references occur when two instances contain a strong reference to each other, which results in a memory leak due to the fact that none of these instances can be released. An instance cannot be released while there are still strong references to it, but one instance holds the other.

This can be resolved by replacing the link on one of the parties by specifying the weak or unowned keyword .
Question 4
Swift allows you to create recursive enums. Here is an example of such an enumeration that contains a variant of Node 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?

answer
We forgot the indirect keyword, which allows similar recursive enumeration options:

enum List<T> { indirect case node(T, List<T>) }

Source: https://habr.com/ru/post/449410/

All Articles

Interview: Swift. Questions and answers

Beginner

Intermediate

Advanced

More articles: