Swift面试题及答案

原文链接： Swift Interview Questions and Answers

译者：lfb_CD

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

0...4

0..<5

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

tutorial1.difficulty is 1,

tutorial2.difficulty is 2.

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

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

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

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) in return one < two }

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

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

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

let sortedAnimals = animals.sort(<)

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.address.fullAddress = "148 Tutorial Street"

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

其实没有区别。Optional.None（.None是缩写）是初始化一个可选变量(没有值)的正确写法，而不只是语法糖.None。

下面的验证代码的输出是true：

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

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)

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

它会打印“I love cars”。当闭包被声明的时候，capture list（捕获列表？）会创建一份拷贝，所以capture(捕获)的值不会改变，即使将一个新值赋值给一个。

如果在闭包中省略了capture list（捕获列表？），则编译器将使用一个引用而不是复制。在这种情况下，当被调用时该变量的任何变化都会产生变化。如下面的代码所示：

看不太懂就直接看代码吧= =

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

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

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!
}

guard let dividend = dividend else { return .None }

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
}

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

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

var thermometer: Thermometer = 56.8

创建一个新的自定义操作符需要两步：声明和实现。

这部分我不太会翻译，是关于自定义操作符的，这里有Swift的相关资料（ http://www.yiibai.com/swift/custom_operators.html）

这是声明：

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

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)
}

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

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

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

都能。Pizzeria协议声明makemargherita()方法提供了一个默认的实现。该方法是在lombardis实现重写。在这两种情况下声明的方法，在运行时都能正确执行。

如果协议没有声明makemargherita()方法，但在扩展中还提供了一个默认的实现呢？

struct Kitten {
} 
func showKitten(kitten: Kitten?) {
  guard let k = kitten else {
    print("There is no kitten")
  }
  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)

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

有一个正在进行的讨论，关于过度使用类超过结构体这究竟是好还是坏。

函数式编程倾向于多使用值数据类型，而面向对象编程更倾向于使用类。

在Swift中，类和结构体有很多不同的特性。可以得出下面这样一份总结：

更多关于类和结构体的细节问题请查阅这篇文章：

detailed post on the matter. (我们还在翻译中..)

func areTheyEqual<T: Equatable>(x: T, _ y: T) -> Bool {
  return x == y
}
areTheyEqual("ray", "ray")
areTheyEqual(1, 1)

1. 不为nil的才能初始化它的值。一个典型的例子是一个界面生成器的出口(Interface Builder outlet)，它总是在它的本体初始化后初始化。在这种情况下，如果它在界面构建器(Interface Builder)中正确地配置了，就能够保证在使用前outlet不为nil的。

class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) {
        self.name = name
    }
    deinit { print("/(name) is being deinitialized") }
}
class CreditCard {
    let number: UInt64
    unowned let customer: Customer
    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("Card #/(number) is being deinitialized") }
}

当Swift作为一种面向函数的语言来理解时，会有不同却相似的方式来定义它。

其中一种是较为常见的维基百科上的：”…a programming paradigm […] that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data.”

“……编程范式[……]，将数学函数作为一种值，不需要考虑其中的状态变化和数据变化。”

const int number = 0;

let number = 0

struct Sun {
  static func illuminate() {}
}

当用在类里的时候，static相当于class final

比如在下面这段代码中你如果覆盖 illuminate() 编译器就会报错

enum Either<T, V> {
  case Left(T)
  case Right(V)
}

class Box<T> {
  let value: T
  init(_ value: T) {
    self.value = value
  }
} 
enum Either<T, V> {
  case Left(Box<T>)
  case Right(Box<V>)
}

init(_ value: Int)

let myNegative = UInt(-1)

enum List<T> {
    case Node(T, List<T>)
}