译文：Swift Interview Questions and Answers

Swift面试问题及答案

原文链接 : Swift Interview Questions and Answers
译文发布地址：
part1: http://www.jianshu.com/p/e98d7dc625ff
part2:http://www.jianshu.com/p/0b9bdffc2523
原文作者 : Antonio Bello
译者 : lfb_CD 欢迎关注我的微博哟：http://weibo.com/lfbWb

虽然swift才发布不到一年的时间，但它已经成为最流行的开发语言之一了。
事实上，Swift，是一种复杂的语言，同时面向对象和面向函数，并且它仍然还在不断推出新的版本。

Swift有很多东西，但是你怎么能测试你学了多少？在这篇文章中，raywenderlich.com团队和我一起列了一个列表-有关swift的面试问题。
你可以用这些问题来测试面试者的Swift知识，或者测试你自己的！如果你不知道答案，不要担心，每一个问题都有一个答案。

问题分成了两部分：

1.笔试题目(Written questions)：可以通过电子邮件来进行编程测试，需要写一些代码。
2.口头提问(Verbal questions)：可以很好的在电话或面对面的面试中询问，适用于口头回答。

另外，每部分都分为三个等级：

• 初级：适合初学者阅读，已经读过一两本有关Swift的书籍，并已经在自己的应用程序使用了Swift。
• 中级：适合某些对语言有浓厚兴趣的人，阅读过很多有关Swift的博客文章，并想进一步进行尝试。
• 高级：适合顶尖的-专注同时享受在程序语言里探索，挑战自己，并使用尖端技术的人。

如果你想试着回答这些问题，建议你打开Playground。所有答案都已经在Xcode 7 Beta 6中测试过。
准备好了吗？Buckle up（系好安全带？），开始了！

注：特别感谢团队成员 Warren Burton, Greg Heo, Mikael Konutgan, Tim Mitra, Luke Parham, Rui Peres, and Ray Wenderlich

Written Questions（书面的问题）

Beginners（初学者）

你好，padowan（应该是指学徒，也就是我们。。）。我将开始检测你的基本知识。

问题#1-Swift 1.0 or later

想有一个更好的方式来写这里的循环范围？

for var i = 0; i < 5; i++ {
    print("Hello!")
}

答案：

for i in 0...4 {
  print("Hello!")
}

Swift实现了二元操作符、闭区间操作符(...)和半闭区间操作符(..<)。第一个的范围(...)包括所有的值。例如，下面包含所有的整数，从0到4：

0...4

半闭区间操作符(..<)不包含最后一个元素。以下产生相同的0至4整数的结果：

0..<5

问题#2-Swift 1.0 or later

思考如下代码：

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

tutorial1.difficulty和tutorial2.difficulty的值是什么呢？如果是一个类，又是什么呢？为什么？

答案：

tutorial1.difficulty is 1,
tutorial2.difficulty is 2.
Swift的struct是值类型，它们被复制的是值，而不是引用。下面的代码是创建一份tutorial1的拷贝并将其分配到tutorial2：

var tutorial2 = tutorial1

从这段代码开始，对tutorial2任何改变都不会影响到tutorial1。
如果Tutorial是类，tutorial1.difficulty和tutorial2.difficulty都会是2。Swift的类是引用类型。对tutorial1属性的任何变化会反映到tutorial2，反之亦然。

问题#3-Swift 1.0 or later

view1是用var声明的，而view2是用let声明的。这里的区别是什么，最后一行又可以编译通过么？

import UIKit
var view1 = UIView()
view1.alpha = 0.5
let view2 = UIView()
view2.alpha = 0.5 // Will this line compile?

答案：

view1是一个变量，可以被重新分配到一个新的UIView的实例。用let你只可以赋值一次，所以这段的代码不能编译通过：

view2 = view1 // Error: view2 is immutable

但是，UIView是一个类的引用，所以你可以改变View2属性（这意味着最后一行可以编译通过）：

let view2 = UIView()
view2.alpha = 0.5 // Yes!

问题#4-Swift 1.0 or later

下面这段代码将数组按字母进行了排序，看起来很复杂，请尽可能的简化它。

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

答案：

先简化参数。类型推导系统可以自动计算出闭包中的参数类型，所以我们可以去掉参数：

let sortedAnimals = animals.sort { (one, two) -> Bool in return one < two }

返回值的类型也可以被推断，所以扔掉它：

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

符号$i可以代替参数名称：

let sortedAnimals = animals.sort { return $0 < $1 }

在单语句闭包中，返回关键字可以省略。最后一个语句的返回值就是闭包的返回值：

let sortedAnimals = animals.sort { $0 < $1 }

这已经很简单了，但还不够，不要停！
对于字符串，有一个比较函数定义如下：

func <(lhs: String, rhs: String) -> Bool

这个小功能使你的代码更整洁：

let sortedAnimals = animals.sort(<)

注意，这里的每一步都是能编译和输出相同的结果的，并且你做了一个字符的闭包！

问题#5-Swift 1.0 or later

这段代码创建了2个类、Address和Person，并且创建了2个实例来表示Ray和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)

假设brian搬到街对面的新大楼，所以你更新了他的地址：

brian.address.fullAddress = "148 Tutorial Street"

但是，仔细想一下这儿有什么问题，发生了什么？这是怎么回事？

答案：

Ray的address.fullAddress也跟着改变了！Address是一个类，并且具有引用的语义。headquarters是同一个实例，无论您访问它通过Ray或Brian，改变headquarters的Address将改变它的两个。
解决方案是重新分配给Brian一个新的Address，或设置Address为struct而不是class。

Intermediate（中级）

现在，开始挑战困难点的问题。你准备好了吗？

问题#1-Swift 2.0 or later

思考下列代码：

var optional1: String? = nil
var optional2: String? = .None

nil和.None有什么区别？optional1和optional1变量有何不同？

答案：

其实没有区别。Optional.None（.None是缩写）是初始化一个可选变量(没有值)的正确写法，而不只是语法糖.None。
下面的验证代码的输出是true：

nil == .None // On Swift 1.x this doesn't compile. You need Optional<Int>.None

请牢记，在底层下，optional是枚举类型：

enum Optional<T> {
  case None
  case Some(T)
}

问题#2-Swift 1.0 or later

这是温度计的模型，一个class和一个struct：

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)

这段代码编译出错，请问哪里错了？为什么错了？

提示：仔细阅读并思考一下，在Playground上测试它。

答案：

编译器会在最后一行报错。正确的thermometerstruct声明与变异函数来改变其内部的温度变化，但编译器报错是因为registertemperature创建实例是通过let的，因此它是不变的。
在结构体中，函数改变内部状态必须得是可变数据类型，即用var声明的。

问题#3-Swift 1.0 or later

下面这段代码会print出什么？为什么？

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

答案：

它会打印“I love cars”。当闭包被声明的时候，参数列表也会创建一份拷贝，所以参数的值不会改变，即使将一个新值赋值给一个。
如果在闭包中省略了参数列表([thing])，则编译器将使用一个引用而不是复制。在这种情况下，当被调用时该变量的任何变化都会产生变化。如下面的代码所示：
看不太懂就直接看代码吧= =

var thing = "cars"
let closure = {    
  print("I love \\(thing)")
}
thing = "airplanes"
closure() // Prints "I love airplanes"

问题#4-Swift 2.0 or later

这里有一个全局函数来计算数组中 “值是唯一” 的数目：

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

你可以这样使用这个方法：

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

请把这个函数重写为数组的扩展方法，使得你可以按照下面代码那样使用：

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

答案：

在Swift2.0中，泛型可以通过强制类型约束来进行扩展。如果泛型不满足约束，则该扩展既不可见也不可访问。

extension Array where Element: Comparable {
  func countUniques() -> Int {
    let sorted = sort(<)
    let initial: (Element?, Int) = (.None, 0)
    let reduced = sorted.reduce(initial) { ($1, $0.0 == $1 ? $0.1 : $0.1 + 1) }
    return reduced.1
  }
}

注意新方法只有在当前的数据类型实现了Comparable的协议时才可用。比如，如果你这样调用的话编译器会报错：

import UIKit
let a = [UIView(), UIView()]
a.countUniques() // compiler error here because UIView doesn't implement Comparable

问题#5-Swift 2.0 or later

这里有一个函数来计算给定的两个double的可选数据类型的除法。在执行除法之前，需要满足三个条件：

• dividend不为空
• divisor不为空
• divisor不为0

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

代码虽然能工作，但有2个问题：

• 它的条件可以guard语句
• 它使用了强制拆包(那个!)不安全

请使用guard语句改进这个函数，避免使用强制拆包。

答案：

如果条件不符合，新的guard语句在Swift2.0提供了返回值。检查条件是非常有用的，因为它提供了一个清晰的方式表达方式--如果不需要对语句进行嵌套的话。这里就是一个例子：

guard dividend != .None else { return .None }

也可以结合可选数据类型，使得访问变量在guard检查之后：

guard let dividend = dividend else { return .None }

所以divide函数可以这样写：

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

另外，你还可以合并guard语句，使函数看起来更简单：

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

Advanced（高级）

问题#1-Swift 1.0 or later

思考下面的结构体，一个温度计的模型：

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

创建一个实例，可以很容易地使用这个代码：

var t: Thermometer = Thermometer(temperature:56.8)

但它有更好地初始化方式：

var thermometer: Thermometer = 56.8

怎么实现？

答案：

Swift定义了下面的协议，使用赋值操作符将一个类型的类型进行初始化：

• NilLiteralConvertible
• BooleanLiteralConvertible
• IntegerLiteralConvertible
• FloatLiteralConvertible
• UnicodeScalarLiteralConvertible
• ExtendedGraphemeClusterLiteralConvertible
• StringLiteralConvertible
• ArrayLiteralConvertible
• DictionaryLiteralConvertible
  采用相应的协议，提供一个公共的初始化方法用来实现特定类型的文字初始化。在Thermometer下，实现FloatLiteralConvertible协议如下：

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

现在你可以用一个简单的浮点数据来创建一个实例。

var thermometer: Thermometer = 56.8

问题#2-Swift 1.0 or later

Swift拥有一组预定义的运算符，执行不同类型的操作，例如算术或逻辑。它还允许创建自定义操作，一元或二元。

按照以下要求自定义并实现一个 ^^ 幂运算符：

• 以两个整数作为参数
• 返回第一个参数与第二个参数的幂运算
• 不用考虑潜在溢出错误

答案：

创建一个新的自定义操作符需要两步：声明和实现。
这部分我不太会翻译，是关于自定义操作符的，这里有Swift的相关资料（http://www.yiibai.com/swift/custom_operators.html）
这是声明：

infix operator ^^ { associativity left precedence 155 }

实现的代码如下：

import Foundation
func ^^(lhs: Int, rhs: Int) -> Int {
  let l = Double(lhs)
  let r = Double(rhs)
  let p = pow(l, r)
  return Int(p)
}

请注意，它没有考虑溢出情况；如果操作产生的结果不能用int代表。比如大于int.max，会发生运行时错误。

问题#3-Swift 1.0 or later

你能用这样的原始值来定义一个枚举吗？为什么？

enum Edges : (Double, Double) {
  case TopLeft = (0.0, 0.0)
  case TopRight = (1.0, 0.0)
  case BottomLeft = (0.0, 1.0)
  case BottomRight = (1.0, 1.0)
}

答案：

不能。一个原始值类型必须：

• 符合合理的协议
• 从下列任一个类型中转换的：
  • Int
  • String
  • Character

在上面的代码中，原始类型是一个元组，是不符合条件的。

问题#4-Swift 1.0 or later

考虑下面的代码定义的Pizza结构体和Pizza协议，以及扩展，包含有makemargherita()默认实现的一个方法：

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

现在餐厅Lombardis 的定义如下：

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

下面的代码创建两个Lombardis的实例。哪一个会成功调用margherita做出basil（一种面）？

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

答案：

都能。Pizzeria协议声明makemargherita()方法提供了一个默认的实现。该方法是在lombardis实现重写。在这两种情况下声明的方法，在运行时都能正确执行。
如果协议没有声明makemargherita()方法，但在扩展中还提供了一个默认的实现呢？

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

在这种情况下，只有lombardis2做出Pizza，而lombardis1没有做出Pizza，因为lombardis1会去使用在扩展中定义的makeMargherita方法方法。它没有声明makeMargherita方法，就不会去调用结构体里面的那个makeMargherita方法。

问题#5-Swift 2.0 or later

以下代码编译时有错误。你能发现哪里出错了么，为什么会发生错误？

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

Hint: There are three ways to fix it.

答案：

else里面需要退出路径，使用return，或者抛出一个异常或声明这是一个@noreturn的方法。最简单的解决方案是添加返回语句。

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

添加抛出异常的方法。

enum KittenError: ErrorType {
  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(nil)

最后一个方法，调用fatalerror()方法，表明这是一个@noreturn方法。

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

Verbal questions part2部分待译。

第一次翻译这么长的文章，也许会有翻译错误的地方，大家可以在评论中帮忙指出。

另外，我在管理一个微信公众号SwiftTips，每天发布一些Swift的文章什么的，欢迎关注

qrcode_for_gh_e36203f1d8d6_258.jpg