Swift笔试试题及其答案

时间：2024-11-04 22:24:51 诗琳笔试题目我要投稿

相关推荐

Swift笔试试题及其答案

　　在学习、工作中，我们需要用到试题的情况非常的多，借助试题可以更好地考查参试者所掌握的知识和技能。什么类型的试题才能有效帮助到我们呢？下面是小编收集整理的Swift笔试试题及其答案，仅供参考，大家一起来看看吧。

Swift笔试试题及其答案

　　Swift笔试试题及其答案 1

　　问题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 doesnt 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 doesnt 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!

　　}

　　Swift笔试试题及其答案 2

　　1、Swift和Objective-C有什么区别？

　　1）Swift是强类型（静态）语言，有类型推断，Objective-C弱类型（动态）语言

　　2）Swift面向协议编程，Objective-C面向对象编程

　　3）Swift注重值类型，Objective-C注重引用类型

　　4）Swift支持泛型，Objective-C只支持轻量泛型（给集合添加泛型）

　　5）Swift支持静态派发（效率高）、动态派发（函数表派发、消息派发）方式，Objective-C支持动态派发（消息派发）方式

　　6）Swift支持函数式编程（高阶函数）

　　7）Swift的.协议不仅可以被类实现，也可以被Struct和Enum实现

　　8）Swift有元组类型、支持运算符重载

　　9）Swift支持命名空间

　　10）Swift支持默认参数

　　11）Swift比Objective-C代码更简洁

　　2、讲讲Swift的派发机制

　　1）函数的派发机制：静态派发（直接派发）、函数表派发、消息派发

　　2）Swift派发机制总结：

【Swift笔试试题及其答案】相关文章：