iOS-Swift-从OC到Swift

一. MARK、TODO、FIXME

// MARK: 类似于OC中的 #pragma mark
// MARK: - 类似于OC中的 #pragma mark -
// TODO: 用于标记未完成的任务 
// FIXME: 用于标记待修复的问题
#warning("里面写警告的东西")

MARK.png TODO、FIXME.png

二. 条件编译、打印、系统版本检测、API可用性说明

1. 条件编译

• 一些判断

// 操作系统：macOS\iOS\tvOS\watchOS\Linux\Android\Windows\FreeBSD
#if os(macOS) || os(iOS)
// CPU架构：i386\x86_64\arm\arm64
#elseif arch(x86_64) || arch(arm64)
// swift版本
#elseif swift(<5) && swift(>=3)
// 模拟器
#elseif targetEnvironment(simulator)
// 可以导入某模块
#elseif canImport(Foundation)
#else
#endif

• 系统默认DEBUG标记

#if DEBUG // debug模式

#else // release模式

#endif

• 自定义标记

自定义方法一：
DEBUG后加空格加TEST
自定义方法二：
-D加空格加OTHER

添加方法如下图：

自定义标记.png

代码使用如下：

#if TEST
print("test")
#endif

#if OTHER
print("other")
#endif

2. 打印

//#file、#line、#function获取的是当前函数的执行环境（文件路径、行号、方法名），当成默认参数传进去
func log<T>(_ msg: T,
            file: NSString = #file, //告诉它是个OC字符串，就可以使用lastPathComponent
            line: Int = #line,
            fn: String = #function) {
    #if DEBUG
    let prefix = "\(file.lastPathComponent)_\(line)_\(fn):"
    print(prefix, msg)
    #endif
}

3. 系统版本检测

if #available(iOS 10, macOS 10.12, *) {
    // 对于iOS平台，只在iOS10及以上版本执行
    // 对于macOS平台，只在macOS10.12及以上版本执行
    // 最后的*代表包含了所有的平台
}

4. API可用性说明

@available(iOS 10, macOS 10.15, *) //Person类只有在iOS10及以上才可用
class Person {}

struct Student {
    @available(*, unavailable, renamed: "study") //study_已经改名为study
    func study_() {}
    func study() {}
    
    @available(iOS, deprecated: 11) //run方法在iOS11已废弃
    @available(macOS, deprecated: 10.12) //run方法在macOS10.12已废弃
    func run() {}
}

更多用法参考：https://docs.swift.org/swift-book/ReferenceManual/Attributes.html

三. iOS程序的入口

在AppDelegate上面默认有个@UIApplicationMain标记，这表示编译器自动生成入口代码（main函数代码），自动设置AppDelegate为APP的代理。

如果以后需要⾃定义UIApplication的时候，可以删掉@UIApplicationMain，新建一个main.swift文件，把⾃定义的Application传进去，main.swift代码如下：

iOS程序的入口.png

四. Swift调用OC

1. 新建一个桥接头文件，文件名格式默认为：{targetName}-Bridging-Header.h（或者直接创建OC的类Xcode会⾃动提示创建桥接⽂件）

2. 设置桥接文件路径，如下图：

Swift调用OC.png

在 {targetName}-Bridging-Header.h 文件中 #import OC需要暴露给Swift的内容，例如：

#import "MJPerson.h"

OC文件代码如下：
MJPerson.h

int sum(int a, int b); //C语言函数

@interface MJPerson : NSObject
@property (nonatomic, assign) NSInteger age;
@property (nonatomic, copy) NSString *name;

- (instancetype)initWithAge:(NSInteger)age name:(NSString *)name;
+ (instancetype)personWithAge:(NSInteger)age name:(NSString *)name;

- (void)run;
+ (void)run;

- (void)eat:(NSString *)food other:(NSString *)other;
+ (void)eat:(NSString *)food other:(NSString *)other;
@end

MJPerson.m

@implementation MJPerson
- (instancetype)initWithAge:(NSInteger)age name:(NSString *)name {
    if (self = [super init]) {
        self.age = age;
        self.name = name;
    }
    return self;
}
+ (instancetype)personWithAge:(NSInteger)age name:(NSString *)name {
    return [[self alloc] initWithAge:age name:name];
}

+ (void)run { NSLog(@"Person +run"); }
- (void)run { NSLog(@"%zd %@ -run", _age, _name); }

+ (void)eat:(NSString *)food other:(NSString *)other { NSLog(@"Person +eat %@ %@", food, other); }
- (void)eat:(NSString *)food other:(NSString *)other { NSLog(@"%zd %@ -eat %@ %@", _age, _name, food, other); }
@end

int sum(int a, int b) { return a + b; } //C语言函数

Swift调用OC：Swift代码

var p = MJPerson(age: 10, name: "Jack")
p.age = 18
p.name = "Rose"
p.run() // 18 Rose -run
p.eat("Apple", other: "Water") // 18 Rose -eat Apple Water

MJPerson.run() // Person +run
MJPerson.eat("Pizza", other: "Banana") // Person +eat Pizza Banana

print(sum(10, 20)) // 30

• @_silgen_name

如果C语言暴露给Swift的函数名跟Swift中的其他函数名冲突了，可以在Swift中使用@_silgen_name修改C函数名。
如上，MJPerson.m里面有个C语言函数sum，用来做加法的，下面Swift代码也有个sum方法是做减法的，我们可以通过@_silgen_name修改C函数名，防止重名

// Swift方法
func sum(_ a: Int, _ b: Int) -> Int { a - b }

// 把C语⾔的sum函数名改成swift_sum
@_silgen_name("sum") func swift_sum(_ v1: Int32, _ v2: Int32) -> Int32
print(swift_sum(10, 20)) // 30  调用的是C语言函数
print(sum(10, 20)) // -10  调用的是Swift方法

@_silgen_name使⽤场景：只要这个函数是存在的，⽆论有没有导⼊头⽂件，或者就算是底层的C函数也可以使用@_silgen_name重命名，然后调用

五. OC调用Swift

1. Xcode已经默认生成一个用于OC调用Swift的头文件，文件名格式是：{targetName}-Swift.h（这个文件是存在的，只不过你看不到，需要用的时候直接导入头文件就可以了）

2. 设置文件路径，如下图：

OC调用Swift.png

Swift类文件代码如下：
Car.swift

import Foundation

@objcMembers class Car: NSObject {
    var price: Double
    var band: String
    init(price: Double, band: String) {
        self.price = price
        self.band = band
    }
    func run() { print(price, band, "run") }
    static func run() { print("Car run") }
}

extension Car {
    func test() { print(price, band, "test")}
}

Swift的类要想暴露给OC，是有条件的，如下：

1. 想要在OC调⽤Swift必须导⼊头⽂件 {targetName}-Swift.h
2. Swift暴露给OC的类最终继承自NSObject
3. 使用@objc修饰需要暴露给OC的成员
4. 使用@objcMembers修饰类，代表默认所有成员都会暴露给OC（包括扩展中定义的成员），最终是否成功暴露，还需要考虑成员自身的访问级别

Xcode会根据Swift代码生成对应的OC声明，写入{targetName}-Swift.h文件，如下：

@interface Car : NSObject
@property (nonatomic) double price;
@property (nonatomic, copy) NSString * _Nonnull band;
- (nonnull instancetype)initWithPrice:(double)price band:(NSString * _Nonnull)band OBJC_DESIGNATED_INITIALIZER;
- (void)run;
+ (void)run;
- (nonnull instancetype)init SWIFT_UNAVAILABLE;
+ (nonnull instancetype)new SWIFT_UNAVAILABLE_MSG("-init is unavailable");
@end

//swift中的扩展,变成了OC中的分类
@interface Car (SWIFT_EXTENSION(备课_Swift))
- (void)test;
@end

OC调用Swift：OC代码

#import "备课_Swift-Swift.h"
int sum(int a, int b) {
    Car *c = [[Car alloc] initWithPrice:10.5 band:@"BMW"];
    c.band = @"Bently";
    c.price = 108.5;
    [c run]; // 108.5 Bently run
    [c test]; // 108.5 Bently test
    [Car run]; // Car run
    return a + b;
}

• 使用@objc重命名Swift的类

可以通过@objc重命名Swift暴露给OC的类名、属性名、函数名等

比如Swift代码如下：

@objc(MJCar) //修改类名
@objcMembers class Car: NSObject {
    var price: Double
    @objc(name) //修改属性名
    var band: String
    init(price: Double, band: String) {
        self.price = price
        self.band = band
    }
    @objc(drive) //修改方法名
    func run() { print(price, band, "run") }
    static func run() { print("Car run") }
}
extension Car {
    @objc(exec:v2:) //修改方法名
    func test() { print(price, band, "test") }
}

在OC中调用，如下：

MJCar *c = [[MJCar alloc] initWithPrice:10.5 band:@"BMW"];
c.name = @"Bently";
c.price = 108.5;
[c drive]; // 108.5 Bently run
[c exec:10 v2:20]; // 108.5 Bently test
[MJCar run]; // Car run

思考：

1. 为什么Swift暴露给OC的类最终要继承⾃NSObject？
   因为如果想要⾛OC的那⼀套，必须要使⽤isa，必须要⾛Runtime那⼀套，所以必须要继承于NSObject，因为NSObject有isa，纯Swift调⽤还是⾛虚表那⼀套。
2. Swift调⽤OC，底层是怎么调⽤的？
   例如:p.run() 还是⾛的OC的objc_msgSend和Runtime那⼀套。
   反过来，OC调⽤Swift底层⼜是如何调⽤？
   也是⾛的OC的objc_msgSend和Runtime那⼀套(因为Swift暴露给OC的必须要继承NSObject)。
3. 如果Swift暴露给OC的类，但是还在Swift中调⽤，那么⾛的还是Swift虚表那⼀套，并不是⾛OC，因为还在Swift中调⽤，没必要⾛OC（如果真的想走OC的Runtime那⼀套，可以加dynamic关键字）。

注意：Swift的类内存结构是：前8个字节放metadata类型相关，后8个字节放指针相关，后⾯再放成员变量信息。如果继承于NSObject，内存信息就变成了：前8个字节放isa指针相关，后⾯再放成员变量信息。

六. 选择器（Selector）

Swift中依然可以使用选择器，使用#selector(name)定义一个选择器，必须是被@objcMembers或@objc修饰的方法才可以定义选择器（因为selector这⼀套是依赖Runtime的，纯Swift是没有Runtime的，所以你要暴露给OC才可以使⽤selector）

@objcMembers class Person: NSObject {
    func test1(v1: Int) { print("test1") }
    func test2(v1: Int, v2: Int) { print("test2(v1:v2:)") }
    func test2(_ v1: Double, _ v2: Double) { print("test2(_:_:)") }
    func run() {
        perform(#selector(test1)) //只写方法名
        perform(#selector(test1(v1:))) //带标签
        perform(#selector(test2(v1:v2:))) //带标签
        perform(#selector(test2(_:_:))) //带标签
        perform(#selector(test2 as (Double, Double) -> Void)) //也可以强转成相应的⽅法类型
    }
}

七. String

Swift的字符串类型String，跟OC的NSString，在API设计上还是有较大差异

1. String的基本使用

// 空字符串
var emptyStr1 = ""
var emptyStr2 = String()

var str = "123456"
print(str.hasPrefix("123")) // true
print(str.hasSuffix("456")) // true

var str: String = "1"
// 拼接，jack_rose
str.append("_2")
// 重载运算符 +
str = str + "_3"
// 重载运算符 +=
str += "_4"
// \()插值
str = "\(str)_5"
// 长度，9，1_2_3_4_5
print(str.count)

2. String的插入和删除

比如：var str = "1_2"，startIndex代表的就是1（第一位），endIndex代表的就是2（最后一位），如下：

var str = "1_2"
// 1_2_
str.insert("_", at: str.endIndex)
// 1_2_3_4
str.insert(contentsOf: "3_4", at: str.endIndex)
// 1666_2_3_4
str.insert(contentsOf: "666", at: str.index(after: str.startIndex))
// 1666_2_3_8884
str.insert(contentsOf: "888", at: str.index(before: str.endIndex))
// 1666hello_2_3_8884
str.insert(contentsOf: "hello", at: str.index(str.startIndex, offsetBy: 4))
// 666hello_2_3_8884
str.remove(at: str.firstIndex(of: "1")!)
// hello_2_3_8884
str.removeAll { $0 == "6" }
var range = str.index(str.endIndex, offsetBy: -4)..<str.index(before: str.endIndex)
// hello_2_3_4
str.removeSubrange(range)

3. Substring

String可以通过下标、prefix、suffix等截取子串，子串类型不是String，而是Substring

var str = "1_2_3_4_5"
// 1_2 var
substr1 = str.prefix(3)
// 4_5
var substr2 = str.suffix(3)
// 1_2
var range = str.startIndex..<str.index(str.startIndex, offsetBy: 3)
var substr3 = str[range]
// 最初的String，1_2_3_4_5
print(substr3.base)
// Substring -> String
var str2 = String(substr3)

Substring和它的base，共享字符串数据。Substring发生修改或者转为String时，会分配新的内存存储字符串数据，如下：

Substring.png

解释：如果subString没有修改，⽐如append数据，那么就会共⽤数据，并没有深拷⻉，如果subString修改了，就会深拷贝，不共⽤数据了。

4. String与Character

for c in "jack" { // c是Character类型
    print(c)
}
    
var str = "jack"
// c是Character类型
var c = str[str.startIndex]

5. String相关的协议

• BidirectionalCollection 协议包含的部分内容：
  startIndex 、 endIndex 属性、index 方法
  String、Array 都遵守了这个协议

• RangeReplaceableCollection 协议包含的部分内容：
  append、insert、remove 方法
  String、Array 都遵守了这个协议

• Dictionary、Set 也有实现上述协议中声明的一些方法，只是并没有遵守上述协议

6. 多行String

1. 多行String使用

let str = """
1
    "2"
3
    '4'
"""
print(str)
//1
//    "2"
//3
//    '4'

2. 缩进以结尾的三引号为对齐线

let str2 = """
        1
            2
    3
        4
    """
print(str2)
//    1
//        2
//3
//    4

3. 如果要显示三引号，至少转义一个引号

let str3 = """
Escaping the first quote \"""
Escaping two quotes \"\""
Escaping all three quotes \"\"\"
"""
print(str3)
//Escaping the first quote """
//Escaping two quotes """
//Escaping all three quotes """

4. 只有一行的多行String就等于单行String

以下两个字符串是等价的

let str4 = "These are the same."
let str5 = """
These are the same.
"""
print(str4)
print(str5)
//These are the same.
//These are the same.

7. String与NSString

String 与 NSString 之间可以随时随地桥接转换，如果你觉得String的API过于复杂难用，可以考虑将String转为NSString

var str1: String = "jack"
var str2: NSString = "rose"

var str3 = str1 as NSString
var str4 = str2 as String

// ja
var str5 = str3.substring(with: NSRange(location: 0, length: 2))
print(str5)

• 比较字符串内容是否等价：
  如果是String，使用 == 运算符
  如果是NSString，使用isEqual方法，也可以使用 == 运算符（本质还是调用了isEqual方法）

8. Swift、OC通过as桥接转换表

as桥接转换.png

String也可以转换成NSMutableString，但是不是通过as桥接，可以通过⾃带的初始化⽅法转换，如下：

var str = “123456” 
var str2 = NSMutableString(String:str) 

八. 关于协议

protocol Runnable1: AnyObject {}
protocol Runnable2: class {}
@objc protocol Runnable3 {}

1. Runnable1、Runnable2都是只能被类遵守的协议
2. Runnable3是被@objc修饰的协议，可以暴露给OC去遵守实现
3. 可以通过 @objc optional 定义可选协议，这种协议只能被类遵守，如下：

@objc protocol Runnable {
    func run1()
    @objc optional func run2()
    func run3()
}

class Dog: Runnable {
    func run3() { print("Dog run3") }
    func run1() { print("Dog run1") }
}

var d = Dog()
d.run1() // Dog run1
d.run3() // Dog run3

总结：
① 以前我们说过，可以给协议添加扩展，在扩展里面提供协议的默认实现，这样间接实现可选协议的效果
② 可以通过 @objc optional 定义可选协议，这种协议只能被类遵守，可以暴露给OC去遵守实现

补充：@objc dynamic

被 @objc dynamic 修饰的内容会具有动态性，比如调用方法会走runtime那一套流程

class Dog: NSObject {
    @objc dynamic func test1() {}
    func test2() {}
}

var d = Dog()
d.test1()
d.test2()

MJ老师通过窥探汇编，发现test1走的是objc_msgSend，test2走的是Swift虚表那一套，如下：

消息发送.png 虚表.png

九. KVC\KVO

Swift 支持 KVC \ KVO 的条件：

1. 属性所在的类、监听器最终继承自 NSObject
2. 用 @objc dynamic 修饰对应的属性

class Observer: NSObject {
    override func observeValue(forKeyPath keyPath: String?,
                               of object: Any?,
                               change: [NSKeyValueChangeKey : Any]?,
                               context: UnsafeMutableRawPointer?) {
        print("observeValue", change?[.newKey] as Any)
    }
}

class Person: NSObject {
    @objc dynamic var age: Int = 0
    var observer: Observer = Observer()
    override init() {
        super.init()
        self.addObserver(observer,
                         forKeyPath: "age",
                         options: .new,
                         context: nil)
    }
    deinit {
        self.removeObserver(observer, forKeyPath: "age")
    }
}
    
var p = Person()
// observeValue Optional(20)
p.age = 20
// observeValue Optional(25)
p.setValue(25, forKey: "age")

也可以使用block方式的KVO，如下：

class Person: NSObject {
    @objc dynamic var age: Int = 0
    var observation: NSKeyValueObservation?
    override init() {
        super.init()
        observation = observe(\Person.age, options: .new) {
            (person, change) in
            print(change.newValue as Any)
        }
    }
}
    
var p = Person()
// Optional(20)
p.age = 20
// Optional(25)
p.setValue(25, forKey: "age")

十. 关联对象（Associated Object）

在Swift中，class依然可以使用关联对象
默认情况，extension不可以增加存储属性(因为修改了类的内存结构)，借助关联对象，可以实现类似extension为class增加存储属性的效果

class Person {}
extension Person {
    private static var AGE_KEY: Void? //使⽤void?可选类型，只占⼀个字节，省内存啊
    var age: Int {
        get {
            (objc_getAssociatedObject(self, &Self.AGE_KEY) as? Int) ?? 0
        }
        set {
            //第⼀个key是对象本身，第⼆个key是&Self.AGE_KEY，通过这两个Key找到存储的值
            objc_setAssociatedObject(self,
                                     &Self.AGE_KEY, //取出newValues的地址值
                                     newValue, //就是外⾯传的值
                                     .OBJC_ASSOCIATION_ASSIGN)
        }
    }
}

var p = Person()
print(p.age) // 0
p.age = 10
print(p.age) // 10

十一. 资源名管理

Swift中可以使用枚举嵌套枚举进行资源名管理，这种做法实际上是参考了Android的资源名管理方式，如下：

enum R {
    enum string: String {
        case add = "添加"
    }
    enum image: String {
        case logo
    }
    enum segue: String {
        case login_main
    }
}

//扩展方法
extension UIImage {
    convenience init?(_ name: R.image) {
        self.init(named: name.rawValue) //name.RawValue拿到图⽚名字符串
    }
}

extension UIViewController {
    func performSegue(withIdentifier identifier: R.segue, sender: Any?) {
        performSegue(withIdentifier: identifier.rawValue, sender: sender)
    }
}

extension UIButton {
    func setTitle(_ title: R.string, for state: UIControl.State) {
        setTitle(title.rawValue, for: state)
    }
}

使用举例：

//原来的方式：
let img = UIImage(named: "logo")
let btn = UIButton(type: .custom)
btn.setTitle("添加", for: .normal)
performSegue(withIdentifier: "login_main", sender: self)

//现在的方式：
let img = UIImage(R.image.logo)
let btn = UIButton(type: .custom)
btn.setTitle(R.string.add, for: .normal)
performSegue(withIdentifier: R.segue.login_main, sender: self)

• 资源名管理的其他思路

//原来的方式
let img = UIImage(named: "logo")
let font = UIFont(name: "Arial", size: 14)

enum R {
    enum image {
        static var logo = UIImage(named: "logo")
    }
    enum font {
        static func arial(_ size: CGFloat) -> UIFont? {
            UIFont(name: "Arial", size: size)
        }
    }
}

let img = R.image.logo
let font = R.font.arial(14)

更多优秀的思路参考：
https://github.com/mac-cain13/R.swift
https://github.com/SwiftGen/SwiftGen

十二. 多线程开发

1. 异步任务

public typealias Task = () -> Void

public static func async(_ task: @escaping Task) {
    _async(task) //传入全局任务
}

public static func async(_ task: @escaping Task, _ mainTask: @escaping Task) {
    _async(task, mainTask) //传入全局任务，主队列任务
}

private static func _async(_ task: @escaping Task,
                           _ mainTask: Task? = nil) {
    let item = DispatchWorkItem(block: task)
    DispatchQueue.global().async(execute: item)
    if let main = mainTask {
        //item⾥⾯的任务完成之后，再到主队列执⾏
        item.notify(queue: DispatchQueue.main, execute: main)
    }
}

2. main延迟

@discardableResult //没⽤到返回值可以忽略，不会有警告
public static func delay(_ seconds: Double,
                         _ block: @escaping Task) -> DispatchWorkItem {
    let item = DispatchWorkItem(block: block)
    //在主线程延迟
    DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + seconds, execute: item)
    return item
}

3. 异步延迟

@discardableResult 
public static func asyncDelay(_ seconds: Double,
                              _ task: @escaping Task) -> DispatchWorkItem {
    return _asyncDelay(seconds, task)
}

@discardableResult
public static func asyncDelay(_ seconds: Double,
                              _ task: @escaping Task,
                              _ mainTask: @escaping Task) -> DispatchWorkItem {
    return _asyncDelay(seconds, task, mainTask)
}

private static func _asyncDelay(_ seconds: Double,
                                _ task: @escaping Task,
                                _ mainTask: Task? = nil) -> DispatchWorkItem {
    let item = DispatchWorkItem(block: task)
    //异步延迟
    DispatchQueue.global().asyncAfter(deadline: DispatchTime.now() + seconds, execute: item)
    if let main = mainTask {
        item.notify(queue: DispatchQueue.main, execute: main)
    }
    //为什么要返回item?
    //因为是延迟执⾏，⽐如3秒，如果在2秒的时候想要取消任务，就拿到item取消：item?.cancel()
    return item
}

4. once

dispatch_once在Swift中已被废弃，可使用类型属性、全局变量\常量（默认自带lazy + dispatch_once效果）。

类型属性、全局变量\常量，默认都是lazy，内部都会调⽤dispatch_once，保证线程安全的只执⾏⼀次。

fileprivate let initTask2: Void = { //全局常量
    print("initTask2---------")
}()

class ViewController: UIViewController { 
    static let initTask1: Void = { //类型属性
        print("initTask1---------")
    }()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        let _ = Self.initTask1
        let _ = initTask2
    }
}

5. 加锁

• gcd信号量

class Cache {
    private static var data = [String: Any]()
    //数字写⼏，表示同时有多少条线程访问他，⼀般写1
    private static var lock = DispatchSemaphore(value: 1)
    static func set(_ key: String, _ value: Any) {
        lock.wait() //加锁
        defer { lock.signal() } //解锁
        data[key] = value
    }
}

• Foundation框架中的锁

//这种会产⽣死锁，⽐如set⾥⾯⼜调⽤set
private static var lock = NSLock()
static func set(_ key: String, _ value: Any) {
    lock.lock()
    defer { lock.unlock() }
}

//使⽤递归锁，不会产⽣死锁
private static var lock = NSRecursiveLock()
static func set(_ key: String, _ value: Any) {
    lock.lock()
    defer { lock.unlock() }
}