![#### 介绍一下 Swift?
Swift是苹果在2014年6月WWDC发布的全新编程语言，借鉴了JS,Python,C#,Ruby等语言特性,看上去偏脚本化,Swift 仍支持 cocoa touch 框架
他的优点:
- Swift更加安全，它是类型安全的语言。
- Swift容易阅读，语法和文件结构简易化。
- Swift更易于维护，文件分离后结构更清晰。
- Swift代码更少，简洁的语法，可以省去大量冗余代码
- Swift速度更快，运算性能更高。
Swift 和OC 如何相互调用?
Swift 调用 OC代码
需要创建一个Target-BriBridging-Header.h的桥文件,在乔文件导入需要调用的OC代码头文件即可OC 调用 Swift代码
直接导入Target-Swift.h文件即可, Swift如果需要被OC调用,需要使用@objc 对方法或者属性进行修饰
类(class) 和 结构体(struct) 有什么区别?
在 Swift 中,class 是引用类型(指针类型), struct 是值类型
值类型
- 值类型在传递和赋值时将进行复制; 赋值给var、let或者给函数传参，是直接将所有内容拷贝一份, 类似于对文件进行copy、paste操作，产生了全新的文件副本。属于深拷贝(deep copy)
- 值类型: 比如结构体,枚举,是在栈空间上存储和操作的
引用类型
- 引用类型只会使用引用对象的一个"指向"; 赋值给var、let或者给函数传参，是将内存地址拷贝一份,类似于制作一个文件的替身(快捷方式、链接)，指向的是同一个文件。属于浅拷贝(shallow copy)
- 引用类型: 比如 Class,是在堆空间上存储和操作的
class 和 struct 比较,优缺点?
class 有以下功能,struct 是没有的:
- class可以继承,子类可以使用父类的特性和方法
- 类型转换可以在运行时检查和解释一个实例对象
- class可以用 deinit来释放资源
- 一个类可以被多次引用
struct 优势:
- 结构较小,适用于复制操作,相比较一个class 实例被多次引用,struct 更安全
- 无需担心内存泄露问题
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-2
Swift 中,什么可选型(Optional)
- 在 Swift 中,可选型是为了表达一个变量为空的情况,当一个变量为空,他的值就是 nil
- 在类型名称后面加个问号? 来定义一个可选型
- 值类型或者引用类型都可以是可选型变量
var name: String? // 默认为 nil
var age: Int? // 默认为nil
print(name, age) // 打印 nil, nil
Swift,什么是泛型?
- 泛型主要是为增加代码的灵活性而生的,它可以是对应的代码满足任意类型的的变量或方法;
- 泛型可以将类型参数化，提高代码复用率，减少代码量
// 实现一个方法,可以交换实现任意类型
func swap<T>(a: inout T, b: inout T) {
(a, b) = (b, a)
}
访问控制关键字 open, public, internal, fileprivate, private 的区别?
Swift 中有个5个级别的访问控制权限,从高到低依次是 open, public, internal, fileprivate, private
它们遵循的基本规则: 高级别的变量不允许被定义为低级别变量的成员变量,比如一个 private 的 class 内部允许包含 public的 String值,反之低级变量可以定义在高级别变量中;
- open: 具备最高访问权限,其修饰的类可以和方法,可以在任意 模块中被访问和重写.
- public: 权限仅次于 open，和 open 唯一的区别是: 不允许其他模块进行继承、重写
- internal: 默认权限, 只允许在当前的模块中访问，可以继承和重写,不允许在其他模块中访问
- fileprivate: 修饰的对象只允许在当前的文件中访问;
- private: 最低级别访问权限,只允许在定义的作用域内访问
关键字:Strong,Weak,Unowned 区别?
Swift 的内存管理机制同OC一致,都是ARC管理机制; Strong,和 Weak用法同OC一样
Unowned(无主引用), 不会产生强引用，实例销毁后仍然存储着实例的内存地址(类似于OC中的unsafe_unretained), 试图在实例销毁后访问无主引用，会产生运行时错误(野指针)
如何理解copy-on-write?
值类型(比如:struct),在复制时,复制对象与原对象实际上在内存中指向同一个对象,当且仅当修改复制的对象时,才会在内存中创建一个新的对象,
- 为了提升性能，Struct, String、Array、Dictionary、Set采取了Copy On Write的技术
- 比如仅当有“写”操作时，才会真正执行拷贝操作
- 对于标准库值类型的赋值操作，Swift 能确保最佳性能，所有没必要为了保证最佳性能来避免赋值
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.0
print(try! divide(2, 0))
// 崩溃
什么是属性观察?
属性观察是指在当前类型内对特性属性进行监测,并作出响应,属性观察是 swift 中的特性,具有2种, willset 和 didset
var title: String {
willSet {
print("willSet", newValue)
}
didSet {
print("didSet", oldValue, title)
}
}
- willSet会传递新值，默认叫newValue
- didSet会传递旧值，默认叫oldValue
- 在初始化器中设置属性值不会触发willSet和didSet
swift 为什么将 String,Array,Dictionary设计为值类型?
- 值类型和引用类型相比,最大优势可以高效的使用内存,值类型在栈上操作,引用类型在堆上操作,栈上操作仅仅是单个指针的移动,而堆上操作牵涉到合并,位移,重链接,Swift 这样设计减少了堆上内存分配和回收次数,使用 copy-on-write将值传递与复制开销降到最低
如何将Swift 中的协议(protocol)中的部分方法设计为可选(optional)?
- 在协议和方法前面添加
@objc,然后在方法前面添加optional关键字,改方式实际上是将协议转为了OC的方式
@objc protocol someProtocol {
@objc optional func test()
}
- 使用扩展(extension),来规定可选方法,在 swift 中,协议扩展可以定义部分方法的默认实现
protocol someProtocol {
func test()
}
extension someProtocol{
func test() {
print("test")
}
}
比较Swift 和OC中的初始化方法 (init) 有什么不同?
swift 的初始化方法,更加严格和准确, swift初始化方法需要保证所有的非optional的成员变量都完成初始化, 同时 swfit 新增了convenience和 required两个修饰初始化器的关键字
- convenience只提供一种方便的初始化器,必须通过一个指定初始化器来完成初始化
- required是强制子类重写父类中所修饰的初始化方法
比较 Swift和OC中的 protocol 有什么不同?
- Swift 和OC中的 protocol相同点在于: 两者都可以被用作代理;
- 不同点: Swift中的 protocol还可以对接口进行抽象,可以实现面向协议,从而大大提高编程效率,Swift中的protocol可以用于值类型,结构体,枚举;
swift 和OC 中的自省 有什么区别?
自省在OC中就是判断某一对象是否属于某一个类的操作,有以下2中方式
[obj iskinOfClass:[SomeClass class]]
[obj isMemberOfClass:[SomeClass class]]
在 Swift 中由于很多 class 并非继承自 NSObject, 故而 Swift 使用 is 来判断是否属于某一类型, is 不仅可以作用于class, 还是作用于enum和struct
什么是函数重载? swift 支不支持函数重载?
- 函数重载是指: 函数名称相同,函数的参数个数不同, 或者参数类型不同,或参数标签不同, 返回值类型与函数重载无关
- swift 支持函数重载
swift 中的枚举,关联值 和 原始值的区分?
-
关联值--有时会将枚举的成员值跟其他类型的变量关联存储在一起，会非常有用
// 关联值 enum Date { case digit(year: Int, month: Int, day: Int) case string(String) } -
原始值--枚举成员可以使用相同类型的默认值预先关联，这个默认值叫做:原始值
// 原始值 enum Grade: String { case perfect = "A" case great = "B" case good = "C" case bad = "D" }
swift 中的闭包结构是什么样子的?
{
(参数列表) -> 返回值类型 in 函数体代码
}
什么是尾随闭包?
- 将一个很长的闭包表达式作为函数的最后一个实参
- 使用尾随闭包可以增强函数的可读性
- 尾随闭包是一个被书写在函数调用括号外面(后面)的闭包表达式
// fn 就是一个尾随闭包参数
func exec(v1: Int, v2: Int, fn: (Int, Int) -> Int) {
print(fn(v1, v2))
}
// 调用
exec(v1: 10, v2: 20) {
$0 + $1
}
什么是逃逸闭包?
当闭包作为一个实际参数传递给一个函数或者变量的时候，我们就说这个闭包逃逸了，可以在形式参数前写 @escaping 来明确闭包是允许逃逸的。
- 非逃逸闭包、逃逸闭包，一般都是当做参数传递给函数
- 非逃逸闭包:闭包调用发生在函数结束前，闭包调用在函数作用域内
- 逃逸闭包:闭包有可能在函数结束后调用，闭包调用逃离了函数的作用域，需要通过@escaping声明
// 定义一个数组用于存储闭包类型
var completionHandlers: [() -> Void] = []
// 在方法中将闭包当做实际参数,存储到外部变量中
func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
completionHandlers.append(completionHandler)
}
如果你不标记函数的形式参数为 @escaping ，你就会遇到编译时错误。
什么是自动闭包?
自动闭包是一种自动创建的用来把作为实际参数传递给函数的表达式打包的闭包。它不接受任何实际参数，并且当它被调用时，它会返回内部打包的表达式的值。这个语法的好处在于通过写普通表达式代替显式闭包而使你省略包围函数形式参数的括号。
func getFirstPositive(_ v1: Int, _ v2: @autoclosure () -> Int) -> Int? {
return v1 > 0 ? v1 : v2()
}
getFirstPositive(10, 20)
- 为了避免与期望冲突，使用了@autoclosure的地方最好明确注释清楚:这个值会被推迟执行
- @autoclosure 会自动将 20 封装成闭包 { 20 }
- @autoclosure 只支持 () -> T 格式的参数
- @autoclosure 并非只支持最后1个参数
- 有@autoclosure、无@autoclosure，构成了函数重载
如果你想要自动闭包允许逃逸，就同时使用 @autoclosure 和 @escaping 标志。
swift中, 存储属性和计算属性的区别?
Swift中跟实例对象相关的属性可以分为2大类
存储属性(Stored Property)
- 类似于成员变量这个概念
- 存储在实例对象的内存中
- 结构体、类可以定义存储属性
- 枚举不可以定义存储属性
计算属性(Computed Property)
- 本质就是方法(函数)
- 不占用实例对象的内存
- 枚举、结构体、类都可以定义计算属性
struct Circle {
// 存储属性
var radius: Double
// 计算属性
var diameter: Double {
set {
radius = newValue / 2
}
get {
return radius * 2
}
}
}
什么是延迟存储属性(Lazy Stored Property)?
使用lazy可以定义一个延迟存储属性，在第一次用到属性的时候才会进行初始化(类似OC中的懒加载)
- lazy属性必须是var，不能是let
- let必须在实例对象的初始化方法完成之前就拥有值
- 如果多条线程同时第一次访问lazy属性
- 无法保证属性只被初始化1次
class PhotoView {
// 延迟存储属性
lazy var image: Image = {
let url = "https://...x.png"
let data = Data(url: url)
return Image(data: data)
}()
}
什么是属性观察器?
可以为非lazy的var存储属性设置属性观察器,通过关键字willSet和didSet来监听属性变化
struct Circle {
var radius: Double {
willSet {
print("willSet", newValue)
}
didSet {
print("didSet", oldValue, radius)
}
}
init() {
self.radius = 1.0
print("Circle init!")
}
}
swift中什么类型属性(Type Property)?
严格来说，属性可以分为
实例属性(Instance Property): 只能通过实例对象去访问
- 存储实例属性(Stored Instance Property):存储在实例对象的内存中，每个实例对象都有1份
- 计算实例属性(Computed Instance Property)
类型属性(Type Property):只能通过类型去访问
- 存储类型属性(Stored Type Property):整个程序运行过程中，就只有1份内存(类似于全局变量)
- 计算类型属性(Computed Type Property)
可以通过static定义类型属性 p如果是类，也可以用关键字class
struct Car {
static var count: Int = 0
init() {
Car.count += 1
}
}
不同于存储实例属性，你必须给存储类型属性设定初始值
- 因为类型没有像实例对象那样的init初始化器来初始化存储属性
存储类型属性默认就是lazy，会在第一次使用的时候才初始化
- 就算被多个线程同时访问，保证只会初始化一次
- 存储类型属性可以是let
枚举类型也可以定义类型属性(存储类型属性、计算类型属性)
26. swift 中如何使用单例模式?
可以通过类型属性+let+private 来写单例; 代码如下如下:
public class FileManager {
public static let shared = {
// ....
// ....
return FileManager()
}()
private init() { }
}
swift 中的下标是什么?
- 使用subscript可以给任意类型(枚举、结构体、类)增加下标功能，有些地方也翻译为:下标脚本
- subscript的语法类似于实例方法、计算属性，本质就是方法(函数)
使用如下:
class Point {
var x = 0.0, y = 0.0
subscript(index: Int) -> Double {
set {
if index == 0 {
x = newValue
} else if index == 1 {
y = newValue }
}
get {
if index == 0 {
return x
} else if index == 1 {
return y
}
return 0
}
}
}
var p = Point()
// 下标赋值
p[0] = 11.1
p[1] = 22.2
// 下标访问
print(p.x) // 11.1
print(p.y) // 22.2
简要说明Swift中的初始化器?
- 类、结构体、枚举都可以定义初始化器
- 类有2种初始化器:
指定初始化器(designated initializer)、便捷初始化器(convenience initializer)
// 指定初始化器
init(parameters) {
statements
}
// 便捷初始化器
convenience init(parameters) {
statements
}
规则:
- 每个类至少有一个指定初始化器，指定初始化器是类的主要初始化器
- 默认初始化器总是类的指定初始化器
- 类偏向于少量指定初始化器，一个类通常只有一个指定初始化器
初始化器的相互调用规则
- 指定初始化器必须从它的直系父类调用指定初始化器
- 便捷初始化器必须从相同的类里调用另一个初始化器
- 便捷初始化器最终必须调用一个指定初始化器
什么可选链?
可选链是一个调用和查询可选属性、方法和下标的过程，它可能为 nil 。如果可选项包含值，属性、方法或者下标的调用成功；如果可选项是 nil ，属性、方法或者下标的调用会返回 nil 。多个查询可以链接在一起，如果链中任何一个节点是 nil ，那么整个链就会得体地失败。
- 多个?可以链接在一起
- 如果链中任何一个节点是nil，那么整个链就会调用失败
Self 的使用场景
Self 通常在协议中使用, 用来表示实现者或者实现者的子类类型.
例如, 定义一个复制的协议
protocol CopyProtocol {
func copy() -> Self
}
如果是结构体去实现, 要将Self 换为具体的类型
struct SomeStruct: CopyProtocol {
let value: Int
func copySelf() -> SomeStruct {
return SomeStruct(value: self.value)
}
}
dynamic framework 和 static framework 的区别是什么
静态库和动态库, 静态库是每一个程序单独打包一份, 而动态库则是多个程序之间共享
高阶
Swift - 高阶函数介绍（map、flatMap、filter、reduce）
Swift 提供了如下几个高阶函数： map、 flatMap、 filter、 reduce。使用高阶函数进行函数式编程不仅可以简化我们的代码，而且当数据比较大的时候，高阶函数会比传统实现更快，因为它可以并行执行（如运行在多核上）。
一. map 函数
方法介绍
map 方法获取一个闭包表达式作为其唯一参数。 数组中的每一个元素调用一次该闭包函数，并返回该元素所映射的值。
简单说就是数组中每个元素通过某个方法进行转换，最后返回一个新的数组。
使用样例
(1)下面将 Int 类型数组），转换成 String 类型的数组, 并且前面拼接上, "Swift"
bash 代码解读复制代码let ins = [2, 3, 4]
let strs = ins.map ({ "Swift($0)" })
print (strs) /// ["Swift2", "Swift3", "Swift4"]
(2）对一个数组里面的数据进行平方操作
ini 代码解读复制代码let values = [2, 3, 4]
let squares = values.map ({ 0 })
print (squares) ///[4, 9, 16]
二、flatMap 函数
方法介绍
flatMap 方法同 map 方法比较类似，只不过它返回后的数组中不存在 nil（自动把 nil 给剔除掉），同时它会把 Optional 解包。
使用样例
(1）下面比较 map 和 flatMap 这两个方法
swift 代码解读复制代码let array = [ "Blue" , "red" , "Green" , "" ]
let arr1 = array.map { a -> Int? in
let length = a.count
guard length > 0 else { return nil }
return length
}
print ( "arr1:(arr1)" )
let arr2 = array.flatMap { a-> Int? in
let length = a.count
guard length > 0 else { return nil }
return length
}
print ( "arr2:(arr2)" )
/// arr1:[Optional(4), Optional(3), Optional(5), nil]
/// arr2:[4, 3, 5]
swift 代码解读复制代码flatMap:
注意：4.1之后如果闭包中返回的值是可选的话，就要使用compactMap代替flatMap了，不然的话就会警告。
@available(swift, deprecated: 4.1, renamed: "compactMap(:)", message: "Please use compactMap(:) for the case where closure returns an optional value")
（2） flatMap 还能把数组中存有数组的数组（二维数组、N维数组）一同打开组装成一个新的数组。
ini 代码解读复制代码let array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
let arr1 = array.map { 0 }
print(arr1)
print(arr2)
///[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
///[1, 2, 3, 4, 5, 6, 7, 8, 9]
三、filter 函数
方法介绍
filter 方法用于过滤元素，即筛选出数组元素中满足某种条件的元素。
2，使用样例
（1）筛选出金额大于 10 的元素。
ini 代码解读复制代码let prices = [2, 15, 23]
let result = prices.filter ({ $0 > 10 })
print (result) // [15, 23]
四、reduce 函数
方法介绍
reduce 方法把数组元素组合计算为一个值，并且会接受一个初始值，这个初始值的类型可以和数组元素类型不同。
将数组中的金额相加，计算总和。
bash 代码解读复制代码let prices = [20,30,40]
let sum = prices.reduce(0) { 1 }
// 可以简化为 let sum = prices.reduce(0, +)
print (sum) ///90
