Programming
Swift
4.6 Rating 8 Questions 10 mins read67 Readers
Programming
4.6 Rating 8 Questions 10 mins read67 Readers
enum BookType {
case biology
case physics
case maths
case unknown
}
class Book {
var name:String?
var type:BookType = .unknown
}
class BookStorage {
func fetchAllBooks() -> [Book] {
// return all available books
}
}
class BooksManager {
func physicsBooks() -> [Book] {
let books = BookStorage().fetchAllBooks()
// identify the physics book and return those
let physicsbooks …
return physicsbooks
}
}We want to test cover the function of physicsBooks. Test the logic if it identifies the physics books from different data sets. Redesign this classes to test cover the method.
Use dependency injection to redesign the classes and provide data from test methods
protocol IBookStorage {
func fetchAllBooks()->[Book]
}
class BookStorage: IBookStorage {
func fetchAllBooks() -> [Book] {
// return all available books
}
}
class BooksManager {
let bookStorage:IBookStorage
init(bookStorage:IBookStorage) {
self.bookStorage = bookStorage
}
func physicsBooks() -> [Book] {
let books = bookStorage.fetchAllBooks()
// identify the physics book and return those
let physicsbooks = …
return physicsbooks
}
}
class StubBookStorage: IBookStorage {
var books = [Book]()
init(books:[Book]) {
self.books = books
}
func fetchAllBooks() -> [Book] {
return books
}
}
// Test methods
func testBookManager() {
let books = … // add stub data you want to test
let bookStorage = StubBookStorage(books: books)
let bookManager = BooksManager(bookStorage: bookStorage)
let physicsBooks = bookManager.physicsBooks()
// test the value physicsBooks array if correct
}This, along with other Swift basic questions for freshers, is a regular feature in Swift programming interviews, be ready to tackle it with the approach mentioned.
Key is to use associated types, which is a powerful way of making protocols generic.
protocol Store {
associatedtype DataType
var ids: [DataType] { get set}
mutating func add(id: DataType)
}
extension Store {
mutating func add(id: DataType) {
ids.append(id)
}
}
struct SystemOne: Store {
var ids = [String]()
}
struct SystemTwo: Store {
var ids = [Int]()
}
var sysOne = SystemOne()
sysOne.add(id: "One")
sysOne.add(id: "Two")
var sysTwo = SystemTwo()
sysTwo.add(id: 1)
sysTwo.add(id: 2)
print(sysOne.ids)
print(sysTwo.ids)In MVC, controller is coordinated that reads / saves data into the data model and displays data / handles actions in the view.
In MVVM, the view model is a close representation of a view. The view model is bound to the view. Any change in data in the view model, leads to notifiications and view pulls data from the view model and it displays it.
Test covering controllers can be a bit difficult as view is tightly attached to a view i.e View controller will have an instance of a view within it. So it will be difficult to mock the view methods called from the controller.
Test covering in ViewModel is rather easy as it does not contain any reference to a view. Rather it only prepares data for the view only. It is the view that pulls the data from the view model. Also, the view delegates the action to the View model.
One of the most frequently posed Swift iOS interview questions, be ready for this conceptual question.
class SwiftBasics {
static func test() {
let emp1 = Employee(name: "John", id: 10)
let emp2 = Employee(name: "John", id: 10)
print("\(emp1 == emp2)")
}
}
struct Employee {
var name:String
var id:Int
init(name:String, id:Int) {
self.name = name
self.id = id
}
}It would provide a compilation error as emp1 == emp2 cannot be resolved by compiler. It depends if the structs/classes are adapted to the Hashable protocol. The primitive data type like Int, String by default implement the Hashable protocol, show they do not show any error if we compare instances of such data types.
The corrected code would be:
struct Employee: Hashable {
var name:String
var id:Int
init(name:String, id:Int) {
self.name = name
self.id = id
}
var hashValue: Int { return self.id}
}
The printed result would be true.This is one of the most frequently asked Swift interview questions for freshers and experienced in recent times.
There will be a compilation error. The derived class Car calls the init method of superclass before its stored property, model gets initialised. Swift does 2 phase initialization, in first phase memory is allocated and all stored properties get initialized starting from the derived classes and then its superclass. Then in the second phase, all customizations of the properties are done, in the init method.
The correct code will be :
class Car:Transport {
var model:String
init(model:String){
self.model = model
super.init(type: "Car")
self.model = "\(self.model) - type \(self.type)"
print("\(self.model)")
}
}
The result will be
Transport - Car
Maruti - type CarA staple Swift interview question for senior developer, be prepared to answer this one using your hands-on experience. This is also one of the top interview questions to ask an application developer.
Dump function is used to print the content of the object
For eg:
class Person {
let name: String
let cars: [String]?
init(name:String, cars: [String]?) {
self.name = name
self.cars = cars
}
}let allPerson = [Person(name: "P1", cars: ["P1_C1", "P1_C2"]), Person(name: "P2", cars: ["P2_C1", "P2_C2"])]
dump(allPerson)
Output:
▿ 2 elements ▿ App.Person #0 - name: "P1" ▿ cars: Optional(["P1_C1", "P1_C2"]) ▿ some: 2 elements - "P1_C1" - "P1_C2" ▿ App.Person #1 - name: "P2" ▿ cars: Optional(["P2_C1", "P2_C2"]) ▿ some: 2 elements - "P2_C1" - "P2_C2" //As seen, dump() outputs the whole class hierarchy, while print() simply outputs the class name.
