Swift的面试问题及答案-part1

译文: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.None

请牢记,在底层下,optional是枚举类型:

enum Optional {
  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(array: Array) -> 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的文章什么的,欢迎关注

Swift的面试问题及答案-part1_第1张图片
qrcode_for_gh_e36203f1d8d6_258.jpg

你可能感兴趣的:(Swift的面试问题及答案-part1)