前言
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 = tailtail.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 = ab.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 = ab.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
