硅谷的 Swift 面試題
1. 給一個數組，要求寫一個函數，交換數組中的兩個元素
-
二X程序員：
好簡單啊，直接寫出以下結果
func swap(_ nums: inout [Int], _ p: Int, _ q: Int) {
let temp = nums[p]
nums[p] = nums[q]
nums[q] = temp
}
-
普通程序員：
首先跟面試官溝通，是什么類型的數組？面試官會說，任意。普通程序員微微一笑，寫出以下代碼
func swap<T>(_ nums: inout [T], _ p: Int, _ q: Int) {
let temp = nums[p]
nums[p] = nums[q]
nums[q] = temp
}
-
文藝程序員：
與面試官溝通，是什么類型的數組？有什么其他要求和限制？面試官會說，這是一個Swift面試題。文藝程序員心領神會，于是寫出以下答案
func swap<T>(_ nums: inout [T], _ p: Int, _ q: Int) {
(nums[p], nums[q]) = (nums[q], nums[p])
}
同時對以上代碼寫上相應測試，檢測各種邊界情況，再確認無誤后，才會說，這道題目我完成了。
這道題目看似簡單，實際上考察了程序員的審題、交流、以及測試的意識。技術上考察了Swift的泛型和Tuple的性質。
2. 下面代碼有什么問題
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。
原因：表面上看，以上代碼毫無問題。但是我這樣一寫，問題就來了：
let head = Node(0)
let tail = Node(1)
head.post = tail
tail.prev = head
此時，head 和 tail 互相指向，形成循環引用（retain cycle）。
3. 實現一個函數，輸入是任一整數，輸出要返回輸入的整數 + 2
這道題很多人上來就這樣寫：
func addTwo(_ num: Int) -> Int {
return num + 2
}
接下來面試官會說，那假如我要實現 + 4 呢？程序員想了一想，又定義了另一個方法：
func addFour(_ num: Int) -> Int {
return num + 4
}
這時面試官會問，假如我要實現返回 + 6, + 8 的操作呢？能不能只定義一次方法呢？正確的寫法是利用 Swift 的柯西特性：
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)
4. 精簡以下代碼
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，最佳答案是
func divide(dividend: Double?, by divisor: Double?) -> Double? {
guard let dividend = dividend, let divisor = divisor, divisor != 0 else {
return nil
}
return dividend / divisor
}
5. 以下函數會打印出什么？
var car = "Benz"
let closure = { [car] in
print("I drive \(car)")
}
car = "Tesla"
closure()
因為 clousre 已經申明將 car 復制進去了（[car]），此時clousre 里的 car 是個局部變量，不再與外面的 car有關，所以會打印出"I drive Benz"。
此時面試官微微一笑，將題目略作修改如下：
var car = "Benz"
let closure = {
print("I drive \(car)")
}
car = "Tesla"
closure()
此時 closure 沒有申明復制拷貝 car，所以clousre 用的還是全局的 car 變量，此時將會打印出 "I drive Tesla"
6. 以下代碼會打印出什么？
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()
答案：打印出如下兩行
["tomato", "basil", "mozzarella"]
["tomato", "basil", "mozzarella"]
在Lombardis的代碼中，重寫了makeMargherita的代碼，所以永遠調用的是Lombardis 中的 makeMargherita。
再進一步，我們把 protocol Pizzeria 中的 func makeMargherita() 刪掉，代碼變為
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()
這時候打印出如下結果：
["tomato", "mozzarella"]
["tomato", "basil", "mozzarella"]
因為lombardis1 是 Pizzeria，而 makeMargherita() 有默認實現，這時候我們調用默認實現。
7. Swift 中定義常量和 Objective-C 中定義常量有什么區別？
一般人會覺得沒有差別，因為寫出來好像也確實沒差別。
OC是這樣定義常量的：
const int number = 0;
Swift 是這樣定義常量的：
let number = 0
首先第一個區別，OC中用 const 來表示常量，而 Swift 中用 let 來判斷是不是常量。
上面的區別更進一步說，OC中 const 表明的常量類型和數值是在 compilation time 時確定的；而 Swift 中 let 只是表明常量（只能賦值一次），其類型和值既可以是靜態的，也可以是一個動態的計算方法，它們在 runtime 時確定的。
8. Swift 中 struct 和 class 什么區別？舉個應用中的實例
struct 是值類型，class 是引用類型。
看過WWDC的人都知道，struct 是蘋果推薦的，原因在于它在小數據模型傳遞和拷貝時比 class 要更安全，在多線程和網絡請求時尤其好用。我們來看一個簡單的例子：
class A {
var val = 1
}
var a = A()
var b = a
b.val = 2
此時 a 的 val 也被改成了 2，因為 a 和 b 都是引用類型，本質上它們指向同一內存。解決這個問題的方法就是使用 struct：
struct A {
var val = 1
}
var a = A()
var b = a
b.val = 2
此時 A 是struct，值類型，b 和 a 是不同的東西，改變 b 對于 a 沒有影響。
9. Swift 到底是面向對象還是函數式的編程語言？
Swift 既是面向對象的，又是函數式的編程語言。
說 Swift 是 Object-oriented，是因為 Swift 支持類的封裝、繼承、和多態，從這點上來看與 Java 這類純面向對象的語言幾乎毫無差別。
說 Swift 是函數式編程語言，是因為 Swift 支持 map, reduce, filter, flatmap 這類去除中間狀態、數學函數式的方法，更加強調運算結果而不是中間過程。
來自：http://www.jianshu.com/p/07c9c6464f83