文章来源：https://mp.weixin.qq.com/s/DIn3otUaoGMyEWZf4c99Mw

1. class 和 struct 的区别

class 为类, struct 为结构体, 类是引用类型, 结构体为值类型, 结构体不可以继承

2. 不通过继承，代码复用（共享）的方式有哪些

扩展, 全局函数

3. Set 独有的方法有哪些？

  1. // 定义一个 set
  2. let setA: Set<Int> = [1, 2, 3, 4, 4]// {1, 2, 3, 4}, 顺序可能不一致, 同一个元素只有一个值
  3. let setB: Set<Int> = [1, 3, 5, 7, 9]// {1, 3, 5, 7, 9}
  4. // 取并集 A | B
  5. let setUnion = setA.union(setB)// {1, 2, 3, 4, 5, 7, 9}
  6. // 取交集 A & B
  7. let setIntersect = setA.intersection(setB)// {1, 3}
  8. // 取差集 A - B
  9. let setRevers = setA.subtracting(setB) // {2, 4}
  10. // 取对称差集, A XOR B = A - B | B - A
  11. let setXor = setA.symmetricDifference(setB) //{2, 4, 5, 7, 9}

4. 实现一个 min 函数，返回两个元素较小的元素

  1. func myMin<T: Comparable>(_ a: T, _ b: T) -> T {
  2.     return a < b ? a : b
  3. }
  4. myMin(1, 2)

5. map、filter、reduce 的作用

map 用于映射, 可以将一个列表转换为另一个列表

  1. [1, 2, 3].map{"\($0)"}// 数字数组转换为字符串数组
  2. ["1", "2", "3"]

filter 用于过滤, 可以筛选出想要的元素

  1. [1, 2, 3].filter{$0 % 2 == 0} // 筛选偶数
  2. // [2]

reduce 合并

  1. [1, 2, 3].reduce(""){$0 + "\($1)"}// 转换为字符串并拼接
  2. // "123"

组合示例

  1. (0 ..< 10).filter{$0 % 2 == 0}.map{"\($0)"}.reduce(""){$0 + $1}
  2. // 02468

6. map 与 flatmap 的区别

flatmap 有两个实现函数实现,
public func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
这个方法, 中间的函数返回值为一个可选值, 而 flatmap 会丢掉那些返回值为 nil 的值
例如

  1. ["1", "@", "2", "3", "a"].flatMap{Int($0)}
  2. // [1, 2, 3]
  3. ["1", "@", "2", "3", "a"].map{Int($0) ?? -1}
  4. //[Optional(1), nil, Optional(2), Optional(3), nil]

另一个实现
public func flatMap<SegmentOfResult>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] where SegmentOfResult : Sequence
中间的函数, 返回值为一个数组, 而这个 flapmap 返回的对象则是一个与自己元素类型相同的数组

  1. func someFunc(_ array:[Int]) -> [Int] {
  2.     return array
  3. }
  4. [[1], [2, 3], [4, 5, 6]].map(someFunc)
  5. // [[1], [2, 3], [4, 5, 6]]
  6. [[1], [2, 3], [4, 5, 6]].flatMap(someFunc)
  7. // [1, 2, 3, 4, 5, 6]
  8. 其实这个实现, 相当于是在使用 map 之后, 再将各个数组拼起来一样的
  9. [[1], [2, 3], [4, 5, 6]].map(someFunc).reduce([Int]()) {$0 + $1}
  10. // [1, 2, 3, 4, 5, 6]

7. 什么是 copy on write

写时复制, 指的是 swift 中的值类型, 并不会在一开始赋值的时候就去复制, 只有在需要修改的时候, 才去复制。

8. 如何获取当前代码的函数名和行号

#file用于获取当前文件文件名
#line用于获取当前行号
#column用于获取当前列编号
#function用于获取当前函数名
以上这些都是特殊的字面量, 多用于调试输出日志

9. 如何声明一个只能被类 conform 的 protocol

声明协议的时候, 加一个 class 即可
如

  1. protocol SomeClassProtocl: class {
  2.     func someFunction()
  3. }

10. guard 使用场景

guard 和 if 类似, 不同的是, guard 总是有一个 else 语句, 如果表达式是假或者值绑定失败的时候, 会执行 else 语句, 且在 else 语句中一定要停止函数调用
例如

  1. guard 1 + 1 == 2 else {
  2.     fatalError("something wrong")
  3. }

常用使用场景为, 用户登录的时候, 验证用户是否有输入用户名密码等

  1. guard let userName = self.userNameTextField.text,
  2.   let password = self.passwordTextField.text else {
  3.     return
  4. }

11. defer 使用场景

defer 语句块中的代码, 会在当前作用域结束前调用, 常用场景如异常退出后, 关闭数据库连接

  1. func someQuery()
  2. -> ([
  3. Result
  4. ], [
  5. Result
  6. ]){
  7.     let db = DBOpen("xxx")
  8.     defer {
  9.         db.close()
  10.     }
  11.     guard results1 = db.query("query1") else {
  12.         return nil
  13.     }
  14.     guard results2 = db.query("query2") else {
  15.         return nil
  16.     }
  17.     return (results1, results2)
  18. }

需要注意的是, 如果有多个 defer, 那么后加入的先执行

  1. func someDeferFunction() {
  2.     defer {
  3.         print("\(#function)-end-1-1")
  4.         print("\(#function)-end-1-2")
  5.     }
  6.     defer {
  7.         print("\(#function)-end-2-1")
  8.         print("\(#function)-end-2-2")
  9.     }
  10.     if true {
  11.         defer {
  12.             print("if defer")
  13.         }
  14.         print("if end")
  15.     }
  16.     print("function end")
  17. }
  18. someDeferFunction()
  19. // 输出
  20. // if end
  21. // if defer
  22. // function end
  23. // someDeferFunction()-end-2-1
  24. // someDeferFunction()-end-2-2
  25. // someDeferFunction()-end-1-1
  26. // someDeferFunction()-end-1-2

12. String 与 NSString 的关系与区别

NSString 与 String 之间可以随意转换

  1. let someString = "123"
  2. let someNSString = NSString(string: "n123")
  3. let strintToNSString = someString as NSString
  4. let nsstringToString = someNSString as String

String 是结构体, 值类型, NSString 是类, 引用类型。
通常, 没必要使用 NSString 类, 除非你要使用一些特有方法, 例如使用 pathExtension属性

13. 怎么获取一个 String 的长度

不考虑编码, 只是想知道字符的数量, 用characters.count

  1. "hello".characters.count // 5
  2. "你好".characters.count // 2
  3. "こんにちは".characters.count // 5

如果想知道在某个编码下占多少字节, 可以用

  1. "hello".lengthOfBytes(using: .ascii) // 5
  2. "hello".lengthOfBytes(using: .unicode) // 10
  3. "你好".lengthOfBytes(using: .unicode) // 4
  4. "你好".lengthOfBytes(using: .utf8) // 6
  5. "こんにちは".lengthOfBytes(using: .unicode) // 10
  6. "こんにちは".lengthOfBytes(using: .utf8) // 15

14. 如何截取 String 的某段字符串

swift 中, 有三个取子串函数,

  1. substring:to , substring:from, substring:with.
  2. let simpleString = "Hello, world"
  3. simpleString.substring(to: simpleString.index(simpleString.startIndex, offsetBy: 5))
  4. // hello
  5. simpleString.substring(from: simpleString.index(simpleString.endIndex, offsetBy: -5))
  6. // world
  7. simpleString.substring(with: simpleString.index(simpleString.startIndex, offsetBy: 5) ..< simpleString.index(simpleString.endIndex, offsetBy: -5))
  8. // ,

15. throws 和 rethrows 的用法与作用

throws 用在函数上, 表示这个函数会抛出错误.
有两种情况会抛出错误, 一种是直接使用 throw 抛出, 另一种是调用其他抛出异常的函数时, 直接使用 try xx 没有处理异常.
如

  1. enum DivideError: Error {
  2.     case EqualZeroError;
  3. }
  4. func divide(_ a: Double, _ b: Double) throws -> Double {
  5.     guard b != Double(0) else {
  6.         throw DivideError.EqualZeroError
  7.     }
  8.     return a / b
  9. }
  10. func split(pieces: Int) throws -> Double {
  11.     return try divide(1, Double(pieces))
  12. }

rethrows 与 throws 类似, 不过只适用于参数中有函数, 且函数会抛出异常的情况, rethrows 可以用 throws 替换, 反过来不行
如

  1. func processNumber(a: Double, b: Double, function: (Double, Double) throws -> Double) rethrows -> Double {
  2.     return try function(a, b)
  3. }

16. try？和 try！是什么意思

这两个都用于处理可抛出异常的函数, 使用这两个关键字可以不用写do catch.
区别在于, try? 在用于处理可抛出异常函数时, 如果函数抛出异常, 则返回 nil, 否则返回函数返回值的可选值, 如:

  1. print(try? divide(2, 1))
  2. // Optional(2.0)
  3. print(try? divide(2, 0))
  4. // nil

而 try! 则在函数抛出异常的时候崩溃, 否则则返会函数返回值, 相当于(try? xxx)!, 如:

  1. print(try! divide(2, 1))
  2. // 2.0
  3. print(try! divide(2, 0))
  4. // 崩溃

17. associatedtype 的作用

简单来说就是 protocol 使用的泛型
例如定义一个列表协议

  1. protocol ListProtcol {
  2.     associatedtype Element
  3.     func push(_ element:Element)
  4.     func pop(_ element:Element) -> Element?
  5. }

实现协议的时候, 可以使用 typealias 指定为特定的类型, 也可以自动推断, 如

  1. class IntList: ListProtcol {
  2.     typealias Element = Int // 使用 typealias 指定为 Int
  3.     var list = [Element]()
  4.     func push(_ element: Element) {
  5.         self.list.append(element)
  6.     }
  7.     func pop(_ element: Element) -> Element? {
  8.         return self.list.popLast()
  9.     }
  10. }
  11. class DoubleList: ListProtcol {
  12.     var list = [Double]()
  13.     func push(_ element: Double) {// 自动推断
  14.         self.list.append(element)
  15.     }
  16.     func pop(_ element: Double) -> Double? {
  17.         return self.list.popLast()
  18.     }
  19. }

使用泛型也可以

  1. class AnyList<T>: ListProtcol {
  2.     var list = [T]()
  3.     func push(_ element: T) {
  4.         self.list.append(element)
  5.     }
  6.     func pop(_ element: T) -> T? {
  7.         return self.list.popLast()
  8.     }
  9. }

可以使用 where 字句限定 Element 类型, 如:

  1. extension ListProtcol where Element == Int {
  2.     func isInt() ->Bool {
  3.         return true
  4.     }
  5. }

18. 什么时候使用 final

final 用于限制继承和重写. 如果只是需要在某一个属性前加一个 final。
如果需要限制整个类无法被继承, 那么可以在类名之前加一个final

19. public 和 open 的区别

这两个都用于在模块中声明需要对外界暴露的函数, 区别在于, public 修饰的类, 在模块外无法继承, 而 open 则可以任意继承, 公开度来说, public < open

20. 声明一个只有一个参数没有返回值闭包的别名

没有返回值也就是返回值为Void

  1. typealias SomeClosuerType = (String) -> (Void)
  2. let someClosuer: SomeClosuerType = { (name: String) in
  3.     print("hello,", name)
  4. }
  5. someClosuer("world")
  6. // hello, world

21. 定义静态方法时关键字 static 和 class 有什么区别

static 定义的方法不可以被子类继承, class 则可以

  1. class AnotherClass {
  2.     static func staticMethod(){}
  3.     class func classMethod(){}
  4. }
  5. class ChildOfAnotherClass: AnotherClass {
  6.     override class func classMethod(){}
  7.     //override static func staticMethod(){}// error
  8. }

22. Self 的使用场景

Self 通常在协议中使用, 用来表示实现者或者实现者的子类类型.
例如, 定义一个复制的协议

  1. protocol CopyProtocol {
  2.     func copy() -> Self
  3. }

如果是结构体去实现, 要将Self 换为具体的类型

  1. struct SomeStruct: CopyProtocol {
  2.     let value: Int
  3.     func copySelf() -> SomeStruct {
  4.         return SomeStruct(value: self.value)
  5.     }
  6. }

如果是类去实现, 则有点复杂, 需要有一个 required 初始化方法

  1. class SomeCopyableClass: CopyProtocol {
  2.     func copySelf() -> Self {
  3.         return type(of: self).init()
  4.     }
  5.     required init(){}
  6. }

23. dynamic 的作用

由于 swift 是一个静态语言, 所以没有 Objective-C 中的消息发送这些动态机制, dynamic 的作用就是让 swift 代码也能有 Objective-C 中的动态机制, 常用的地方就是 KVO 了, 如果要监控一个属性, 则必须要标记为 dynamic

24. 什么时候使用 @objc

@objc 用途是为了在 Objective-C 和 Swift 混编的时候, 能够正常调用 Swift 代码. 可以用于修饰类, 协议, 方法, 属性。
常用的地方是在定义 delegate 协议中, 会将协议中的部分方法声明为可选方法, 需要用到@objc

  1. @objc protocol OptionalProtocol {
  2.     @objc optional func optionalFunc()
  3.     func normalFunc()
  4. }
  5. class OptionProtocolClass: OptionalProtocol {
  6.     func normalFunc() {
  7.     }
  8. }
  9. let someOptionalDelegate: OptionalProtocol = OptionProtocolClass()
  10. someOptionalDelegate.optionalFunc?()

25. Optional（可选型） 是用什么实现的

Optional 是一个泛型枚举
大致定义如下:

  1. enum Optional<Wrapped> {
  2.   case none
  3.   case some(Wrapped)
  4. }

除了使用let someValue: Int? = nil之外, 还可以使用let optional1: Optional<Int> = nil来定义

26. 如何自定义下标获取

实现 subscript 即可, 如

  1. extension AnyList {
  2.     subscript(index: Int) -> T{
  3.         return self.list[index]
  4.     }
  5.     subscript(indexString: String) -> T?{
  6.         guard let index = Int(indexString) else {
  7.             return nil
  8.         }
  9.         return self.list[index]
  10.     }
  11. }

索引除了数字之外, 其他类型也是可以的

27. ?? 的作用

可选值的默认值, 当可选值为nil 的时候, 会返回后面的值. 如

  1. let someValue = optional1 ?? 0

28. lazy 的作用

懒加载, 当属性要使用的时候, 才去完成初始化
如

  1. class LazyClass {
  2.     lazy var someLazyValue: Int = {
  3.         print("lazy init value")
  4.         return 1
  5.     }()
  6.     var someNormalValue: Int = {
  7.         print("normal init value")
  8.         return 2
  9.     }()
  10. }
  11. let lazyInstance = LazyClass()
  12. print(lazyInstance.someNormalValue)
  13. print(lazyInstance.someLazyValue)
  14. // 打印输出
  15. // normal init value
  16. // 2
  17. // lazy init value
  18. // 1

29. 一个类型表示选项，可以同时表示有几个选项选中（类似 UIViewAnimationOptions ），用什么类型表示

需要实现自 OptionSet, 一般使用 struct 实现. 由于 OptionSet 要求有一个不可失败的init(rawValue:) 构造器, 而 枚举无法做到这一点(枚举的原始值构造器是可失败的, 而且有些组合值, 是没办法用一个枚举值表示的)

  1. struct SomeOption: OptionSet {
  2.     let rawValue: Int
  3.     static let option1 = SomeOption(rawValue: 1 << 0)
  4.     static let option2 =  SomeOption(rawValue:1 << 1)
  5.     static let option3 =  SomeOption(rawValue:1 << 2)
  6. }
  7. let options: SomeOption = [.option1, .option2]

30. inout 的作用

输入输出参数, 如:

  1. func swap( a: inout Int, b: inout Int) {
  2.     let temp = a
  3.     a = b
  4.     b = temp
  5. }
  6. var a = 1
  7. var b = 2
  8. print(a, b)// 1 2
  9. swap(a: &a, b: &b)
  10. print(a, b)// 2 1

31. Error 如果要兼容 NSError 需要做什么操作

其实直接转换就可以, 例如SomeError.someError as NSError但是这样没有错误码, 描述等等, 如果想和 NSError 一样有这些东西, 只需要实现 LocalizedError和CustomNSError协议, 有些方法有默认实现, 可以略过, 如:

  1. enum SomeError: Error, LocalizedError, CustomNSError {
  2.     case error1, error2
  3.     public var errorDescription: String? {
  4.         switch self {
  5.         case .error1:
  6.             return "error description error1"
  7.         case .error2:
  8.             return "error description error2"
  9.         }
  10.     }
  11.     var errorCode: Int {
  12.         switch self {
  13.         case .error1:
  14.             return 1
  15.         case .error2:
  16.             return 2
  17.         }
  18.     }
  19.     public static var errorDomain: String {
  20.         return "error domain SomeError"
  21.     }
  22.     public var errorUserInfo: [String : Any] {
  23.         switch self {
  24.         case .error1:
  25.             return ["info": "error1"]
  26.         case .error2:
  27.             return ["info": "error2"]
  28.         }
  29.     }
  30. }
  31. print(SomeError.error1 as NSError)
  32. // Error Domain=error domain SomeError Code=1 "error description error1" UserInfo={info=error1}

32. 下面的代码都用了哪些语法糖

  1. [1, 2, 3].map{ $0 * 2 }

[1, 2, 3] 使用了, Array 实现的ExpressibleByArrayLiteral 协议, 用于接收数组的字面值
map{xxx} 使用了闭包作为作为最后一个参数时, 可以直接写在调用后面, 而且, 如果是唯一参数的话, 圆括号也可以省略
闭包没有声明函数参数, 返回值类型, 数量, 依靠的是闭包类型的自动推断
闭包中语句只有一句时, 自动将这一句的结果作为返回值

33. 什么是高阶函数

一个函数如果可以以某一个函数作为参数, 或者是返回值, 那么这个函数就称之为高阶函数, 如 map, reduce, filter

34. 如何解决引用循环

  1. 转换为值类型, 只有类会存在引用循环, 所以如果能不用类, 是可以解引用循环的
  2. delegate 使用 weak 属性
  3. 闭包中, 对有可能发生循环引用的对象, 使用 weak 或者 unowned, 修饰

    35. 下面的代码会不会崩溃，说出原因

    1. var mutableArray = [1,2,3]
    2. for _ in mutableArray {
    3.  mutableArray.removeLast()
    4. }
    不会, 原理不清楚, 就算是把 removeLast(), 换成 removeAll() ,这个循环也会执行三次, 估计是在一开始, for
    in 就对 mutableArray 进行了一次值捕获, 而 Array 是一个值类型 , removeLast() 并不能修改捕获的值。

    36. 给集合中元素是字符串的类型增加一个扩展方法，应该怎么声明

    使用 where 子句, 限制 Element 为 String
    1. extension Array where Element == String {
    2.  var isStringElement:Bool {
    3.      return true
    4.  }
    5. }
    6. ["1", "2"].isStringElement
    7. //[1, 2].isStringElement// error

    二、 高级题解答区

    1。 一个 Sequence 的索引是不是一定从 0 开始？

    不一定, 两个 for in 并不能保证都是从 0 开始, 且输出结果一致, 官方文档如下：

    Repeated Access

    The Sequence protocol makes no requirement on conforming types regarding
    whether they will be destructively consumed by iteration. As a
    consequence, don’t assume that multiple for-in loops on a sequence
    will either resume iteration or restart from the beginning:
    1. for element in sequence {
    2.  if ... some condition { break }
    3. }
    4. for element in sequence {
    5.  // No defined behavior
    6. }
    有些同学还是不太理解, 我写了一个demo 当作参考
    1. class Countdown: Sequence, IteratorProtocol {
    2.  var count: Int
    3.  init(count: Int) {
    4.      self.count = count
    5.  }
    6.  func next() -> Int? {
    7.     if count == 0 {
    8.         return nil
    9.     } else {
    10.         defer { count -= 1 }
    11.         return count
    12.     }
    13. }
    14. }
    15. var countDown = Countdown(count: 5)
    16. print("begin for in 1")
    17. for c in countDown {
    18.  print(c)
    19. }
    20. print("end for in 1")
    21. print("begin for in 2")
    22. for c in countDown {
    23.  print(c)
    24. }
    25. print("end for in 2")
    最后输出的结果是

    begin for in 1
    5
    4
    3
    2
    1
    end for in 1
    begin for in 2
    end for in 2

很明显, 第二次没有输出任何结果, 原因就是在第二次for in 的时候, 并没有将count重置。

2. 数组都实现了哪些协议

MutableCollection, 实现了可修改的数组, 如a[1] = 2
ExpressibleByArrayLiteral, 实现了数组可以从[1, 2, 3] 这种字面值初始化的能力

3. 如何自定义模式匹配

待更新，暂时没有最优解，读者可在文末留言

4. autoclosure 的作用

自动闭包, 会自动将某一个表达式封装为闭包. 如

  1. func autoClosureFunction(_ closure: @autoclosure () -> Int) {
  2.    closure()
  3. }
  4. autoClosureFunction(1)

5. 编译选项 whole module optmization 优化了什么

编译器可以跨文件优化编译代码, 不局限于一个文件。

6. 下面代码中 mutating 的作用是什么

  1. struct Person {
  2.     var name: String {
  3.         mutating get { 
  4.             return store 
  5.         }
  6.     }
  7.   }

让不可变对象无法访问 name 属性

7. 如何让自定义对象支持字面量初始化

有几个协议, 分别是
ExpressibleByArrayLiteral可以由数组形式初始化
ExpressibleByDictionaryLiteral可以由字典形式初始化
ExpressibleByNilLiteral可以由nil 值初始化
ExpressibleByIntegerLiteral可以由整数值初始化
ExpressibleByFloatLiteral可以由浮点数初始化
ExpressibleByBooleanLiteral可以由布尔值初始化
ExpressibleByUnicodeScalarLiteral
ExpressibleByExtendedGraphemeClusterLiteral
ExpressibleByStringLiteral
这三种都是由字符串初始化, 上面两种包含有 Unicode 字符和特殊字符

8. dynamic framework 和 static framework 的区别是什么

静态库和动态库, 静态库是每一个程序单独打包一份, 而动态库则是多个程序之间共享

9. 为什么数组索引越界会崩溃，而字典用下标取值时 key 没有对应值的话返回的是 nil 不会崩溃

10. 一个函数的参数类型只要是数字（Int、Float）都可以，要怎么表示

**