基础
1、class 和 struct 的区别
2、不通过继承，代码复用（共享）的方式有哪些
3、Set 独有的方法有哪些？
4、实现一个 min 函数，返回两个元素较小的元素
5、map、filter、reduce 的作用
6、map 与 flatmap 的区别
7、什么是 copy on write
8、如何获取当前代码的函数名和行号
9、如何声明一个只能被类 conform 的 protocol
10、guard 使用场景
11、defer 使用场景
12、String 与 NSString 的关系与区别
13、怎么获取一个 String 的长度
14、如何截取 String 的某段字符串
15、throws 和 rethrows 的用法与作用
16、try？ 和 try！是什么意思
17、associatedtype 的作用
18、什么时候使用 final
19、public 和 open 的区别
20、声明一个只有一个参数没有返回值闭包的别名
22、Self 的使用场景
23、dynamic 的作用
24、什么时候使用 @objc
25、Optional（可选型） 是用什么实现的
26、如何自定义下标获取
27、?? 的作用
28、lazy 的作用
29、一个类型表示选项，可以同时表示有几个选项选中（类似 UIViewAnimationOptions ），用什么类型表示
30、inout 的作用
31、Error 如果要兼容 NSError 需要做什么操作
32、下面的代码都用了哪些语法糖
[1, 2, 3].map{ $0 * 2 }
33、什么是高阶函数
34、如何解决引用循环
35、下面的代码会不会崩溃，说出原因
1var mutableArray = [1,2,3] 2for _ in mutableArray { 3 mutableArray.removeLast() 4}
36、给集合中元素是字符串的类型增加一个扩展方法，应该怎么声明
37、定义静态方法时关键字 static 和 class 有什么区别
高级
38、、一个 Sequence 的索引是不是一定从 0 开始？
39、数组都实现了哪些协议
40、如何自定义模式匹配
41、autoclosure 的作用
42、编译选项 whole module optmization 优化了什么
43、下面代码中 mutating 的作用是什么
1struct Person { 2 var name: String { 3 mutating get { 4 return store 5 } 6 } 7}
44、如何让自定义对象支持字面量初始化
45、dynamic framework 和 static framework 的区别是什么
46、为什么数组索引越界会崩溃，而字典用下标取值时 key 没有对应值的话返回的是 nil 不会崩溃。
47、一个函数的参数类型只要是数字（Int、Float）都可以，要怎么表示。
解答区
class 和 struct 的区别
class 为类, struct 为结构体, 类是引用类型, 结构体为值类型, 结构体不可以继承
不通过继承，代码复用（共享）的方式有哪些
扩展, 全局函数
Set 独有的方法有哪些？
1// 定义一个 set 2let setA: Set<Int> = [1, 2, 3, 4, 4]// {1, 2, 3, 4}, 顺序可能不一致, 同一个元素只有一个值 3let setB: Set<Int> = [1, 3, 5, 7, 9]// {1, 3, 5, 7, 9} 4// 取并集 A | B 5let setUnion = setA.union(setB)// {1, 2, 3, 4, 5, 7, 9} 6// 取交集 A & B 7let setIntersect = setA.intersection(setB)// {1, 3} 8// 取差集 A - B 9let setRevers = setA.subtracting(setB) // {2, 4} 10// 取对称差集, A XOR B = A - B | B - A 11let setXor = setA.symmetricDifference(setB) //{2, 4, 5, 7, 9}
实现一个 min 函数，返回两个元素较小的元素
1func myMin<T: Comparable>(_ a: T, _ b: T) -> T { 2 return a < b ? a : b 3} 4myMin(1, 2)
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
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 返回的对象则是一个与自己元素类型相同的数组
1func 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]
其实这个实现, 相当于是在使用 map 之后, 再将各个数组拼起来一样的
1[[1], [2, 3], [4, 5, 6]].map(someFunc).reduce([Int]()) {$0 + $1} 2// [1, 2, 3, 4, 5, 6]
什么是 copy on write时候
写时复制, 指的是 swift 中的值类型, 并不会在一开始赋值的时候就去复制, 只有在需要修改的时候, 才去复制.
如何获取当前代码的函数名和行号
#file 用于获取当前文件文件名
#line 用于获取当前行号
#column 用于获取当前列编号
#function 用于获取当前函数名
以上这些都是特殊的字面量, 多用于调试输出日志
如何声明一个只能被类 conform 的 protocol
声明协议的时候, 加一个 class 即可
如
1protocol SomeClassProtocl: class { 2 func someFunction() 3}
guard 使用场景
guard 和 if 类似, 不同的是, guard 总是有一个 else 语句, 如果表达式是假或者值绑定失败的时候, 会执行 else 语句, 且在 else 语句中一定要停止函数调用
例如
1guard 1 + 1 == 2 else { 2 fatalError("something wrong") 3}
常用使用场景为, 用户登录的时候, 验证用户是否有输入用户名密码等
1guard let userName = self.userNameTextField.text, 2 let password = self.passwordTextField.text else { 3 return 4}
defer 使用场景
defer 语句块中的代码, 会在当前作用域结束前调用, 常用场景如异常退出后, 关闭数据库连接
1func someQuery() -> ([Result], [Result]){ 2 let db = DBOpen("xxx") 3 defer { 4 db.close() 5 } 6 guard results1 = db.query("query1") else { 7 return nil 8 } 9 guard results2 = db.query("query2") else { 10 return nil 11 } 12 return (results1, results2) 13}
需要注意的是, 如果有多个 defer, 那么后加入的先执行
1func 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} 18someDeferFunction() 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
String 与 NSString 的关系与区别
NSString 与 String 之间可以随意转换,
1let someString = "123" 2let someNSString = NSString(string: "n123") 3let strintToNSString = someString as NSString 4let nsstringToString = someNSString as String
String 是结构体, 值类型, NSString 是类, 引用类型.
通常, 没必要使用 NSString 类, 除非你要使用一些特有方法, 例如使用 pathExtension 属性
怎么获取一个 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
如何截取 String 的某段字符串
swift 中, 有三个取子串函数,
substring:to , substring:from, substring:with.
1let simpleString = "Hello, world" 2simpleString.substring(to: simpleString.index(simpleString.startIndex, offsetBy: 5)) 3// hello 4simpleString.substring(from: simpleString.index(simpleString.endIndex, offsetBy: -5)) 5// world 6simpleString.substring(with: simpleString.index(simpleString.startIndex, offsetBy: 5) ..< simpleString.index(simpleString.endIndex, offsetBy: -5)) 7// ,
throws 和 rethrows 的用法与作用
throws 用在函数上, 表示这个函数会抛出错误.
有两种情况会抛出错误, 一种是直接使用 throw 抛出, 另一种是调用其他抛出异常的函数时, 直接使用 try xx 没有处理异常.
如
1enum DivideError: Error { 2 case EqualZeroError; 3} 4func divide(_ a: Double, _ b: Double) throws -> Double { 5 guard b != Double(0) else { 6 throw DivideError.EqualZeroError 7 } 8 return a / b 9} 10func split(pieces: Int) throws -> Double { 11 return try divide(1, Double(pieces)) 12}
rethrows 与 throws 类似, 不过只适用于参数中有函数, 且函数会抛出异常的情况, rethrows 可以用 throws 替换, 反过来不行
如
1func processNumber(a: Double, b: Double, function: (Double, Double) throws -> Double) rethrows -> Double { 2 return try function(a, b) 3}
try？ 和 try！是什么意思
这两个都用于处理可抛出异常的函数, 使用这两个关键字可以不用写 do catch.
区别在于, try? 在用于处理可抛出异常函数时, 如果函数抛出异常, 则返回 nil, 否则返回函数返回值的可选值, 如:
1print(try? divide(2, 1)) 2// Optional(2.0) 3print(try? divide(2, 0)) 4// nil
而 try! 则在函数抛出异常的时候崩溃, 否则则返会函数返回值, 相当于(try? xxx)!, 如:
1print(try! divide(2, 1)) 2// 2.0 3print(try! divide(2, 0)) 4// 崩溃
associatedtype 的作用
简单来说就是 protocol 使用的泛型
例如定义一个列表协议
1protocol ListProtcol { 2 associatedtype Element 3 func push(_ element:Element) 4 func pop(_ element:Element) -> Element? 5}
实现协议的时候, 可以使用 typealias 指定为特定的类型, 也可以自动推断, 如
1class 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} 11class 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}
使用泛型也可以
1class 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 类型, 如:
1extension ListProtcol where Element == Int { 2 func isInt() ->Bool { 3 return true 4 } 5}
什么时候使用 final
final 用于限制继承和重写. 如果只是需要在某一个属性前加一个 final.
如果需要限制整个类无法被继承, 那么可以在类名之前加一个final
public 和 open 的区别
这两个都用于在模块中声明需要对外界暴露的函数, 区别在于, public 修饰的类, 在模块外无法继承, 而 open 则可以任意继承, 公开度来说, public < open
声明一个只有一个参数没有返回值闭包的别名
没有返回值也就是返回值为 Void
1typealias SomeClosuerType = (String) -> (Void) 2let someClosuer: SomeClosuerType = { (name: String) in 3 print("hello,", name) 4} 5someClosuer("world") 6// hello, world
Self 的使用场景
Self 通常在协议中使用, 用来表示实现者或者实现者的子类类型.
例如, 定义一个复制的协议
1protocol CopyProtocol { 2 func copy() -> Self 3}
如果是结构体去实现, 要将Self 换为具体的类型
1struct SomeStruct: CopyProtocol { 2 let value: Int 3 func copySelf() -> SomeStruct { 4 return SomeStruct(value: self.value) 5 } 6}
如果是类去实现, 则有点复杂, 需要有一个 required 初始化方法
1class SomeCopyableClass: CopyProtocol { 2 func copySelf() -> Self { 3 return type(of: self).init() 4 } 5 required init(){} 6}
dynamic 的作用
由于 swift 是一个静态语言, 所以没有 Objective-C 中的消息发送这些动态机制, dynamic 的作用就是让 swift 代码也能有 Objective-C 中的动态机制, 常用的地方就是 KVO 了, 如果要监控一个属性, 则必须要标记为 dynamic
什么时候使用 @objc
@objc 用途是为了在 Objective-C 和 Swift 混编的时候, 能够正常调用 Swift 代码. 可以用于修饰类, 协议, 方法, 属性.
常用的地方是在定义 delegate 协议中, 会将协议中的部分方法声明为可选方法, 需要用到@objc
1@objc protocol OptionalProtocol { 2 @objc optional func optionalFunc() 3 func normalFunc() 4} 5class OptionProtocolClass: OptionalProtocol { 6 func normalFunc() { 7 } 8} 9let someOptionalDelegate: OptionalProtocol = OptionProtocolClass() 10someOptionalDelegate.optionalFunc?()
Optional（可选型） 是用什么实现的
Optional 是一个泛型枚举
大致定义如下:
1enum Optional<Wrapped> { 2 case none 3 case some(Wrapped) 4}
除了使用 let someValue: Int? = nil 之外, 还可以使用let optional1: Optional<Int> = nil 来定义
如何自定义下标获取
实现 subscript 即可, 如
1extension 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}
索引除了数字之外, 其他类型也是可以的
?? 的作用
可选值的默认值, 当可选值为nil 的时候, 会返回后面的值. 如
let someValue = optional1 ?? 0
lazy 的作用
懒加载, 当属性要使用的时候, 才去完成初始化
如
1class 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} 11let lazyInstance = LazyClass() 12print(lazyInstance.someNormalValue) 13print(lazyInstance.someLazyValue) 14// 打印输出 15// normal init value 16// 2 17// lazy init value 18// 1
一个类型表示选项，可以同时表示有几个选项选中（类似 UIViewAnimationOptions ），用什么类型表示
需要实现自 OptionSet, 一般使用 struct 实现. 由于 OptionSet 要求有一个不可失败的init(rawValue:) 构造器, 而 枚举无法做到这一点(枚举的原始值构造器是可失败的, 而且有些组合值, 是没办法用一个枚举值表示的)
1struct 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} 7let options: SomeOption = [.option1, .option2]
inout 的作用
输入输出参数, 如:
1func swap( a: inout Int, b: inout Int) { 2 let temp = a 3 a = b 4 b = temp 5} 6var a = 1 7var b = 2 8print(a, b)// 1 2 9swap(a: &a, b: &b) 10print(a, b)// 2 1
Error 如果要兼容 NSError 需要做什么操作
其实直接转换就可以, 例如 SomeError.someError as NSError 但是这样没有错误码, 描述等等, 如果想和 NSError 一样有这些东西, 只需要实现 LocalizedError 和 CustomNSError 协议, 有些方法有默认实现, 可以略过, 如:
1enum 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} 31print(SomeError.error1 as NSError) 32// Error Domain=error domain SomeError Code=1 "error description error1" UserInfo={info=error1}
下面的代码都用了哪些语法糖
[1, 2, 3].map{ $0 * 2 }
[1, 2, 3] 使用了, Array 实现的ExpressibleByArrayLiteral 协议, 用于接收数组的字面值
map{xxx} 使用了闭包作为作为最后一个参数时, 可以直接写在调用后面, 而且, 如果是唯一参数的话, 圆括号也可以省略
闭包没有声明函数参数, 返回值类型, 数量, 依靠的是闭包类型的自动推断
闭包中语句只有一句时, 自动将这一句的结果作为返回值
什么是高阶函数
一个函数如果可以以某一个函数作为参数, 或者是返回值, 那么这个函数就称之为高阶函数, 如 map, reduce, filter
如何解决引用循环
- 转换为值类型, 只有类会存在引用循环, 所以如果能不用类, 是可以解引用循环的,
- delegate 使用 weak 属性.
- 闭包中, 对有可能发生循环引用的对象, 使用 weak 或者 unowned, 修饰
下面的代码会不会崩溃，说出原因
1var mutableArray = [1,2,3] 2for _ in mutableArray { 3 mutableArray.removeLast() 4}
不会, 原理不清楚, 就算是把 removeLast(), 换成 removeAll() ,这个循环也会执行三次, 估计是在一开始, for
in 就对 mutableArray 进行了一次值捕获, 而 Array 是一个值类型 , removeLast() 并不能修改捕获的值.
给集合中元素是字符串的类型增加一个扩展方法，应该怎么声明
使用 where 子句, 限制 Element 为 String
1extension Array where Element == String { 2 var isStringElement:Bool { 3 return true 4 } 5} 6["1", "2"].isStringElement 7//[1, 2].isStringElement// error
定义静态方法时关键字 static 和 class 有什么区别
static 定义的方法不可以被子类继承, class 则可以
1class AnotherClass { 2 static func staticMethod(){} 3 class func classMethod(){} 4} 5class ChildOfAnotherClass: AnotherClass { 6 override class func classMethod(){} 7 //override static func staticMethod(){}// error 8}
一个 Sequence 的索引是不是一定从 0 开始？
不一定, 两个 for in 并不能保证都是从 0 开始, 且输出结果一致, 官方文档如下
Repeated Access
The
Sequenceprotocol makes no requirement on conforming types regarding
whether they will be destructively consumed by iteration. As a
consequence, don't assume that multiplefor-inloops on a sequence
will either resume iteration or restart from the beginning:1for element in sequence { 2 if ... some condition { break } 3} 4 5for element in sequence { 6 // No defined behavior 7}
有些同学还是不太理解, 我写了一个demo 当作参考
1class 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 16var countDown = Countdown(count: 5) 17print("begin for in 1") 18for c in countDown { 19 print(c) 20} 21print("end for in 1") 22print("begin for in 2") 23for c in countDown { 24 print(c) 25} 26print("end for in 2")
最后输出的结果是
1begin for in 1 25 34 43 52 61 7end for in 1 8begin for in 2 9end for in 2
很明显, 第二次没有输出任何结果, 原因就是在第二次for in 的时候, 并没有将count 重置.
数组都实现了哪些协议
MutableCollection, 实现了可修改的数组, 如 a[1] = 2
ExpressibleByArrayLiteral, 实现了数组可以从[1, 2, 3] 这种字面值初始化的能力
...
如何自定义模式匹配
autoclosure 的作用
自动闭包, 会自动将某一个表达式封装为闭包. 如
1func autoClosureFunction(_ closure: @autoclosure () -> Int) { 2 closure() 3} 4autoClosureFunction(1)
编译选项 whole module optmization 优化了什么
编译器可以跨文件优化编译代码, 不局限于一个文件.
下面代码中 mutating 的作用是什么
1struct Person { 2 var name: String { 3 mutating get { 4 return store 5 } 6 } 7}
让不可变对象无法访问 name 属性
如何让自定义对象支持字面量初始化
有几个协议, 分别是
ExpressibleByArrayLiteral 可以由数组形式初始化
ExpressibleByDictionaryLiteral 可以由字典形式初始化
ExpressibleByNilLiteral 可以由nil 值初始化
ExpressibleByIntegerLiteral 可以由整数值初始化
ExpressibleByFloatLiteral 可以由浮点数初始化
ExpressibleByBooleanLiteral 可以由布尔值初始化
ExpressibleByUnicodeScalarLiteral
ExpressibleByExtendedGraphemeClusterLiteral
ExpressibleByStringLiteral
这三种都是由字符串初始化, 上面两种包含有 Unicode 字符和特殊字符
dynamic framework 和 static framework 的区别是什么
静态库和动态库, 静态库是每一个程序单独打包一份, 而动态库则是多个程序之间共享