Swift 面试题及其答案

思而思学网

虽然Swift出生才一年,但是它已经成为最流行的编程语言之一了。它的语法很简单,以至于当它发布的时候,java script开发者感觉就像下图一样。

事实上,Swift是一种复杂的语言。它包含面向对象和函数方法这两个方面,并且随着新版本的发布在一直进化。

你可以用这些问题来测试应聘者关于Swift方面的知识水平,或者测试一下你自己。如果你不知道答案,没关系,没一个问题下面都有答案供你学习。

这些问题包含两个方面:

笔试问题:通过电子邮件做一个编程测试是极好的,因为这涉及到写大量的代码,从代码质量上可以看出一个人的水平。

面试问题:电话面试或者面对面面试也是很好的,因为对面试者来说口头交流会更方面。

每个方面有分成三个等级:

初级:适合读了一到两本有关Swift的书,并且已经开始用Swift开发应用程序的初学者。

中级:适合那些对Swift语言的概念有深刻理解和强烈兴趣的,并且一直在阅读大量有关Swift的博客文章并进行实践的中级工程师。

高级:适合那些以探索Swift语言知识为乐趣,挑战自己,使用前言技术的人们。

假如你想回答这些问题,我建议你在回答这些问题之前,打开Playground运行一下这些问题的代码。这些问题的答案都在Xcode 7.0 Beta 6 版本中测试过。

准备好了吗?系好安全带,现在就开始!

笔试问题

初学者

问题1、(Swift 1.0及其之后的版本的问题)有什么更好的方法来写下面的for循环?

for var i = 0; i < 5; i++ {

print("Hello!")

}

答案:

for _ in 0...4 {

print("Hello!")

}

Swift 实现了两个数组运算符closed operator 和 half-operator.前者包含数组中得所有值。例如:下面的例子包含从0到4得所有整数

0...4

half-operator不包含数组中的最后一个元素,下面的例子会得到的结果和上面的一样:

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的值分别是多少?假如Tutorial是一个类,会有什么不同?并说明原因。

答案:tutorial1.difficulty 的值是1,然而tutorial2.difficulty的值是2.

在Swift中结构体是值类型,他们的值是复制的而不是引用的。下面的一行代码意思是复制了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 }

在一个独立的闭包内,return这个关键字是可以省略的。最后声明的返回值就是闭包的返回值:

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

这简化很多了,但是我们不能止步于此!

对于字符串,有一个定义如下的比较函数:

func Bool

这个简单的小函数可以使你的代码简洁如下:

let sortedAnimals = animals.sort(<)

注意每一步的编译结果都相同,但是最后一步你的闭包里只有一个字符。

问题5 – Swift 1.0 or later

下面的代码创建了两个类Address和Person,并且创建了两个实例对象分别代表Ray和Brain.

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)

假设Brain搬家到街对面的建筑物里,那么你会这样更新他的地址:

brian.address.fullAddress = "148 Tutorial Street"

这样做将会发生什么?错误出在什么地方呢?

答案:Ray同样会搬家到新的建筑物里面。Address是一个引用类型类,所以无论你是通过ray或者brain访问headquarters,访问都是同一个实例化对象。headquarters对象的变化也会引起ray和brain的变化。你能想象如果Brain收到Ray的邮件或者相反Ray收到Brain的邮件,将会发生什么?解决方案是创建一个新的Address对象赋值给Brain或者把Address声明成为结构体而不是一个类。

中级

问题1– Swift 2.0 or later

思考下面的代码:

var optional1: String? = nil

var optional2: String? = .None

答案:两者没有什么不同。Optional.None(简称.None)是optional变量值初始化的标准方法,而nil只是.None语法的一种修饰。事实上下面语句输出是正确的:

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

.None

记住枚举类型的Optional下的None:

enum Optional{

case None

case Some(T)

}

问题2-Swift 1.0 or later

下面是thermometer作为类和结构体的例子:

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结构体中正确的声明了一个mutating属性函数,它是用来改变结构体内部temperature属性的值的,但是编译器不通过的原因是,通过let创建的不可变的registerTemperature结构体调用了registerTemperature函数。

问题3– Swift 1.0 or later

下面的代码输出是什么?并说明理由。

var thing = "cars"

let closure = { [thing] in

print("I love \(thing)")

}

thing = "airplanes"

closure()

答案:输出的是:I love cars。当闭包被声明的时候,抓捕列表就复制一份thing变量,所以被捕捉的值并没有改变,即使你给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

}

它使用了< 和==运算符,他们限制着T(占位类型)的实际类型,也就是说T必须遵循Comparable协议。你可以这样使用它:

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

现在要求你重写上面的方法作为Array的扩展方法,然后你就可以这样写代码:

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

如何实现?

答案:在Swift 2.0 中,泛类型可以使用类型约束条件被强制扩展。但是假如这个泛类型不满足这个类型的约束条件,那么这个扩展方法既不可见也无法调用。

所以countUniques全局函数可以作为Array的扩展方法被重写如下:

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协议新的方法才可以被使用。例如,如果你在全部是UIView对象的数组中调用countUniques,编译器将会报错。

import UIKit

let a = [UIView(), UIView()]

a.countUniques() // compiler error here because UIView doesn't implement Comparable

问题5- Swift 2.0 or later

下面一个函数的功能是计算两个double(optional)类型的数的相除的结果。在执行除法之前,必须提前满足三个条件:

被除数必须包含nil值

除数必须为包含nil值

除数不能为零

func pide(pidend: Double?, by pisor: Double?) -> Double? {

if pidend == .None {

return .None

}

if pisor == .None {

return .None

}

if pisor == 0 {

return .None

}

return pidend! / pisor!

}

上面的函数可以正常使用,但是会存在两个问题:


热门推荐

最新文章