Swift面试题及答案整理

时间:2022-09-20 17:43:45

前言

Swift语言至今诞生有一年多的时间了,已经成为当前最流行语言之一。虽然它的语法简单好用,但实际上Swift是一门非常复杂的语言。因为它不仅是面向对象的同时又是函数式编程语言。本文主要介绍Swift常见的一些面试问题,你可以用这些问题向面试者提问,也可以用来测试你自己目前所掌握的Swift知识,如果你不清楚问题答案的话也不用太担心,因为每个问题下面都有相应的答案。

一、给一个数组,要求写一个函数,交换数组中的两个元素

二X程序员:

好简单啊,直接写出以下结果

?
1
2
3
4
5
func swap(_ nums: inout [Int], _ p: Int, _ q: Int) {
 let temp = nums[p]
 nums[p] = nums[q]
 nums[q] = temp
}

普通程序员:

首先跟面试官沟通,是什么类型的数组?面试官会说,任意。普通程序员微微一笑,写出以下代码

?
1
2
3
4
5
func swap<T>(_ nums: inout [T], _ p: Int, _ q: Int) {
 let temp = nums[p]
 nums[p] = nums[q]
 nums[q] = temp
}

文艺程序员:

与面试官沟通,是什么类型的数组?有什么其他要求和限制?面试官会说,这是一个Swift面试题。文艺程序员心领神会,于是写出以下答案

?
1
2
3
func swap<T>(_ nums: inout [T], _ p: Int, _ q: Int) {
 (nums[p], nums[q]) = (nums[q], nums[p])
}

同时对以上代码写上相应测试,检测各种边界情况,再确认无误后,才会说,这道题目我完成了。

这道题目看似简单,实际上考察了程序员的审题、交流、以及测试的意识。技术上考察了Swift的泛型和Tuple的性质。

二、下面代码有什么问题

?
1
2
3
4
5
6
7
8
9
public class Node {
 public var value: Int
 public var prev: Node?
 public var post: Node?
 
 public init(_ value: Int) {
 self.value = value
 }
}

答案:应该在 var prev 或者 var post 前面加上 weak。

原因:表面上看,以上代码毫无问题。但是我这样一写,问题就来了:

?
1
2
3
4
let head = Node(0)
let tail = Node(1)
head.post = tail
tail.prev = head

此时,head 和 tail 互相指向,形成循环引用(retain cycle)。

三、实现一个函数,输入是任一整数,输出要返回输入的整数 + 2

这道题很多人上来就这样写:

?
1
2
3
func addTwo(_ num: Int) -> Int {
 return num + 2
}

接下来面试官会说,那假如我要实现 + 4 呢?程序员想了一想,又定义了另一个方法:

?
1
2
3
func addFour(_ num: Int) -> Int {
 return num + 4
}

这时面试官会问,假如我要实现返回 + 6, + 8 的操作呢?能不能只定义一次方法呢?正确的写法是利用 Swift 的柯西特性:

?
1
2
3
4
5
6
7
func add(_ num: Int) -> (Int) -> Int {
 return { val in
 return num + val
 }
}
 
let addTwo = add(2), addFour = add(4), addSix = add(6), addEight = add(8)

四、 精简以下代码

?
1
2
3
4
5
6
7
8
9
10
11
12
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!
}

这题考察的是 guard let 语句以及 optional chaining,最佳答案是

?
1
2
3
4
5
6
7
func divide(dividend: Double?, by divisor: Double?) -> Double? {
 guard let dividend = dividend, let divisor = divisor, divisor != 0 else {
 return nil
 }
 
 return dividend / divisor
}

五、以下函数会打印出什么?

?
1
2
3
4
5
6
var car = "Benz"
let closure = { [car] in
 print("I drive \(car)")
}
car = "Tesla"
closure()

因为 clousre 已经申明将 car 复制进去了([car]),此时clousre 里的 car 是个局部变量,不再与外面的 car有关,所以会打印出"I drive Benz"。

此时面试官微微一笑,将题目略作修改如下:

?
1
2
3
4
5
6
var car = "Benz"
let closure = {
 print("I drive \(car)")
}
car = "Tesla"
closure()

此时 closure 没有申明复制拷贝 car,所以clousre 用的还是全局的 car 变量,此时将会打印出 "I drive Tesla"

六、以下代码会打印出什么?

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
protocol Pizzeria {
 func makePizza(_ ingredients: [String])
 func makeMargherita()
}
 
extension Pizzeria {
 func makeMargherita() {
 return makePizza(["tomato", "mozzarella"])
 }
}
 
struct Lombardis: Pizzeria {
 func makePizza(_ ingredients: [String]) {
 print(ingredients)
 }
 func makeMargherita() {
 return makePizza(["tomato", "basil", "mozzarella"])
 }
}
 
let lombardis1: Pizzeria = Lombardis()
let lombardis2: Lombardis = Lombardis()
lombardis1.makeMargherita()
lombardis2.makeMargherita()

答案:打印出如下两行

?
1
2
["tomato", "basil", "mozzarella"]
["tomato", "basil", "mozzarella"]

在Lombardis的代码中,重写了makeMargherita的代码,所以永远调用的是Lombardis 中的 makeMargherita。

再进一步,我们把 protocol Pizzeria 中的 func makeMargherita() 删掉,代码变为

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
protocol Pizzeria {
 func makePizza(_ ingredients: [String])
}
 
extension Pizzeria {
 func makeMargherita() {
 return makePizza(["tomato", "mozzarella"])
 }
}
 
struct Lombardis: Pizzeria {
 func makePizza(_ ingredients: [String]) {
 print(ingredients)
 }
 func makeMargherita() {
 return makePizza(["tomato", "basil", "mozzarella"])
 }
}
 
let lombardis1: Pizzeria = Lombardis()
let lombardis2: Lombardis = Lombardis()
lombardis1.makeMargherita()
lombardis2.makeMargherita()

这时候打印出如下结果:

?
1
2
["tomato", "mozzarella"]
["tomato", "basil", "mozzarella"]

因为lombardis1 是 Pizzeria,而 makeMargherita() 有默认实现,这时候我们调用默认实现。

七、Swift 中定义常量和 Objective-C 中定义常量有什么区别?

一般人会觉得没有差别,因为写出来好像也确实没差别。

OC是这样定义常量的:

?
1
const int number = 0;

Swift 是这样定义常量的:

?
1
let number = 0

首先第一个区别,OC中用 const 来表示常量,而 Swift 中用 let 来判断是不是常量。

上面的区别更进一步说,OC中 const 表明的常量类型和数值是在 compilation time 时确定的;而 Swift 中 let 只是表明常量(只能赋值一次),其类型和值既可以是静态的,也可以是一个动态的计算方法,它们在 runtime 时确定的。

八、Swift 中 struct 和 class 什么区别?举个应用中的实例

struct 是值类型,class 是引用类型。

看过WWDC的人都知道,struct 是苹果推荐的,原因在于它在小数据模型传递和拷贝时比 class 要更安全,在多线程和网络请求时尤其好用。

我们来看一个简单的例子:

?
1
2
3
4
5
6
7
class A {
 var val = 1
}
 
var a = A()
var b = a
b.val = 2

此时 a 的 val 也被改成了 2,因为 a 和 b 都是引用类型,本质上它们指向同一内存。解决这个问题的方法就是使用 struct:

?
1
2
3
4
5
6
7
struct A {
 var val = 1
}
 
var a = A()
var b = a
b.val = 2

此时 A 是struct,值类型,b 和 a 是不同的东西,改变 b 对于 a 没有影响。

九、Swift 到底是面向对象还是函数式的编程语言?

Swift 既是面向对象的,又是函数式的编程语言。

说 Swift 是 Object-oriented,是因为 Swift 支持类的封装、继承、和多态,从这点上来看与 Java 这类纯面向对象的语言几乎毫无差别。

说 Swift 是函数式编程语言,是因为 Swift 支持 map, reduce, filter, flatmap 这类去除中间状态、数学函数式的方法,更加强调运算结果而不是中间过程。

总结

以上就是关于Swift面试题的全部内容了,希望本文的内容对大家的学习或者工作能带来一定的帮助,如果有疑问大家可以留言交流。

原文链接:http://www.jianshu.com/p/07c9c6464f83