【面试必备】swiftamp;nbsp;面试题及其答案 -尊龙游戏旗舰厅官网

• 原文：swift interview questions and answers
  

• 原作者：antonio bello

• 原作者介绍: antonio 拥有丰富的编程经验。他开始编程的时候，内存单位还是 byte 而不是 gigabyte，存储空间还是可选的附加物，最常用的语言还是basic。现在，antonio 的兴趣在于 ios 应用开发、node.js 后端开发，而且他从来不会放过学习新东西的机会。他认为 swift 是一门很有表现力的语言，不过 objective-c 仍然是伟大而不同寻常的。

• 译者：本文由cocoachina译者 浅夏@旧时光 翻译

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

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

swift的知识浩如烟海——但是怎么测试你掌握了多少？在这篇文章中，我和这个raywenderlich.com网站的教学团队共同写了一个swift面试问题列表。

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

这些问题包含两个方面：

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

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

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

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

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

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

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

准备好了吗？系好安全带，现在就开始！

编者注：特别感谢raywenderlich.com教学团队成员warren burton, greg heo, mikael konutgan, tim mitra, luke parham, rui peres, 和 ray wenderlich ，他们帮我相处了下面问题中得一些，并且测试区分难度级别。

笔试问题

初学者

问题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 uikitvar view1 = uiview() view1.alpha = 0.5let 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 inreturn 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: stringvar city: stringinit(fulladdress: string, city: string) {self.fulladdress = fulladdressself.city = city} }class person {var name: stringvar address: addressinit(name: string, address: address) {self.name = nameself.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

nil 和 .none有什么不同？optional1和optional2有什么不同？

答案：两者没有什么不同。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 nonecase some(t) }

问题2-swift 1.0 or later

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

public class thermometerclass {private(set) var temperature: double = 0.0public func registertemperature(temperature: double) {self.temperature = temperature} }let thermometerclass = thermometerclass() thermometerclass.registertemperature(56.0)public struct thermometerstruct {private(set) var temperature: double = 0.0public 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] inprint("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 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语句。

使用了强制拆包。

请使用guard语句和避免使用强制拆包来优化这个函数。

答案：guard语句是在swift 2.0中引进的，它是用途是在未满足某个条件时，提供一个退出的路径。对于检查是否满足先决条件来说，它是非常有用的。因为它可以使你更清晰的表达逻辑——而不是像i各种f语句嵌套实现那么复杂。下面就是一个例子：

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

它也可以在optional binding（可选绑定）中使用。使用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 }

我们发现隐身的可拆包的运算在代码的最后一行，因为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 }

上面的函数中使用了两个guard语句，因为使用了where语句指定了divisor不能为0的条件。

高级

问题1- swift 1.0 or later

下面是thermometer作为结构体的例子：

public struct thermometer {public var temperature: doublepublic init(temperature: double) {self.temperature = temperature} }

创建一个thermometer实例对象，你可以使用下面的代码：

var t: thermometer = thermometer(temperature:56.8)

但是像下面的代码那样初始化对象是否会更好：

var thermometer: thermometer = 56.8

能这样做吗？如果可以，怎么做？提示：it has to do with convertibles, but not convertibles like camaros and mustangs

答案：swift 定义了下面的协议，这些协议可以使一种类型通过字面量的方式来初始化并赋值。

nilliteralconvertible booleanliteralconvertible integerliteralconvertible floatliteralconvertible unicodescalarliteralconvertible extendedgraphemeclusterliteralconvertible stringliteralconvertible arrayliteralconvertible dictionaryliteralconvertible

采用相应的协议并且提供一个允许字面量初始化的公用方法。在thermometer类型的例子下，我们需要实现floatliteralconvertible协议，代码如下：

extension thermometer : floatliteralconvertible {public init(floatliteral value: floatliteraltype) {self.init(temperature: value)} }

那么现在，你就可以通过一个简单的float数字创建一thermometer对象，代码如下：

var thermometer: thermometer = 56.8

问题2 - swift 1.0 or later

swift 拥有一系列预定义的运算符，这些运算符执行不同类型的操作，例如算术运算符和逻辑运算符。它甚至允许创建自定义的运算符，无论是一元运算符还是二元运算符。自定义一个满足一下规格的幂运算符：

以两个整数作为参数

返回第一个参数的第二个参数次方的值

忽略潜在溢出错误

答案：创建一个自定义的运算符需要两个步骤：声明它和实现它。

使用operator关键字来声明指定的类型（一元或者二元）、组成这个运算符字符的顺序已经它的优先级和关联性。

在这中情况下，运算符是^^,类型是infix（二进制），关联性是right，优先级设置成为155，原因是乘法和除法的优先级是150.下面就是具体的声明代码：

infix operator ^^ { associativity right precedence 155 }

代码实现如下：

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

答案：不行。原始值得类型必须满足一下条件

遵守equatable协议

满足能转换成下列类型中的任何一个类型：    

a.intb.stringc. character

在上面的代码中，原始值即使是独立的个体值，但是它仍然是一个不兼容的元组。 

问题4- swift 2.0 or later

下面的代码定义了一个结构体pizza和一个协议pizzeria，这个协议有一个包含makemargherita()函数的扩展。

struct pizza {let ingredients: [string] }protocol pizzeria {func makepizza(ingredients: [string]) -> pizzafunc makemargherita() -> pizza }extension pizzeria {func makemargherita() -> pizza {return makepizza(["tomato", "mozzarella"])} }

现在你将要定义一个如下的lombardi的餐馆：

struct lombardis: pizzeria {func makepizza(ingredients: [string]) -> pizza {return pizza(ingredients: ingredients)}func makemargherita() -> pizza {return makepizza(["tomato", "basil", "mozzarella"])} }

下面的代码创建了lombardis类型的两个实例对象，哪一个对象会产生一个带有basil的margherita披萨？

let lombardis1: pizzeria = lombardis() let lombardis2: lombardis = lombardis()lombardis1.makemargherita() lombardis2.makemargherita()

答案：两个都可以。pizzeria协议声明了makemargherita()方法并且提供了一个默认的实现，而且它又在lombardis的实现中被重写。在这两种情况下，由于这个方法在协议中被声明，那么在运行时相应的实现就会被调用。

假如pizzeria协议没有声明makemargherita()方法，但是扩展中仍然提供了如下的代码的这个方法默认的实现，会发生什么？

protocol pizzeria {func makepizza(ingredients: [string]) -> pizza }extension pizzeria {func makemargherita() -> pizza {return makepizza(["tomato", "mozzarella"])} }

这种情况下，只有lombardis2会产生一个带有basil的pizza,而lombardis1将会产生一个不带basil的pizza，原因是它会调用扩展中定义的那个方法。

问题5- swift 2.0 or later

下面的代码有一个编译错误，请指出来并说明原因。

struct kitten { }func showkitten(kitten: kitten?) {guard let k = kitten else {print("there is no kitten")}print(k) }

提示：有三种方法修复它。

答案：guard语句中得else语句必须需要一个返回路径，你可以使用return ,抛出异常或者调用@noreturn.最简单的解决方法是添加一个return语句，代码如下：

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)

最后，调用一个@noreturn功能函数 fatalerror( ) 尊龙游戏旗舰厅官网的解决方案：

struct kitten { }func showkitten(kitten: kitten?) {guard let k = kitten else {print("there is no kitten")fatalerror()}print(k) }

面试试题

你很棒，但是你还没达到绝地武士的要求。任何人都可以写出代码，但是你如何处理理论和实践相结合的开放式问题？

为了解决这些问题，你仍然需要使用playgroud写代码来验证一些问题。

初级

问题1- swift 1.0 or later

什么是optional类型，它是用来解决什么问题的？

答案：optional类型被用来表示任何类型的变量都可以表示缺少值。在objective-c中，引用类型的变量是可以缺少值得，并且使用nil作为缺少值。基本的数据类型如int 或者float没有这种功能。

swift用optional扩展了在基本数据类型和引用类型中缺少值的概念。一个optional类型的变量，在任何时候都可以保存一个值或者为nil。

问题2- swift 1.0 or later

在swfit中,什么时候用结构体，什么时候用类？

答案：一直都有这样的争论：到底是用类的做法优于用结构体，还是用结构体的做法优于类。函数式编程倾向于值类型，面向对象编程更喜欢类。

在swift 中，类和结构体有许多不同的特性。下面是两者不同的总结：

类支持继承，结构体不支持。

类是引用类型，结构体是值类型

并没有通用的规则决定结构体和类哪一个更好用。一般的建议是使用最小的工具来完成你的目标，但是有一个好的经验是多使用结构体，除非你用了继承和引用语义。

想要了解更多，点击这里。

注意：在运行时，结构体的在性能方面更优于类，原因是结构体的方法调用是静态绑定，而类的方法调用是动态实现的。这就是尽可能得使用结构体代替类的又一个好的原因。

问题3- swift 1.0 or later

什么是泛型？泛型是用来解决什么问题的？

答案：泛型是用来使类型和算法安全的工作的一种类型。在swift中，在函数和数据结构中都可以使用泛型，例如类、结构体和枚举。

泛型一般是用来解决代码复用的问题。常见的一种情况是，你有一个函数，它带有一个参数，参数类型是a，然而当参数类型改变成b的时候，你不得不复制这个函数。

例如，下面的代码中第二个函数就是复制第一个函数——它仅仅是用string类型代替了integer类型。

func areintequal(x: int, _ y: int) -> bool {return x == y }func arestringsequal(x: string, _ y: string) -> bool {return x == y }arestringsequal("ray", "ray") // true areintequal(1, 1) // true

objective-c开发人员可能想到用nsobject类来解决这个问题，代码如下：

import foundationfunc aretheyequal(x: nsobject, _ y: nsobject) -> bool {return x == y }aretheyequal("ray", "ray") // true aretheyequal(1, 1) // true

这个代码会按照预期的方式工作,但是它在编译时不安全。它允许字符串和整数相比较,像这样:

aretheyequal(1, "ray")

应用程序不会崩溃,但是允许字符串和整数相比较可能不是预想的结果。

通过采用泛型,可以合并这两个函数为一个并同时保持类型安全。下面是代码实现:

func aretheyequal(x: t, _ y: t) -> bool {return x == y }aretheyequal("ray", "ray") aretheyequal(1, 1)

上面的例子是测试两个参数是否相等，这两个参数的类型受到约束都必须遵循equatable协议。上面的代码达到预想的结果,并且防止了传递不同类型的参数。

问题4- swift 1.0 or later

哪些情况下你不得不使用隐式拆包？说明原因。

答案：对optional变量使用隐式拆包最常见的原因如下：

1、对象属性在初始化的时候不能nil,否则不能被初始化。典型的例子是interface builder outlet类型的属性，它总是在它的拥有者初始化之后再初始化。在这种特定的情况下，假设它在interface builder中被正确的配置——outlet被使用之前，保证它不为nil。

2、解决强引用的循环问题——当两个实例对象相互引用，并且对引用的实例对象的值要求不能为nil时候。在这种情况下，引用的一方可以标记为unowned,另一方使用隐式拆包。

建议：除非必要，不要对option类型使用隐式拆包。使用不当会增加运行时崩溃的可能性。在某些情况下,崩溃可能是有意的行为,但有更好的方法来达到相同的结果,例如,通过使用fatalerror( )函数。

问题5- swift 1.0 or later

对一个optional变量拆包有多少种方法？并在安全方面进行评价。

答案：  

• 强制拆包 ！操作符——不安全

• 隐式拆包变量声明——大多数情况下不安全

• 可选绑定——安全

• 自判断链接（optional chaining）——安全

• nil coalescing 运算符（空值合并运算符）——安全

• swift 2.0 的新特性 guard 语句——安全

• swift 2.0 的新特性optional pattern（可选模式） ——安全（@kametrixom支持）

 

中级

问题1- swift 1.0 or later

swift 是面向对象编程语言还是函数式编程语言？

答案：swift是一种混合编程语言，它包含这两种编程模式。它实现了面向对象的三个基本原则:

• 封装

• 继承

• 多态

说道swift作为一种函数式编程语言，我们就不得不说一下什么是函数式编程。有很多不同的方法去定义函数式编程语言，但是他们表达的意义相同。

最常见的定义来自维基百科：...它是一种编程规范…它把电脑运算当做数学函数计算，避免状态改变和数据改变。

很难说swift是一个成熟的函数式语言，但是它已经具备了函数式语言的基础。

问题2- swift 1.0 or later

下面的功能特性都包含在swift中吗？

1、泛型类

2、泛型结构体

3、泛型协议

答案：

• swift 包含1和2特性。泛型可以在类、结构体、枚举、全局函数或者方法中使用。

• 3是通过typealias部分实现的。typealias不是一个泛型类型,它只是一个占位符的名字。它通常是作为关联类型被引用，只有协议被一个类型引用的时候它才被定义。

问题3- swift 1.0 or later

在objective-c中，一个常量可以这样定义：

const int number = 0;

类似的swift是这样定义的：

let number = 0

两者之间有什么不同吗？如果有，请说明原因。

答案：const常量是一个在编译时或者编译解析时被初始化的变量。通过let创建的是一个运行时常量，是不可变得。它可以使用stattic 或者dynamic关键字来初始化。谨记它的的值只能被分配一次。

问题4- swift 1.0 or later

声明一个静态属性或者函数，我们常常使用值类型的static修饰符。下面就是一个结构体的例子：

struct sun {static func illuminate() {} }

对类来说,使用static 或者class修饰符，都是可以的。它们使用后的效果是一样的，但是本质上是不同的。能解释一下为什么不同吗？

答案：

static修饰的属性或者修饰的函数都不可以重写。但是使用class修饰符，你可以重写属性或者函数。

当static在类中应用的时候，static就成为class final的一个别名。

例如，在下面的代码中，当你尝试重写illuminate()函数时，编译器就会报错：

class star {class func spin() {}static func illuminate() {} }class sun : star {override class func spin() {super.spin()}override static func illuminate() { // error: class method overrides a 'final' class methodsuper.illuminate()} }

问题5- swift 1.0 or later

你能通过extension(扩展)保存一个属性吗？请解释一下原因。

答案：不能。扩展可以给当前的类型添加新的行为，但是不能改变本身的类型或者本身的接口。如果你添加一个新的可存储的属性，你需要额外的内存来存储新的值。扩展并不能实现这样的任务。

高级

问题1- swift 1.2

在swift1.2版本中，你能解释一下用泛型来声明枚举的问题吗？拿下面代码中either枚举来举例说明吧，它有两个泛型类型的参数t和v，参数t在关联值类型为left情况下使用，参数v在关联值为rihgt情况下使用，代码如下：

enum either{case left(t)case right(v) }

提示：验证上面的条件，需要在xcode工程里面，而不是在playgroud中。同时注意，这个问题跟swift1.2相关，所以xcode的版本必须是6.4以上。

答案：上面的代码会出现编译错误：

unimplemented ir generation feature non-fixed multi-payload enum layout

问题是t的内存大小不能确定前期,因为它依赖于t类型本身,但enum情况下需要一个固定大小的有效载荷。

最常用的解决方法是讲泛类型用引用类型包装起来，通常称为box,代码如下：

class box{let value: tinit(_ value: t) {self.value = value} }enum either{case left(box)case right(box) }

这个问题在swift1.0及之后的版本出现，但是swift2.0的时候，被解决了。

问题2- swift 1.0 or later

闭包是引用类型吗？

答案：闭包是引用类型。如果一个闭包被分配给一个变量,这个变量复制给另一个变量,那么他们引用的是同一个闭包，他们的捕捉列表也会被复制。

问题3- swift 1.0 or later

uint类型是用来存储无符号整型的。下面的代码实现了一个有符号整型转换的初始化方法：

init(_ value: int)

然而，在下面的代码中，当你给一个负值的时候，它会产生一个编译时错误：

let mynegative = uint(-1)

我们知道负数的内部结构是使用二进制补码的正数，在保持这个负数内存地址不变的情况下，如何把一个负整数转换成一个无符号的整数？

答案：使用下面的初始化方法：

uint(bitpattern: int)

问题4- swift 1.0 or later

描述一种在swift中出现循环引用的情况，并说明怎么解决。

答案：循环引用出现在当两个实例对象相互拥有强引用关系的时候，这会造成内存泄露，原因是这两个对像都不会被释放。只要一个对象被另一个对象强引用，那么该对象就不能被释放，由于强引用的存在，每个对象都会保持对方存在。

解决这个问题的方法是，用weak或者unowned引用代替其中一个的强引用，来打破循环引用。

问题5- swift 2.0 or later

swift2.0 增加了一个新的关键字来实现递归枚举。下面的例子是一个枚举类型，它在node条件下有两个相关联的值类型t和list：

enum list{case node(t, list) }

什么关键字可以实现递归枚举？

答案：indirect 关键值可以允许递归枚举，代码如下：

enum list{indirect case cons(t, list) }

where to go from here?

恭喜你到了文章的最后，如果你不知道所有问题的答案，也不要感到沮丧。

因为上面中得有些问题还是比较复杂的，并且swift是一门富有表现力的语言，还有很多需要我们学。此外，苹果公司一直改善swift的新特性，所以即使学的最好的人也不可能知道所有的一切。

在你现有的swift基础知识之上，要深入了解swift ,你就的看看swift by tutorials这本书，或者加入尊龙游戏旗舰厅官网实践教学协会rwdevcon。

当然，关于swift所有方面的资源都来是苹果公司官方文档the swift programming language。

事实上，学习一门语言最好的方式是用它。在你的工程里或者plaugroud里面使用swift编程。swift几乎可以无缝衔接object-c，所以在你现有的工程中使用swift是一个学习swift的很好的方法。

谢谢你的访问和回答这些问题。在下面你可以随意提问交流。我也不介意你在下面贴上自己遇见的难题和挑战，我们可以相互学习。

温馨提示：未经博主许可禁止转载！

总结

以上是尊龙游戏旗舰厅官网为你收集整理的【面试必备】swiftamp;nbsp;面试题及其答案的全部内容，希望文章能够帮你解决所遇到的问题。

如果觉得尊龙游戏旗舰厅官网网站内容还不错，欢迎将尊龙游戏旗舰厅官网推荐给好友。