DevStore首页 > 文章 >文章详情

Swift面试题及答案(一)

fuli1024 | 2015-08-29 10:41    浏览量(1149)    评论(0)   推荐(0)

虽然swift才发布不到一年的时间,但它已经成为最流行的开发语言之一了。

事实上,Swift是一种复杂的语言,同时面向对象和面向函数,并且它仍然还在不断推出新的版本。

Swift有很多东西,但是你怎么能测试你学了多少?在这篇文章中,raywenderlich.com团队和我一起列了一个列表-有关swift的面试问题。

你可以用这些问题来测试面试者的Swift知识,或者测试你自己的!如果你不知道答案,不要担心,每一个问题都有一个答案。

问题分成了两部分:

1.笔试题目(Written questions):可以通过电子邮件来进行编程测试,需要写一些代码。

2.口头提问(Verbal questions):可以很好的在电话或面对面的面试中询问,适用于口头回答。

另外,每部分都分为三个等级:

·初级:适合初学者阅读,已经读过一两本有关Swift的书籍,并已经在自己的应用程序使用了Swift。

·中级:适合某些对语言有浓厚兴趣的人,阅读过很多有关Swift的博客文章,并想进一步进行尝试。

·高级:适合顶尖的-专注同时享受在程序语言里探索,挑战自己,并使用尖端技术的人。

如果你想试着回答这些问题,建议你打开Playground。所有答案都已经在Xcode 7 Beta 6中测试过。

准备好了吗?开始了!

一、Beginners(初级)

问题#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? = nilvar 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”。当闭包被声明的时候,capture list(捕获列表?)会创建一份拷贝,所以capture(捕获)的值不会改变,即使将一个新值赋值给一个。

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

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

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 UIKitlet 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 Foundationfunc ^^(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)
}

三个方法

答案:

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

本文为译文,原文:Swift Interview Questions and Answers

原文作者:Antonio Bello;译者:lfb_CD

  •   赞(0) 赞 +1 赞(0) 已赞
  •   收藏(0) 收藏 +1 已收藏 取消
  •   推荐上头条 推荐 +1 推荐上头条 已推荐
评论(0)

热门文章

暂时没有热门文章噢~