底子
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、下面的代码会不会崩溃，说出原因
var mutableArray = [1,2,3]for _ in mutableArray { mutableArray.removeLast()}36、给集合中元素是字符串的范例增长一个扩展方法，应该怎么声明
37、界说静态方法时关键字 static 和 class 有什么区别
高级
38、、一个 Sequence 的索引是不是肯定从 0 开始？
39、数组都实现了哪些协议
40、怎样自界说模式匹配
41、autoclosure 的作用,自动闭包，逃逸闭包@escaping，非逃逸闭包，尾随闭包
42、编译选项 whole module optmization 优化了什么
43、下面代码中 mutating 的作用是什么
struct Person { var name: String { mutating get { return store } }}44、怎样让自界说对象支持字面量初始化
45、dynamic framework 和 static framework 的区别是什么
46、为什么数组索引越界会崩溃，而字典用下标取值时 key 没有对应值的话返回的是 nil 不会崩溃。
47、一个函数的参数范例只要是数字（Int、Float）都可以，要怎么表示。
解答区
class 和 struct 的区别
class 为类, struct 为布局体, 类是引用范例, 布局体为值范例, 布局体不可以继承
不通过继承，代码复用（共享）的方式有哪些
扩展, 全局函数
Set 独有的方法有哪些？
// 界说一个 setlet setA: Set<Int> = [1, 2, 3, 4, 4]// {1, 2, 3, 4}, 序次大概差异等, 同一个元素只有一个值let setB: Set<Int> = [1, 3, 5, 7, 9]// {1, 3, 5, 7, 9}// 取并集 A | Blet setUnion = setA.union(setB)// {1, 2, 3, 4, 5, 7, 9}// 取交集 A & Blet setIntersect = setA.intersection(setB)// {1, 3}// 取差集 A - Blet setRevers = setA.subtracting(setB) // {2, 4}// 取对称差集, A XOR B = A - B | B - Alet setXor = setA.symmetricDifference(setB) //{2, 4, 5, 7, 9}实现一个 min 函数，返回两个元素较小的元素
func myMin<T: Comparable>(_ a: T, _ b: T) -> T { return a < b ? a : b}myMin(1, 2)map、filter、reduce 的作用
map 用于映射, 可以将一个列表转换为另一个列表
[1, 2, 3].map{"\($0)"}// 数字数组转换为字符串数组//["1", "2", "3"]filter 用于过滤, 可以筛选出想要的元素
[1, 2, 3].filter{$0 % 2 == 0} // 筛选偶数// [2]reduce 归并
[1, 2, 3].reduce(""){$0 + "\($1)"}// 转换为字符串并拼接// "123"组合示例
(0 ..< 10).filter{$0 % 2 == 0}.map{"\($0)"}.reduce(""){$0 + $1}// 02468map 与 flatmap 的区别
flatmap 有两个实现函数实现,
public func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
这个方法, 中央的函数返回值为一个可选值, 而 flatmap 会丢掉那些返回值为 nil 的值
比方
["1", "@", "2", "3", "a"].flatMap{Int($0)}// [1, 2, 3]["1", "@", "2", "3", "a"].map{Int($0)}//[Optional(1), nil, Optional(2), Optional(3), nil]另一个实现
public func flatMap<SegmentOfResult>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] where SegmentOfResult : Sequence
中央的函数, 返回值为一个数组, 而这个 flapmap 返回的对象则是一个与本身元素范例雷同的数组
func someFunc(_ array:[Int]) -> [Int] { return array}[[1], [2, 3], [4, 5, 6]].map(someFunc)// [[1], [2, 3], [4, 5, 6]][[1], [2, 3], [4, 5, 6]].flatMap(someFunc)// [1, 2, 3, 4, 5, 6]着实这个实现, 相当于是在使用 map 之后, 再将各个数组拼起来一样的
[[1], [2, 3], [4, 5, 6]].map(someFunc).reduce([Int]()) {$0 + $1}// [1, 2, 3, 4, 5, 6]什么是 copy on write时间
写时复制, 指的是 swift 中的值范例, 并不会在一开始赋值的时间就去复制, 只有在必要修改的时间, 才去复制.
// 打印对象的地点func printPoint(name:String,point:UnsafePointer<Int>){ print("\(name):\(point)")}var numberArray1 = [1, 2, 3, 4, 5]var numberArray2 = numberArray1printPoint(name: "numberArray1", point: numberArray1)//numberArray1:0x0000600000eb5560printPoint(name: "numberArray2", point: numberArray2)//numberArray2:0x0000600000eb5560numberArray2.append(6)printPoint(name: "numberArray1", point: numberArray1)//numberArray1:0x0000600000eb5560printPoint(name: "numberArray2", point: numberArray2)//numberArray2:0x00006000006b5750怎样获取当前代码的函数名和行号
#file 用于获取当前文件文件名
#line 用于获取当前行号
#column 用于获取当前列编号
#function 用于获取当前函数名
以上这些都是特殊的字面量, 多用于调试输出日记
具体可以看这里 apple 文档
https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html
这里有中文翻译
http://wiki.jikexueyuan.com/project/swift/chapter3/04_Expressions.html
怎样声明一个只能被类 conform 的 protocol
声明协议的时间, 加一个 class 即可
如
protocol SomeClassProtocl: class { func someFunction()}guard 使用场景
guard 和 if 类似, 差异的是, guard 总是有一个 else 语句, 如果表达式是假大概值绑定失败的时间, 会实行 else 语句, 且在 else 语句中肯定要停止函数调用
比方
guard 1 + 1 == 2 else { fatalError("something wrong")}常用使用场景为, 用户登录的时间, 验证用户是否有输入用户名暗码等
guard let userName = self.userNameTextField.text, let password = self.passwordTextField.text else { return}defer 使用场景
defer 语句块中的代码, 会在当前作用域竣事前调用, 常用场景如非常退出后, 关闭数据库毗连
func someQuery() -> ([Result], [Result]){ let db = DBOpen("xxx") defer { db.close() } guard results1 = db.query("query1") else { return nil } guard results2 = db.query("query2") else { return nil } return (results1, results2)}必要注意的是, 如果有多个 defer, 那么后参加的先实行
func someDeferFunction() { defer { print("\(#function)-end-1-1") print("\(#function)-end-1-2") } defer { print("\(#function)-end-2-1") print("\(#function)-end-2-2") } if true { defer { print("if defer") } print("if end") } print("function end")}someDeferFunction()// 输出// if end// if defer// function end// someDeferFunction()-end-2-1// someDeferFunction()-end-2-2// someDeferFunction()-end-1-1// someDeferFunction()-end-1-2String 与 NSString 的关系与区别
NSString 与 String 之间可以随意转换,
let someString = "123"let someNSString = NSString(string: "n123")let strintToNSString = someString as NSStringlet nsstringToString = someNSString as StringString 是布局体, 值范例, NSString 是类, 引用范例.
通常, 没须要使用 NSString 类, 除非你要使用一些特有方法, 比方使用 pathExtension 属性
怎么获取一个 String 的长度
不思量编码, 只是想知道字符的数量, 用characters.count
"hello".characters.count // 5"你好".characters.count // 2"こんにちは".characters.count // 5如果想知道在某个编码下占多少字节, 可以用
"hello".lengthOfBytes(using: .ascii) // 5"hello".lengthOfBytes(using: .unicode) // 10"你好".lengthOfBytes(using: .unicode) // 4"你好".lengthOfBytes(using: .utf8) // 6"こんにちは".lengthOfBytes(using: .unicode) // 10"こんにちは".lengthOfBytes(using: .utf8) // 15怎样截取 String 的某段字符串
swift 中, 有三个取子串函数,
substring:to , substring:from, substring:with.
let simpleString = "Hello, world"simpleString.substring(to: simpleString.index(simpleString.startIndex, offsetBy: 5))// hellosimpleString.substring(from: simpleString.index(simpleString.endIndex, offsetBy: -5))// worldsimpleString.substring(with: simpleString.index(simpleString.startIndex, offsetBy: 5) ..< simpleString.index(simpleString.endIndex, offsetBy: -5))// ,使用起来略微贫苦, 具体用法可以参考我的另一篇文章http://www.jianshu.com/p/b3231f9406e9
throws 和 rethrows 的用法与作用
throws 用在函数上, 表示这个函数会抛堕落误.
有两种情况会抛堕落误, 一种是直接使用 throw 抛出, 另一种是调用其他抛出非常的函数时, 直接使用 try xx 没有处理惩罚非常.
如
enum DivideError: Error { case EqualZeroError;}func divide(_ a: Double, _ b: Double) throws -> Double { guard b != Double(0) else { throw DivideError.EqualZeroError } return a / b}func split(pieces: Int) throws -> Double { return try divide(1, Double(pieces))}rethrows 与 throws 类似, 不外只实用于参数中有函数, 且函数会抛出非常的情况, rethrows 可以用 throws 更换, 反过来不可
如
func processNumber(a: Double, b: Double, function: (Double, Double) throws -> Double) rethrows -> Double { return try function(a, b)}try？ 和 try！是什么意思
这两个都用于处理惩罚可抛出非常的函数, 使用这两个关键字可以不消写 do catch.
区别在于, try? 在用于处理惩罚可抛出非常函数时, 如果函数抛出非常, 则返回 nil, 否则返回函数返回值的可选值, 如:
print(try? divide(2, 1))// Optional(2.0)print(try? divide(2, 0))// nil而 try! 则在函数抛出非常的时间崩溃, 否则则返会函数返回值, 相当于(try? xxx)!, 如:
print(try! divide(2, 1))// 2.0print(try! divide(2, 0))// 崩溃associatedtype 的作用
简单来说就是 protocol 使用的泛型
比方界说一个列表协议
protocol ListProtcol { associatedtype Element func push(_ element:Element) func pop(_ element:Element) -> Element?}实现协议的时间, 可以使用 typealias 指定为特定的范例, 也可以自动推断, 如
class IntList: ListProtcol { typealias Element = Int // 使用 typealias 指定为 Int var list = [Element]() func push(_ element: Element) { self.list.append(element) } func pop(_ element: Element) -> Element? { return self.list.popLast() }}class DoubleList: ListProtcol { var list = [Double]() func push(_ element: Double) {// 自动推断 self.list.append(element) } func pop(_ element: Double) -> Double? { return self.list.popLast() }}使用泛型也可以
class AnyList<T>: ListProtcol { var list = [T]() func push(_ element: T) { self.list.append(element) } func pop(_ element: T) -> T? { return self.list.popLast() }}可以使用 where 字句限定 Element 范例, 如:
extension ListProtcol where Element == Int { func isInt() ->Bool { return true }}什么时间使用 final
final 用于限定继承和重写. 如果只是必要在某一个属性前加一个 final.
如果必要限定整个类无法被继承, 那么可以在类名之前加一个final
public 和 open 的区别
这两个都用于在模块中声明必要对外界袒露的函数, 区别在于, public 修饰的类, 在模块外无法继承, 而 open 则可以恣意继承, 公开度来说, public < open
声明一个只有一个参数没有返回值闭包的别名
没有返回值也就是返回值为 Void
typealias SomeClosuerType = (String) -> (Void)let someClosuer: SomeClosuerType = { (name: String) in print("hello,", name)}someClosuer("world")// hello, worldSelf 的使用场景
Self 通常在协议中使用, 用来表示实现者大概实现者的子类范例.
比方, 界说一个复制的协议
protocol CopyProtocol { func copy() -> Self}如果是布局体去实现, 要将Self 换为具体的范例
struct SomeStruct: CopyProtocol { let value: Int func copySelf() -> SomeStruct { return SomeStruct(value: self.value) }}如果是类去实现, 则有点复杂, 必要有一个 required 初始化方法, 具体可以看这里 http://swifter.tips/use-self/
class SomeCopyableClass: CopyProtocol { func copySelf() -> Self { return type(of: self).init() } required init(){}}dynamic 的作用
由于 swift 是一个静态语言, 所以没有 Objective-C 中的消息发送这些动态机制, dynamic 的作用就是让 swift 代码也能有 Objective-C 中的动态机制, 常用的地方就是 KVO 了, 如果要监控一个属性, 则必须要标记为 dynamic, 可以参考我的文章http://www.jianshu.com/p/ae26100b9edf
什么时间使用 @objc
@objc 用途是为了在 Objective-C 和 Swift 混编的时间, 可以或许正常调用 Swift 代码. 可以用于修饰类, 协议, 方法, 属性.
常用的地方是在界说 delegate 协议中, 会将协议中的部门方法声明为可选方法, 必要用到@objc
@objc protocol OptionalProtocol { @objc optional func optionalFunc() func normalFunc()}class OptionProtocolClass: OptionalProtocol { func normalFunc() { }}let someOptionalDelegate: OptionalProtocol = OptionProtocolClass()someOptionalDelegate.optionalFunc?()Optional（可选型） 是用什么实现的
Optional 是一个泛型枚举
大抵界说如下:
enum Optional<Wrapped> { case none case some(Wrapped)}除了使用 let someValue: Int? = nil 之外, 还可以使用let optional1: Optional<Int> = nil 来界说
怎样自界说下标获取
实现 subscript 即可, 如
extension AnyList { subscript(index: Int) -> T{ return self.list[index] } subscript(indexString: String) -> T?{ guard let index = Int(indexString) else { return nil } return self.list[index] }}索引除了数字之外, 其他范例也是可以的
?? 的作用
可选值的默认值, 当可选值为nil 的时间, 会返回反面的值. 如
let someValue = optional1 ?? 0
lazy 的作用
懒加载, 当属性要使用的时间, 才去完成初始化
如
class LazyClass { lazy var someLazyValue: Int = { print("lazy init value") return 1 }() var someNormalValue: Int = { print("normal init value") return 2 }() init() { print("LazyClass 初始化方法") }}let lazyInstance = LazyClass()print(lazyInstance.someNormalValue)print(lazyInstance.someLazyValue)// 打印输出// normal init value// LazyClass 初始化方法// 2// lazy init value// 1一个范例表示选项，可以同时表示有几个选项选中（类似 UIViewAnimationOptions ），用什么范例表示
必要实现自 OptionSet, 一样平常使用 struct 实现. 由于 OptionSet 要求有一个不可失败的init(rawValue 构造器, 而 枚举无法做到这一点(枚举的原始值构造器是可失败的, 而且有些组合值, 是没办法用一个枚举值表示的)
struct SomeOption: OptionSet { let rawValue: Int static let option1 = SomeOption(rawValue: 1 << 0) static let option2 = SomeOption(rawValue:1 << 1) static let option3 = SomeOption(rawValue:1 << 2)}let options: SomeOption = [.option1, .option2]inout 的作用
输入输出参数, 如:
func swap( a: inout Int, b: inout Int) { let temp = a a = b b = temp}var a = 1var b = 2print(a, b)// 1 2swap(a: &a, b: &b)print(a, b)// 2 1Error 如果要兼容 NSError 必要做什么操纵
着实直接转换就可以, 比方 SomeError.someError as NSError 但是如许没有错误码, 形貌等等, 如果想和 NSError 一样有这些东西, 只必要实现 LocalizedError 和 CustomNSError 协议, 有些方法有默认实现, 可以略过, 如:
enum SomeError: Error, LocalizedError, CustomNSError { case error1, error2 public var errorDescription: String? { switch self { case .error1: return "error description error1" case .error2: return "error description error2" } } var errorCode: Int { switch self { case .error1: return 1 case .error2: return 2 } } public static var errorDomain: String { return "error domain SomeError" } public var errorUserInfo: [String : Any] { switch self { case .error1: return ["info": "error1"] case .error2: return ["info": "error2"] } }}print(SomeError.error1 as NSError)// 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} 使用了闭包作为作为末了一个参数时, 可以直接写在调用反面, 而且, 如果是唯一参数的话, 圆括号也可以省略
闭包没有声明函数参数, 返回值范例, 数量, 依赖的是闭包范例的自动推断
闭包中语句只有一句时, 自动将这一句的效果作为返回值 |
