Please enable JavaScript.

Coggle requires JavaScript to display documents.

SwiftTips_从OC/C到Swift (1.3 (动态类型和多方法 Swift 默认情况下是不采用动态派发的，因此方法的调用只能在编译时决…

SwiftTips_从OC/C到Swift

1.3

动态类型和多方法

Swift 默认情况下是不采用动态派发的，因此方法的调用只能在编译时决定

单例

class MyManager  {
    static let shared = MyManager()
    private init() {}
}
这种写法不仅简洁，而且保证了单例的独一无二。在初始化类变量的时候，Apple 将会把这个初始化包装在一次 swift_once_block_invoke 中，以保证它的唯一性。不仅如此，对于所有的全局变量，Apple 都会在底层使用这个类似 dispatch_once 的方式来确保只以 lazy 的方式初始化一次。

另外，我们在这个类型中加入了一个私有的初始化方法，来覆盖默认的公开初始化方法，这让项目中的其他地方不能够通过 init 来生成自己的 MyManager 实例，也保证了类型单例的唯一性。如果你需要的是类似 default 的形式的单例 (也就是说这个类的使用者可以创建自己的实例) 的话，可以去掉这个私有的 init 方法。

objc 和 dynamic

1.首先通过添加 {product-module-name}-Bridging-Header.h 文件，在其中填写想要使用的头文件名称，就能在在 Swift 中使用 OC 代码了。
2.想要在 OC 里使用项目中的 Swift 的源文件的话，导入自动生成的头文件 {product-module-name}-Swift.h 来完成。
3.对于项目来说，外界框架是由 Swift 写的还是 Objective-C 写的，两者并没有太大区别。使用@import 来引入即可。

Selector

在 Swift 中没有 @selector 了，取而代之 #selector 
类似地，在 Swift 里原来 SEL 的类型是一个叫做 Selector 的结构体。
在 Swift 4 中，默认所有方法在 OC 中都是不可见的，需要在前面加上 @objc 关键字

条件编译

在 C 系语言中，可以使用 #if 或者 #ifdef 之类的编译条件分支来控制哪些代码需要编译，而哪些代码不需要。
  #if DEBUGE
  #else
  #endif

用 DEBUGE 这个编译符号来代表测试接口版本。需要在项目的编译选项中Build Settings 中，找到 Swift Compiler - Custom Flags，并在其中的 Other Swift Flags 加上 -D DEBUGE 就可以了。

Protocol Extension

Swift 中标准库的功能基本都是基于 protocol 来实现的
protocol extension 为 protocol 中定义的方法提供了一个默认的实现。
使用场景：给某个协议的所有类型添加一些共通的功能时
1.如果类型推断得到的是实际的类型：
那么类型中的实现将被调用；如果类型中没有实现的话，那么协议扩展中的默认实现将被使用。
2.如果类型推断得到的是协议，而不是实际类型：
并且方法在协议中进行了定义，那么类型中的实现将被调用；如果类型中没有实现，那么协议扩展中的默认实现被使用
否则 (也就是方法没有在协议中定义)，扩展中的默认实现将被调用

内存管理，weak 和 unowned”

所有的自动引用计数机制都有一个从理论上无法绕过的限制，那就是循环引用 (retain cycle) 的情况。
Apple 建议是能够确定在访问时不会已被释放的话，使用 unowned，如果存在被释放的可能，那就用 weak。[weak self]

autoreleasepool

在 app 中，整个主线程其实是跑在一个自动释放池里的，并且在每个主 Runloop 结束时进行 drain 操作。这是一种必要的延迟释放的方式，因为我们有时候需要确保在方法内部初始化的生成的对象在被返回后别人还能使用，而不是立即被释放掉。

OC 中建立一个自动释放池使用 @autoreleasepool 就行了
Swift中变成一个方法：func autoreleasepool(code: () -> ())

String 还是 NSString

1.尽可能的话还是使用原生的 String 类型。原因：Swift 中 String 是 struct，相比 NSObject 的 NSString 类来说，更切合字符串的 "不变" 特性。配合常量赋值 (let) ，在多线程编程时就非常重要了，它从原理上将程序员从内存访问和操作顺序的担忧中解放出来。另外，在不触及 NSString 特有操作和动态特性的时候，使用 String 的方法，在性能上也会有所提升。

2.我们更愿意和基于 Int 的 NSRange 一起工作，而不喜欢使用麻烦的 Range<String.Index>。这种情况下，将 String 转为 NSString 也许是个不错的选择

UnsafePointer(不安全、不建议使用)

指针在 Swift 中不被鼓励，语言标准中完全没有与指针完全等同的概念的。为了与 C 系帝国合作，Swift 定义了一套对 C 语言指针的访问和转换方法，那就是 UnsafePointer 和它的一系列变体。对于使用 C API 时如果遇到接受内存地址作为参数，或者返回是内存地址的情况，在 Swift 里会将它们转为 UnsafePointer<Type> 的类型， 

void method(const int *num) {
其对应的 Swift 方法应该是：
func method(_ num: UnsafePointer<CInt>) {

对于 C 中基础类型，在 Swift 中对应的类型都遵循统一的命名规则：在前面加上一个字母 C 并将原来的第一个字母大写：比如 int，bool 和 char 的对应类型分别是 CInt，CBool 和 CChar。在上面的 C 方法中，我们接受一个 int 的指针，转换到 Swift 里所对应的就是一个 CInt 的 UnsafePointer 类型。这里原来的 C API 中已经指明了输入的 num 指针的不可变的 (const)，因此在 Swift 中我们与之对应的是 UnsafePointer 这个不可变版本。如果只是一个普通的可变指针的话，我们可以使用 UnsafeMutablePointer 来对应：

在 C 中，对指针取值用 *，而Swift 中用 memory 属性来读取相应内存中存储的内容。通过传入指针地址进行方法调用的时候就都比较相似了，都是在前面加上 & 符号，C 的版本和 Swift 的版本只在声明变量的时候有所区别：
//C
int a = 123;
//Swift
var a: CInt = 123

后半部

KeyPath 和 KVO

KVO 的目的并不是为当前类的属性提供一个钩子方法，而是为了其他不同实例对当前的某个属性 (严格来说是 keypath) 进行监听时使用的。
KVO 仅限于在 NSObject 的子类中，因为 KVO 是基于 KVC (Key-Value Coding) 以及动态派发技术实现的，而这些东西都是 Objective-C 运行时的概念。另外由于 Swift 为了效率，默认禁用了动态派发，因此想用 Swift 来实现 KVO，我们还需要做额外的工作，那就是将想要观测的对象标记为 dynamic 和 @objc。
Swift 4 中 Apple 引入了新的 KeyPath 的表达方式:
var observation: NSKeyValueObservation?

observation = myObject.observe(\MyClass.date, options: [.new]) { (_, change) in
            if let newDate = change.newValue {
                print("AnotherClass 日期发生变化 \(newDate)")
            }
        }

非 NSObject 的 Swift 类型：因为 Swift 类型并没有通过 KVC 进行实现，所以更不用谈什么对属性进行 KVO 了。语言中现在暂时还没有原生的类似 KVO 的观察机制。我们可能只能通过属性观察来实现一套自己的类似替代了

局部 scope

C 系语言中在方法内部我们是可以任意添加成对的大括号 {} 来限定代码的作用范围的。两个好处，首先是超过作用域后里面的临时变量就将失效，这不仅使方法内的命名更加容易，也使得那些不被需要的引用的回收提前进行了，可以稍微提高一些代码的效率；
Swift 中，直接使用大括号的写法是不支持的，因为这和闭包的定义产生了冲突。如果我们想类似地使用局部 scope 来分隔代码的话，一个不错的选择是定义一个接受 ()->() 作为函数的全局方法，然后执行它：
func local(_ closure: ()->()) {
Swift 2.0 为了处理异常，Apple 加入了 do 关键字来作为捕获异常的作用域。这一功能恰好为我们提供了一个完美的局部作用域，现在我们可以简单地使用 do 来分隔代码了：
do {

}
在 OC 中一个技巧是使用 GNU C 的声明扩展来在限制局部作用域的时候同时进行赋值，运用得当的话，可以使代码更加紧凑和整洁。在 OC 中可以写为：

self.titleLabel = ({
    UILabel *label = [[UILabel alloc]
    label;
});

Swift 里当然没有 GNU C 的扩展，但是使用匿名的闭包的话，写出类似的代码也不是难事：
let titleLabel: UILabel = {
    let label = UILabel(frame: CGRect(x: 150, y: 30, width: 200, height: 40))

    return label
}()

自省/类型判断

对于不确定的类型，我们使用 is 来进行判断。is 在功能上相当于原来的 isKindOfClass，检查一个对象是否属于某类型或其子类型。is 和原来的区别在于，不仅可以用于 class 类型上，也可以对 Swift 的其他像是 struct 或 enum 类型进行判断。

判等

在 Objective-C 中 == 这个符号的意思是判断两个对象是否指向同一块内存地址。
OC 中使用 == 进行的对象指针的判定，Swift 中是 ===。在 Swift 中 === 只有一种重载：
func ===(lhs: AnyObject?, rhs: AnyObject?) -> Bool
它用来判断两个 AnyObject 是否是同一个引用。

类簇

在 OC 中，init 开头的初始化方法实际做的事情和其他方法并没无不同。类簇在 OC 中实现起来很自然，在所谓的“初始化方法”中将 self 进行替换，根据调用的方式或者输入的类型，返回合适的私有子类对象就可以了。
Swift 中的情况不同。因为 Swift 拥有真正的初始化方法，在初始化的时候我们只能得到当前类的实例，并且要完成所有的配置。也就是说对于一个公共类来说，是不可能在初始化方法中返回其子类的信息的。对于 Swift 中的类簇构建，一种有效的方法是使用工厂方法来进行。

Options

通过 typedef 的定义，可以使用 NS_OPTIONS 来把 UIViewAnimationOptions 映射为每一位都不同的一组 NSUInteger。不需要特殊的选项的话，使用 kNilOptions ，它被定义为数字 0。

OptionSetType 是实现了 SetAlgebraType 的，因此我们可以对两个集合进行各种集合运算，包括并集 (union)、交集 (intersect) 等等。另外，对于不需要选项输入的情况，也就是对应原来的 kNilOptions，现在我们直接使用一个空的集合 [] 来表示

delegate

因为 Swift 的 protocol 可以被除了 class 以外的其他类型遵守的，而对于像 struct 或是 enum 这样的类型，本身就不通过引用计数来管理内存，所以也不可能用 weak 这样的 ARC 的概念来进行修饰。

想要在 Swift 中使用 weak delegate，我们就需要将 protocol 限制在 class 内。一种做法是将 protocol 声明为 Objective-C 的，这可以通过在 protocol 前面加上 @objc 关键字来达到，Objective-C 的 protocol 都只有类能实现，因此使用 weak 来修饰就合理了：
@objc protocol MyClassDelegate {
或者
protocol MyClassDelegate: class {

Lock

@synchronized 在幕后做的事情是调用了 objc_sync 中的 objc_sync_enter 和 objc_sync_exit 方法，并且加入了一些异常判断。
func synchronized(_ lock: AnyObject, closure: () -> ()) {
    objc_sync_enter(lock)
    closure()
    objc_sync_exit(lock)
}