一、背景
现在
Objective-C在Apple那儿现已是放养的孩子了，除了每年的修修补补，现已不再做大的改动，而Swift变成了亲儿子，每年一个大版别的更新，特别是Swift3.0版别之后，Swift现已趋于稳定，运用的用户已超过了Ojective-C，所以关于iOS开发者来说，把握Swift开发变成了必备的技能。
关于公司新项目来说能够直接上纯Swift项目，但关于一些老项目，留给开发者的就只有运用Swift
重构和混编两条路了，本文就针对混编要点讲解下一些实用的tips，以便在进行混编时分更好的运用。注(这儿只讲详细的小技巧，关于根底的混编环境网上许多，能够自己查找，这儿不做展开)。
二、常用混编tips
1、运用 @objc 润饰
假如Swift类里边的某个成员变量或许方噶想要露出给Objective-C调用，需求在前面加上 @objc
@objc let name: String
@objc func eat() {
print('aaa')
}
2、运用 @objcMembers 润饰类
运用Tip1办法，假如遇到多个成员变量和办法都需求露出，每个都加@objc显得太冗余，这时分能够运用 @objcMembers 润饰这个类，这样默许所有成员都会露出给OC(包含扩展中界说的成员)
终究是否成功露出，还需求考虑成员本身的访问等级（private、fileprivate不会露出）
@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") }
}
3、经过 @objc 重命名Swift露出给OC的类名、特点名、函数名等
由于Objective-C没有命名空间，所以类名一般都会加上前缀，而Swift则不需求，为了符合OC的运用习惯，能够将Swift的类重命名后露出给OC进行混编调用，这样运用起来就很nice了。
@objc(EHICar)
@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(newTest)
func test() { print(price, band, "test") }
}
重命名后在OC中的调用如下：
EHICar *car = [[EHICar alloc] initWithPrice:30 band:@"BMW"];
car.name = @"525LI";
[car drive];
[EHICar run];
4、挑选器
在Swift里边也能够运用挑选器，可是对应地办法有必要运用 @objc 润饰或许当时类被 @objcMembers 润饰才干运用。
@objcMembers class Car: NSObject {
func textSelector(str: String) {
print(str)
}
func run() {
perform(#selector(textSelector(str:)))
}
}
5、String与NSString
运用过Swift的应该都知道Swift在3.0版别对String进行了大改，API规划上和NSString有了很大的不同，如前缀、后缀、索引、Substring等：
var str = "123456"
func textPrint() {
print(str.hasPrefix("123")) // true
print(str.hasSuffix("456")) // true
print(str.prefix(3)) // 从最初截取三位，成果为：123
print(str.suffix(3)) // 从结尾截取三位，成果为：456
}
var str = "1_2"
func textStr() {
// 刺进 单个字符，成果是：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))
// 删去值为1的第一个索引的值，，成果是：666hello_2_3_8884
str.remove(at: str.firstIndex(of: "1")!)
// 删去值为字符为 6 的字符，成果是：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)
}
所以在混编的时分运用起来就很不方便了，这时分能够考虑将String转换为NSString运用。
6、协议
protocol对咱们来说都很了解了，可是OC中的协议对开发者有一个痛点便是，OC的协议严格来说只能说是接口，由于不能对协议中界说的办法进行默许的完成，详细的完成还需求依靠完成类，这样在运用时分就有很大的局限性。而Swift里边的协议相对来说就很强壮了，能够在 extension 中提供默许完成。所以在混编的时分能够运用Swift来界说协议(需求@objc润饰才干够在OC中运用)，然后在OC和Swift中进行运用，这样就很棒了。且假如是不用完成的函数，函数前要加上 @objc optional。
@objc protocol CarProtocol {
func run()
}
extension CarProtocol {
func run() {
print("Car run")
}
}
7、runtime
OC的东西在Swift里边调用，会调用了 runtime 那套机制；而Swift的东西在OC里边调用，咱们打断点看汇编能够发现调用的也是runtime那套机制，而关于swift里边自己的办法走的肯定是Swift的流程，假如咱们强行让它走OC那套runtime机制，能够在 run() 函数前加 dynamic。
class Car: NSObject {
@objc dynamic func run() {
printf("Car run")
}
}
8、swift中运用KVO
Swift 要运用 KVO ,有必要满意以下条件：
-
特点所在的类、监听器终究继承自 NSObject
-
用 @objc dynamic 润饰对应的特点
import Foundation
class Acount:NSObject {
dynamic var balance:Double = 0.0
}
class Person:NSObject {
var name:String
var account:Acount?{
didSet{
if account != nil {
account!.addObserver(self, forKeyPath: "balance", options: .Old, context: nil);
}
}
}
init(name:String){
self.name = name
super.init()
}
override func observeValueForKeyPath(keyPath: String, ofObject object: AnyObject, change: [NSObject : AnyObject], context: UnsafeMutablePointer) {
if keyPath == "balance" {
var oldValue = change[NSKeyValueChangeOldKey] as! Double
var newValue = (account?.balance)!
print("oldValue=\(oldValue),newValue=\(newValue)")
}
}
}
var p = Person(name: "Kenshin Cui")
var account = Acount()
account.balance = 10000000.0
p.account = account
p.account!.balance = 999999999.9 //成果：oldValue=10000000.0,newValue=999999999.9
9、枚举
OC假如想要调Swift中的枚举值时，Swift的枚举需求运用 @objc 进行润饰，然后OC就能够运用，需求留意的是，假如需求在OC中进行该枚举值的调用，书写规矩为枚举名+case的值。
注: Swift的枚举比OC强壮的许多，所以在混编时，需求界说为Int类型后，才干供OC调用。
@objc enum CarType: Int {
case baoma = 0
case benchi
}
OC调用该枚举值时，能够直接运用 CarType这个枚举，需求运用详细值时如 baoma这个值，能够直接运用 CarTypeBaoma，这个是swift编译器编译后的值，OC能够运用。
10、结构体
在oc中是不能调用struct里边的内容的，你想在类似class前面加个 @objc 的办法加在struct 前面是不行的，那可是咱们又想在oc中调用struct的特点，那怎么办呢？咱们只能够再建一个Swift的类，在类里写个办法来回来struct中的值
Swift代码如下：
struct CarStruct {
var name: String?
var price: Int?
init(name: String, price: Int) {
self.name = name
self.price = price
}
}
@objcMembers class CarClass: NSObject {
var car = CarStruct(name: "BMW", price: 30)
func getCarName() -> String {
return car.name ?? ""
}
func getCarPrice() -> Int {
return car.price ?? 0
}
}
在OC中调用结构领会提示找不到，所以能够运用
CarClass这个类来直接的运用CarStruct这个结构体。
@interface ViewController ()
//@property(nonatomic, strong) CarStruct car;
@property(nonatomic, strong) CarClass* car;
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view.
}
- (NSString *)getCarName {
return [self.car getCarName];
}
11、OC的block与Swift的闭包
在混编中，OC中的block在Swift中能够正常运用，Swift的闭包在OC中也是能够正常运用的，测试代码如下，能够看下：
- OC类：
@interface ViewController : UIViewController
@property (nonatomic, strong) void (^myblock) (NSString *name);
@property(nonatomic, strong) SwiftText *swiftVc;
@end
// 测试swift闭包
- (void)textSwiftClosures {
self.swiftVc = [[SwiftText alloc] init];
self.swiftVc.textClosures = ^{
printf("aaaaa");
};
}
- Swift类
@objcMembers class SwiftText: NSObject {
// OC类
var ocViewController: ViewController?
// 测试闭包
var textClosures = {}
override init() {
super.init()
}
func textOcBlock() {
self.ocViewController = ViewController()
self.ocViewController?.myblock = { name in
print(name ?? "")
}
}
}
12、OC中的宏
Swift 中是不能运用OC中的宏界说语法，Swift是有命名空间的，所以咱们能够将原本OC中不需求承受参数的宏，界说成 let常量或枚举，将需求承受参数的宏界说成函数。
- 如oc的宏：
#define kScreenHeight [UIScreen mainScreen].bounds.size.height
#define kScreenWidth [UIScreen mainScreen].bounds.size.width
- 在swift中界说为大局常量：
let kScreenHeight = UIScreen.main.bounds.height
let kScreenWidth = UIScreen.main.bounds.width
13、元组
元组是Swift特有的，在OC中是没有的，OC调用不了Swift中的元组，所以在Swift中关于OC可能用到的办法中，回来值和参数都不能是元组，Swift中OC可能用到的特点变量也不能是元组。
15、高阶函数
Swift 中界说的高阶函数(比方filter、map、redux等)，OC是不能调用的。
三、API混编适配
3.1、可选类型
3.1.1、关键字nonnull、nullable
Objective-C指针既能够是一个有效值，也能够是空值，例如 null 或许 nil，这与Swift里的可选值行为十分相似。
假如咱们再仔细想一下，就会发现在 Objective-C 里边，每个指针类型实际上都是可选类型，每个非指针类型都对错可选类型。可是大部分时刻，一个特点或许办法不会处理输入值是 nil 的情况，或许永远不会回来 nil。
所以，默许情况下 Swift 会把 Objective-C 里的指针当做隐式解析可选类型，由于它认为这个值大部分情况下不会是 nil，但它也不完全确定。
虽说这种转换规矩没什么毛病，但大量的隐式解析可选类型让代码变得目的模糊，好在咱们有两个关键字注解能够去描述这个目的，他们分别是 nonnull 和 nullable。这两个注解在 Objective-C 里边仅仅用于记录开发者的目的，不是强制的。但 Swift 会用到这些信息来决定是否转换为可选类型。
3.1.2、宏 NS_ASSUME_NONNULL_BEGIN、NS_ASSUME_NONNULL_END
除了
nonnull和nullable以外，还有一对配合运用的宏NS_ASSUME_NONNULL_BEGIN和NS_ASSUME_NONNULL_END能够让咱们的代码更简练。
在这两个宏包裹的代码片段中，特点，⽅法参数和回来值的默许注解都是 nonnull 类型的，这样一来，咱们就能够删掉许多冗余的代码。
3.1.3、底层关键字
可是上面的关键字和宏并不适用所有的场合，例如你将 nonnull 直接放在常量前会触发编译器过错。还好这种过错是有解决办法的！
nonull 和 nullable 只能在办法和特点上运用，假如想拓宽其运用场景，就需求直接调用这两关键字底层的内容，也便是 _Nonnull 和 _Nullable。
这两种注解除了能够用在大局常量，大局函数的场景外，也适用于任何 Objective-C 任何地方的指针类型，乃至那种指向指针类型的指针。
3.2、Int类型
大多数人运用 NSUInteger 是为了表明这个数值是⾮负的，虽然这种用法是可行的，但它仍是会存在一些严重的安全漏洞(NSUInteger 的大小会因架构不同而产生一些改变)，所以这种规划思路并没有被 Swift 选用。
Swift 采取的战略是在进⾏有符号运算时，要求开发者有必要将⽆符号类型转换为有符号类型，假如 Swift 在处理⽆符号运算时，产⽣了负值，就会直接停⽌运算。
也正是这样的战略，会让 Swift 中的 Int 和 UInt 在混合起来运用的时分变得很费事，当然，这在 Objective-C ⾥⾯的也是一个棘手的问题。
所以混合运用 Int 和 UInt 并不是 Swift 里的最佳实践，在 Swift 里边，咱们建议将所有进行数值计算的类型声明为 Int，即使它永远不行能为负数。
关于 Apple 自己的结构，他们设置了一个白名单用于将 NSUInteger 转换为 Int。
关于开发者而言，决定权在咱们自己手里，咱们能够⾃⾏挑选是否使⽤ NSInteger，但 Apple 的工程师强烈推荐你这么做。
或许在 Objective-C ⾥⾯距离不是很⼤，但在 Swift ⾥⾯很重要！
3.3、对Swift躲藏某个API
在做一个公共库时，可能会面临一个问题：其间的某个办法不期望Swift运用，这时分只需求在原有的头⽂件⾥将相应的 Objective-C 的⽅法符号为NS_REFINED_FOR_SWIFT即可。
例如：
- (instancetype)initWithNameComponent:(nullable NSString *)name NS_REFINED_FOR_SWIFT;
这样在Swift调用的时分，编译器会将该办法躲藏起来，比方代码补全的时分。其实这样不代表就不能调用了，这个符号做的作业其实很简单，是在对应地Swift版别的API最初增加了两个下划线，所以假如非要运用，也能够经过调用__+办法调用。
3.4、对Swift重命名办法名
Swift 和 Objectiv-C 的命名风格是有所不同，为了解决 API 风格上的问题，Swift 会依据一些规矩重命名，通常这个成果还不错，但这毕竟是计算机的审美成果，很难满意开发者的诉求，所以针对一些不满意的地方，咱们能够自己运用NS_SWIFT_NAME 来进行命名OC办法对应地Swift中API的办法名。
OC:
- (BOOL)driveCarByHand:(Int)handType
NS_SWIFT_NAME(driveCar(handType:));
重命名后的供Swift调用的API:
func driveCar(handType: Int) -> bool
四、总结
写到这儿，根本现已总结了项目中常见的在混编过程中会遇到的问题，从常用的特点、办法、类等到结构的API规划，当然本篇文章主要写的是在混编时分适配的Tips，所以要点写的是编译器没有帮咱们做好的作业，其实在混编中，编译器大部分帮助咱们做的仍是比较友好的，在大部分功能上能够做到OC和Swift的无缝衔接调用。
