内容字号:默认大号超大号

段落设置:段首缩进取消段首缩进

字体设置:切换到微软雅黑切换到宋体

Swift和Objective-C混编

2018-06-08 18:51 出处:清屏网 人气: 评论(0

翻译自 苹果官方文档

和Objective-C交互

互用性是指,在Swift和Objective-C之间可以建立一个互通接口,不管是Swift生成接口给Objective-C对接,还是Objective-C生成接口给Swift对接。既然你决定开始用Swift来开发,那么有必要理解一下怎么运用互用性来重定义、提高、改进你写Cocoa app的方式。

互用性重要性之一是,在Swift中调用Objective-C的API。在你import一个Objective-C框架之后,你就可以用Swift的语法来实例化里面的类,继而使用它们。

初始化

要在Swift里初始化一个Objective-C类,需要用Swift的初始化语法来调Objective-C的初始化方法。

Objective-C初始化方法都以init开头,或者,如果有一个或多个参数,会以initWith:开头。在Swift文件里如果要调用Objective-C初始化方法,那么init前缀会变成Swift初始化方法。如果此时初始化方法带有参数,会去掉with,而其他参数会根据情况划分到各个参数中。

Objective-C初始化方法的声明:

- (instancetype)init;
- (instancetype)initWithFrame:(CGRect)frame style:(UITableViewStyle)style;

转为Swift的初始化声明:

init() { /* ... */ }
init(frame: CGRect, style: UITableViewStyle) { /* ... */ }

实例化对象的过程,更能看出Objective-C和Swift语法的不同:

Objective-C:

UITableView *myTableView = [[UITableView alloc] initWithFrame:CGRectZero style:UITableViewStyleGrouped];

Swift:

let myTableView: UITableView = UITableView(frame: .zero, style: .grouped)

不用调用alloc,Swift替你处理了。还有,调用Swift风格的初始化函数,不会到处出现init。

当给变量或者常量赋值的时候,你可以指明一个类型,或者可以不指明这个类型,让Swift根据初始化方法自动推导出类型。

let myTextField = UITextField(frame: CGRect(x: 0.0, y: 0.0, width: 200.0, height: 40.0))

这里的UITableView和UITextField和你在Objective-C里实例化出来的对象是一样的,Objective-C里怎么用,这里就怎么用,根据各自的类型,获取属性、调用方法都一样。

类工厂方法和方便初始化方法

为了保持一致性和简单,Objective-C的类工厂方法引入Swift后,会改为方便初始化方法。这样,使用这些方法就像使用初始化方法一样。

例如,下面这个就是Objective-C中的一个工厂方法:

UIColor *color = [UIColor colorWithRed:0.5 green:0.0 blue:0.5 alpha:1.0];

在Swift中,要这样调用:

let color = UIColor(red: 0.5, green: 0.0, blue: 0.5, alpha: 1.0)

可失败的初始化

Objective-C中初始化函数直接返回初始化的结果,如果初始化失败,就会直接返回nil。在Swift中,这个模式由语言的一个特性来实现,叫可失败的初始化(原文:failable initialization)。

很多系统框架里的初始化方法都有标识初始化能不能失败。在你自己的Objective-C类里可以使用可空性(原文:nullability)来标识是不是能失败, Nullability and Optionals 里有描述。在Objective-C里不可失败的话,在Swift里是init(...),可失败的话,用init?(...)。否则,都用init!(...)。

例如,UIImage(contentsOfFile:)初始化方法,如果提供的路径下面没有图片文件,就会初始化失败。如果可失败初始化函数初始化成功了,你可以用可选绑定去解包返回的结果。(译者注:public init?(contentsOfFile path: String))

if let image = UIImage(contentsOfFile: "MyImage.png") {
    // loaded the image successfully
} else {
    // could not load the image
}

获取属性

在Objective-C中用@property声明的属性,Swift会做下面的处理:

已经用nonnull、nullable和 null_resettable修饰的属性,按照 Nullability and Optionals 说的,转成可选和非可选属性。

readonly属性会转化为Swift中的计算型属性,也即只有一个getter方法({ get })。

weak属性转化为Swift中的weak属性(weak var)。

对于不是weak的所有者属性(原文:ownership property)(即assign、 copy、strong、 unsafe_unretained)都会转成相对应的存储属性。

class修饰的属性(译者注:Objective-C在Xcode9引入了一个新的属性class,应该就是为了对接Swift吧),转为在Swift中类型属性。

Objective-C中的原子性修饰符(atomic和nonatomic)在Swift中没有对应的修饰符,但是原子性所提供的功能在Swift里是依然存在的。(译者注:Atomicity property attributes (atomic and nonatomic) are not reflected in the corresponding Swift property declaration, but the atomicity guarantees of the Objective-C implementation still hold when the imported property is accessed from Swift.这句翻译的不是太好,请指教!)

存取属性(getter=和setter=)在Swift被忽略掉。(译者注:今天才知道getter=和setter=也是属性)

在Swift中,获取Objective-C 对象的属性值,用点语法直接带上属性名字,不需要括号。

例如,设置UITextField的textColor和text属性:

myTextField.textColor = .darkGray
myTextField.text = "Hello world"

Objective-C中用点语法调用无参数有返回值的方法,形式和获取属性很像(译者注:方法除了点,还有括号,其实并不一样)。虽然调用形式一样,方法在Swift中还是会转换为方法,只有Objective-C中用@property声明的变量才能转为Swift中的属性。关于方法的引入和调用可以参考 方法的使用

方法的使用

在Swift中,用点语法来调用Objective-C方法。

Objective-C方法引入到Swift后,方法的第一部分,变成方法名,在括号前面。第一个参数在括号里,没有参数名。剩下的参数对应各自的参数名排在括号里。方法的所有组成部分都是需要的,少了任何部分,调用地址就是不对的。

例如Objective-C中:

[myTableView insertSubview:mySubview atIndex:2];

在Swift中,会是这样:

myTableView.insertSubview(mySubview, at: 2)

调用一个没有参数的方法,依然要带上括号。

myTableView.layoutIfNeeded()

id兼容

Objective-C中的id类型会转为Swift中的Any类型。在编译时和运行时,将Swift的值或者对象(译者注:Swift里引入了结构体,所以不光是类引用类型,也包括结构体值类型,所以,总是出现“值或者对象”)传给Objective-C的类型为id参数时,编译器会去执行一个全局桥接转换操作(原文:universal bridging conversion operation)。当将一个Objective-C中的id传给Swift的Any参数时,运行时会自动桥接回Swift的类引用或者值类型。(译者注:换句话说就是,id和Any可以转换,并且转换由系统完成)

var x: Any = "hello" as String
x as? String   // String with value "hello"
x as? NSString // NSString with value "hello"
 
x = "goodbye" as NSString
x as? String   // String with value "goodbye"
x as? NSString // NSString with value "goodbye"

(译者注:这个例子代码说明啥?不是特别清楚,求指教!)

向下转换Any(译者注:从一个比较宽的类型,转化为一个比较具体的类型)

如果知道Any里实际是什么类型,那么将其向下转化到一个更具体的类型比较有用。由于Any类型可以包含任意类型,所以,向下转型到一个更具体的类型不一定都能成功。

可以试试可选类型转化操作符(as?),返回一个包裹着转化结果的可选值:

let userDefaults = UserDefaults.standard
let lastRefreshDate = userDefaults.object(forKey: "LastRefreshDate") // lastRefreshDate is of type Any?
if let date = lastRefreshDate as? Date {
    print("\(date.timeIntervalSinceReferenceDate)")
}

如果你能确定对象的类型,那么可以用强制向下类型转换(as!)。

let myDate = lastRefreshDate as! Date
let timeInterval = myDate.timeIntervalSinceReferenceDate

如果强制向下转换失败,会触发一个运行时错误:

let myDate = lastRefreshDate as! String // Error

动态方法查找

Swift还有一个AnyObject类型,用来表示某些对象类型(译者注:和Any不同的是,Any还可以存储值类型),并且这个类型还有特别的能力,可以将@objc修饰的方法转为动态查找。通过这个特性,对Objective-C返回的id类型的值可以更好的操作与维护。(译者注:AnyObject能力比较强大,因为Swift是强类型,不指定具体类型是不能调用方法的,但是AnyObject不一样,可以调用任意方法。如果一个对象的方法或者属性标记为@objc,那么这些方法就变成可以动态查找的方法。因为Objective-C的方法是采用动态查找实现的,所以,只有这样,这些方法才能提供给Objective-C使用。@objc后面有详细叙述)

例如,可以给AnyObject类型的常量或者变量赋值任意的对象,这个变量又可以再赋值一个不同类型的对象。你不需要转换为具体的类型,直接通过AnyObject类型就可以调用Objective-C具体类的方法和属性。

var myObject: AnyObject = UITableViewCell()
myObject = NSDate()
let futureDate = myObject.addingTimeInterval(10)
let timeSinceNow = myObject.timeIntervalSinceNow

不能识别的方法和可选链

因为直到运行时才能知道AnyObject的值到底是什么类型,所以,就有可能写出不安全的代码。无论是Swift还是Objective-C,试图去调用一个不存在的方法都会触发一个找不到方法(译者注:unrecognized selector)的错误。

例如,下面的代码不会有编译时的警告,但是在运行时会报错:

myObject.character(at: 5)
// crash, myObject doesn't respond to that method

Swift可以用可选的方式来避免不安全的行为。调用AnyObject类型的方法时,实际进行了一个隐式解包。可以用可选链语法来调用AnyObject类型的方法。

例如下面的代码,第一行和第二行不会执行,因为NSDate对象没有count属性和character(at:)方法。常量myCount会被推导为可选Int类型,值为nil。可以用if let语句来解包方法返回的结果,如第三行所示。

// myObject has AnyObject type and NSDate value
let myCount = myObject.count
// myCount has Int? type and nil value
let myChar = myObject.character?(at: 5)
// myChar has unichar? type and nil value
if let fifthCharacter = myObject.character?(at: 5) {
    print("Found \(fifthCharacter) at index 5")
}
// conditional branch not executed

注意

虽然Swift没有强制要求,AnyObject类型的值调用方法时,一定要解包,但还是推荐解包,以此来避免不可预知的行为。(译者注:Although Swift does not require forced unwrapping when calling methods on values of type AnyObject, it is recommended as a way to safeguard against unexpected behavior.不是太理解,求指教!)

可空和可选

Objective-C中,通过原始指针(原文:raw pointer)来引用对象,指针可能是NULL(在Objective-C中是nil)。在Swift中,所有的结构体类型,或者对象类型都不会为空(译者注:不会直接是nil,而是一个可选值)。如果要表示这个值可以为空,那么要将这个值包装为可选类型。关于可选值的更多信息,请看Swift编程语言( Swift 4.0.3 )中可选值。

Objective-C中可以用可空性标识来表示参数、属性、返回值是不是可以为NULL或者nil。单个的类型声明,我们可以用_Nullable和_Nonnull标识,单个的属性声明可以用nullable, nonnull和null_resettable标识,或者用宏NS_ASSUME_NONNULL_BEGIN和NS_ASSUME_NONNULL_END来标识整个区域的可空性。如果没有给一个类型设置可空性修饰,Swift无法区分是可选还是非可选,那么统一设置为隐式解包可选类型。(译者注:对于隐式解包可选类型加个说明,隐式解包的可选类型主要用在一个变量/常量在定义瞬间完成之后值一定会存在的情况,在使用时,不需要解包,直接使用,系统自动解包)

  • 用_Nonnull标识,或者在整个非空宏区域里的类型,声明为不可空,在Swift里都转为不可选。

  • 声明为_Nullable的可空类型,在Swift里转为可选类型。

  • 没有任何可空性标识的类型,在Swift里都转为隐式解包可选类型。

例如,下面的Objective-C声明:

@property (nullable) id nullableProperty;
@property (nonnull) id nonNullProperty;
@property id unannotatedProperty;

NS_ASSUME_NONNULL_BEGIN
- (id)returnsNonNullValue;
- (void)takesNonNullParameter:(id)value;
NS_ASSUME_NONNULL_END

- (nullable id)returnsNullableValue;
- (void)takesNullableParameter:(nullable id)value;

- (id)returnsUnannotatedValue;
- (void)takesUnannotatedParameter:(id)value;

下面是在Swift中的样子:

var nullableProperty: Any?
var nonNullProperty: Any
var unannotatedProperty: Any!
 
func returnsNonNullValue() -> Any
func takesNonNullParameter(value: Any)
 
func returnsNullableValue() -> Any?
func takesNullableParameter(value: Any?)

func returnsUnannotatedValue() -> Any!
func takesUnannotatedParameter(value: Any!)

大部分的系统框架,包括Foundation,都有可空性标识,所以在和这些值打交道时,可以保持类型安全和语言的习惯

桥接可选类型到非空对象

Swift将可选值桥接为Objective-C的非空对象,如果可选值里有值,那么把这个值传递给Objective-C对象,如果可选值是nil,那么会传递一个NSNull实例给Objective-C对象。例如,可以将一个Swift可选类型直接传入Objective-C接受非空id参数的API,也可以将包含可选项的数组([T?])桥接为NSArray。

下面的代码可以看出,怎么根据实际所包含的值来桥接String?实例到Objective-C中。

@implementation OptionalBridging
+ (void)logSomeValue:(nonnull id)valueFromSwift {
    if ([valueFromSwift isKindOfClass: [NSNull class]]) {
        os_log(OS_LOG_DEFAULT, "Received an NSNull value.");
    } else {
        os_log(OS_LOG_DEFAULT, "%s", [valueFromSwift UTF8String]);
    }
}
@end

valueFromSwift参数类型是id,所以在Swift中要传入Any类型,如下所示。一般情况下,给参数为Any函数传入一个可选类型并不普遍,所以,需要将传入logSomeValue(_:)类方法的可选值进行显式的转换为Any类型,避免编译器警告。

let someValue: String? = "Bridge me, please."
let nilValue: String? = nil

OptionalBridging.logSomeValue(someValue as Any)  // Bridge me, please.
OptionalBridging.logSomeValue(nilValue as Any)   // Received an NSNull value.

协议限定类(Protocol-Qualified Classes)

实现了一个或者多个协议的Objective-C类,在Swift中会转换成协议组合类型。例如以下的Objective-C中定义的view controller属性

@property UIViewController * myController;

Swift中会是这样:

var myController: UIViewController & UITableViewDataSource & UITableViewDelegate

Objective-C中协议限定元类(protocol-qualified metaclasses),在Swift中转换为协议元类型(protocol metatypes)。例如以下Objective-C方法对特定的类执行操作(原文:Objective-C protocol-qualified metaclasses are imported by Swift as protocol metatypes. For example, given the following Objective-C method that performs an operation on the specified class):

- (void)doSomethingForClass:(Class)codingClass;

Swift中的样子:

func doSomething(for codingClass: NSCoding.Type)

轻量级泛型

用轻量级泛型参数化(译者注:generic parameterization泛型参数化,意思是,给泛型指定了类型,也即尖括号里有具体的类型。所以后面说到的参数化,都是指已经给泛型指定了具体的类型)。声明的Objective-C类型,内容的类型信息在Swift会保留下来。例如下面的Objective-C属性声明:(译者注:Objective-C里面的泛型实际是Xcode7引入的一个语法糖,称为轻量级泛型。 Stack Overflow 上有这个讨论)

@property NSArray *dates;
@property NSCache
<nsobject nbsp="" id="">
  *cachedData;
@property NSDictionary 
 <nsstring nbsp="" nsarray="">
   *supportedLocales;
 </nsstring>
</nsobject>

Swift中会是这样:

var dates: [Date]
var cachedData: NSCachevar supportedLocales: [String: [Locale]]

一个Objective-C中参数化的类,引入Swift后,转换为泛型类,有同样数量的类型参数(译者注:type parameters类型参数,这里的意思是,泛型尖括号里的类型)。所有Objective-C中的泛型类型参数,在Swift中,会将类型参数转换为像(T: Any)类似的类的形式。如果Objective-C里泛型参数化指定了一个限制类(译者注:class qualification限制类,意思是,这个类起到了一个限制的作用,下面说道的protocol qualification协议限制,也是一样的理解,表示,这个协议对这个泛型起到一个限制作用),在Swift中也会转换这个限制:这个类必须是这个限制类的子类。如果Objective-C离泛型参数化指定了一个限制协议,在Swift中也会转换这个限制:这个类也必须遵守指定的协议。对于没有任何限制的Objective-C类型,Swift会推导给出限制,如下,Objective-C类和类别的声明:

@interface List
<t: nbsp="" id="">
  : NSObject
- (List *)listByAppendingItemsInList:(List *)otherList;
@end
 
@interface ListContainer : NSObject
- (List *)listOfValues;
@end
 
@interface ListContainer (ObjectList)
- (List *)listOfObjects;
@end
</t:>

Swift中是这个样子的:

class List : NSObject {
    func listByAppendingItemsInList(otherList: List) -> List}

class ListContainer : NSObject {
    func listOfValues() -> List}

extension ListContainer {
    func listOfObjects() -> List}

扩展

Swift扩展和Objective-C中的类别相似。扩展增加了已有类,结构体,枚举的功能,也可以扩展在Objective-C中定义的这些类型(译者注:应该是系统将Objective-C中的结构体和枚举类型转成了Swift中的结构体和枚举类型,这样才具备扩展功能)。可以给系统类型添加扩展,也可以给自定义的类添加扩展。Swift里引入Objective-C的模块,用Objective-C中的名字 ,来引用这些类,结构体,枚举类型。

例如,给UIBezierPath类扩展功能,根据边长和起点生成一个等边三角形,再由这个等边三角形创建一个贝塞尔路径。

extension UIBezierPath {
    convenience init(triangleSideLength: CGFloat, origin: CGPoint) {
        self.init()
        let squareRoot = CGFloat(sqrt(3.0))
        let altitude = (squareRoot * triangleSideLength) / 2
        move(to: origin)
        addLine(to: CGPoint(x: origin.x + triangleSideLength, y: origin.y))
        addLine(to: CGPoint(x: origin.x + triangleSideLength / 2, y: origin.y + altitude))
        close()
    }
}

可以用扩展来添加属性(包括类属性和静态属性)。但是,只能是计算属性;扩展不能给类,结构体,枚举类型添加存储属性。

下面的例子是给CGRect结构体扩展一个计算属性area:

extension CGRect {
    var area: CGFloat {
        return width * height
    }
}
let rect = CGRect(x: 0.0, y: 0.0, width: 10.0, height: 50.0)
let area = rect.area

可以不通过继承,通过扩展来让一个类来实现协议(译者注:Objective-C中分类也是可以实现这个功能)。如果协议是在Swift中定义的,那么也可以给Objective-C和Swift中的结构体,枚举类型添加实现协议的扩展。

扩展不能覆盖Objective-C中已经存在的方法和属性。

闭包

Objective-C中的block使用@convention(block)自动转换为Swift中的闭包。下面是Objective-C block变量:

void (^completionBlock)(NSData *) = ^(NSData *data) {
   // ...
}

Swift中:

let completionBlock: (Data) -> Void = { data in
    // ...
}

Swift闭包和Objective-C block是兼容的,可以将Swift闭包传递给接受block的Objective-C方法。Swift闭包和函数是相同的类型,所以也可以给Objective-C的block传递一个Swift的函数名字。

闭包和block有相似的值捕获功能,但是闭包有一点不一样:变量默认是可以修改的。换句话说,Objective-C中给变量添加__block修饰,在Swift是默认行为。

避免捕获self而造成循环引用

Objective-C中,在block中捕获self,需要考虑内存管理。

block会对任何捕获的对象保持一个强引用,包括self。如果self又对block保持一个强引用,例如block是self的一个copy属性,那么会造成一个循环引用。为了避免循环引用,我们让block捕获一个弱引用的self。

__weak typeof(self) weakSelf = self;
self.block = ^{
   __strong typeof(self) strongSelf = weakSelf;
   [strongSelf doSomething];
};

和Objective-C里的block一样,Swift中的闭包也会对捕获的对象保持一个强引用,当然也包括self。为了防止造成循环引用,可以在闭包的捕获列表里,将self设置为unowned

self.closure = { [unowned self] in
    self.doSomething()
}

更多信息参照Swift编程语言(Swift 4.0.3)中的 解决闭包循环引用

对象比较

在Swift中有两个不同的比较类型来比较两个对象。一个是等号(==),来比较对象的内容。还有一个是恒等(===),来判断比较的变量或常量是不是指向同一个对象。

Swift对==和===操作符提供了默认的实现,对于继承自NSObject的对象,遵守Equatable协议。==的默认实现是调用isEqual:方法,===的默认实现是检查指针是否相等。从Objective-C引入的类型,不能重写等号和恒等操作符。

NSObject类提供的isEqual:实现和恒等是一样的,也是比较指针是否相等。在Swift和Objective-C中,可以通过重写isEqual:,来比较对象的内容是不是相等,而不是比较指针。关于比较逻辑实现的更多信息,请看Cocoa Core Competencies里的对象比较。

注意

Swift也提供了等和恒等对应的相反的实现(!=和!==)。这两个操作符不能重写。

哈希

Objective-C中NSDictionary没有对key指定类型限制,Swift会转化为Dictionary,key的类型是AnyHashable。NSSet也一样,如果在Objective-C中没有对其中的元素指定类型限制,Swift会将Set中的元素类型设置为AnyHashable。如果NSDictionary和NSSet已经参数化key或者元素的,那么Swift里就会用相应的类型。如下Objective-C的声明:

@property NSDictionary *unqualifiedDictionary;
@property NSDictionary *qualifiedDictionary;

@property NSSet *unqualifiedSet;
@property NSSet *qualifiedSet;

转为Swift:

var unqualifiedDictionary: [AnyHashable: Any]
var qualifiedDictionary: [String: Date]

var unqualifiedSet: Setvar qualifiedSet: Set

Objective-C中未指明类型或者类型为id的类型,转到Swift中都是AnyHashable,为什么不是Any类型,因为在这里,这些类型都需要遵守Hashable协议。AnyHashable类型表示任何可哈希的类型,可以用as?和as!操作符转化为更具体的类型。

更多信息,见 AnyHashable。

Swift类型兼容

Swift可以继承Objective-C类,生成一个Swift类,其中成员属性、方法、索引(译者注:subscript索引是Swift里的新功能)、初始化方法,这些能在Objective-C中找到对应的转化,都会自动转化为Objective-C相应的功能。但是有些特性是Swift特有的,无法转到Objective-C,如下所示:

  • 泛型(译者注:Objective-C没有泛型,后来引入的称作轻量级泛型,只是一个编译器的语法糖,和Swift中真正的泛型不是一回事)

  • 元祖

  • 在Swift中定义的枚举类型,raw值不为Int类型(译者注:Objective-C中也有枚举类型,但是,原始值一定是int类型。在Swift中,枚举类型可以是其他类型,不光是int类型,所以要和Objective-C兼容的话,必须限定为int类型)。

  • Swift中定义的结构体

  • Swift中定义的顶级函数(原文:Top-level functions意思是,不属于某个类,某个结构体,枚举等的函数,直接写在文件里的函数)

  • Swift中定义的全局变量

  • Swift中的Typealiases关键字

  • Swift风格的可变参数(译者注:Objective-C中也有可变参数,但是和Swift相比,功能弱很多,所以,Swift特有的功能转不过去)

  • 嵌套类型(译者注:Swift里类型可以嵌套,例如类里面还可以定义类)

  • 柯里化函数(译者注:王巍的Swift 100 tips第一节就是介绍柯里化)

Swift API转为Objective-C API,和上面的Objective-C API转为Swift API类似,下面是Swift转Objective-C:

  • Swift可选类型转为__nullable

  • Swift非可选类型转为__nonnull

  • Swift常量的存储属性和计算属性都转为Objective-C的read-only。

  • Swift变量存储属性转为Objective-C的read-write。

  • Swift的类型属性(type properties)转为class属性(译者注:参考Xcode8添加一个属性class)。

  • Swif类型方法转为Objective-C的类方法(静态方法)。

  • Swift初始化方法(译者注:Swift的初始化函数,在Swift里是按特殊函数对待,但是Objective-C初始化函数也是实例函数)和实例方法转为Objective-C的实例方法。

  • Swift中(throw)抛出错误的方法,会转化为Objective-C中的带NSError **参数的方法。如果这个Swift方法没有参数,会追加AndReturnError: 到Objective-C方法名的后面,否则就追加error:参数。如果Swift方法没有指定返回类型,相应的Objective-C方法会返回一个BOOL类型。如果Swift方法返回一个非可选类型,相应的Objective-C方法会返回一个可选类型(译者注:原文是“ If the Swift method returns a nonoptional type, the corresponding Objective-C method has an optional return type. ”,Objective-C中没有所谓的可选类型,这句不甚了解,求指导!)。

以下Swift声明:

class Jukebox: NSObject {
    var library: Set  
    var nowPlaying: String?
   
    var isCurrentlyPlaying: Bool {
        return nowPlaying != nil
    }
   
    class var favoritesPlaylist: [String] {
        // return an array of song names
    }
   
    init(songs: String...) {
        self.library = Set(songs)
    }
   
    func playSong(named name: String) throws {
        // play song or throw an error if unavailable
    }
}

转为Objective-C:

@interface Jukebox : NSObject
@property (nonatomic, strong, nonnull) NSSet *library;
@property (nonatomic, copy, nullable) NSString *nowPlaying;
@property (nonatomic, readonly, getter=isCurrentlyPlaying) BOOL currentlyPlaying;
@property (nonatomic, class, readonly, nonnull) NSArray *favoritesPlaylist;
- (nonnull instancetype)initWithSongs:(NSArray * __nonnull)songs OBJC_DESIGNATED_INITIALIZER;
- (BOOL)playSong:(NSString * __nonnull)name error:(NSError * __nullable * __null_unspecified)error;
@end

注意

Objective-C不能继承Swift类。

调整Swift,适配Objective-C

某些情况下,对于暴露给Objective-C的Swift API需要有一个更细粒度的控制(译者注:原文finer grained control)。用@objc(name)可以给类,属性,方法,枚举,及枚举里的case重新改一个名字,暴露给Objective-C。

例如,Swift类包含的字符是Objective-C不支持的,那么我们可以改个名字暴露给Objective-C。如果要给Swift函数改名,需要用Objective-C的selector语法。如果有参数,不要漏了冒号(:)。

@objc(Color)
enum Цвет: Int {
    @objc(Red)
    case Красный
   
    @objc(Black)
    case Черный
}

@objc(Squirrel)
class Белка: NSObject {
    @objc(color)
    var цвет: Цвет = .Красный
   
    @objc(initWithName:)
    init (имя: String) {
        // ...
    }
    @objc(hideNuts:inTree:)
    func прячьОрехи(количество: Int, вДереве дерево: Дерево) {
        // ...
    }
}

当给一个Swift类使用@objc(name)属性的时候,Objective-C就可以访问这个类,并且不会带有任何命名空间信息(译者注:因为Swift是有命名空间的,如果不去掉命名空间,直接搬到Objective-C中使用,类名就会是xxx.类名的形式,这个在Objective-C里当然不能使用,所以这里的意思是,转到Objective-C,会去掉命名空间,也就是去掉类名前的xxx)。在将可归档的Objective-C类迁移到Swift中时(译者注:意思是将一个Objective-C类改写为Swift类),这个属性也非常有用。因为归档的对象会储存类名,用@objc(name)指定一个和Objective-C中一样的名字,这样才能用新的Swift类来解档之前Objective-C归档的类。(译者注:用我的话说就是,Objective-C归档的时候,没有所谓的命名空间,直接按照类名来归档,但是改成Swift之后,想把之前用Objective-C归档的东西解档,就必须去掉命名空间,去掉命名空间的做法,就是用@objc(name)来指定类名)

注意

相反,Swift也有@nonobjc属性,这个属性表示Objective-C中不能访问。You can use it to resolve circularity for bridging methods and to allow overloading of methods for classes imported by Objective-C.(译者注:译者对于混编经验不足,这句意思不甚了解,求指教!原文在上面)有些功能,例如可变参数,在Objective-C中不能表示,所以,对于这类方法,需要标记为@nonobjc。

要求动态派发(译者注:Objective-C里面的消息调用机制称作动态派发)

暴露给Objective-C调用的Swift API,可必须是通过动态派发的方式调用。但是,这些通过动态派发的Swift API,当Swift调用这些API的时候,Swift编译器会选择一个更加高效的方法来调用,而不会直接用动态派发的方式调用(译者注:其实Objective-C中的动态派发是一种低效的机制,Swift已经摒弃)。

在@objc后面加上dynamic,表示通过Objective-C运行时动态派发来访问成员。很少情况下需要这种动态派发。但是在使用KVO和 method_exchangeImplementations等那些需要在运行时动态替换方法的时候,就需要指明动态派发。

添加dynamic的声明也必须添加@objc,除非@objc被系统隐式添加了。@objc隐式添加的相关信息请看Swift编程语言中 属性声明

选择子(译者注:原文selector)

Objective-C中,selector表示一个方法的类型。Swift中,用Selector结构体表示Objective-C的selector类型,可以用#selector表达式来创建这个结构体。要给一个方法创建一个可供Objective-C调用的selector,需要传入方法名,例如#selector(MyViewController.tappedButton(_:))。如果要给一个属性的getter或者setter方法创建一个selector,需要传递一个以getter或者setter标签为前缀的属性名,例如#selector(getter: MyViewController.myButton)。

import UIKit
class MyViewController: UIViewController {
    let myButton = UIButton(frame: CGRect(x: 0, y: 0, width: 100, height: 50))
   
    override init(nibName nibNameOrNil: NSNib.Name?, bundle nibBundleOrNil: Bundle?) {
        super.init(nibName: nibNameOrNil, bundle: nibBundleOrNil)
        let action = #selector(MyViewController.tappedButton)
        myButton.addTarget(self, action: action, forControlEvents: .touchUpInside)
    }
   
    @objc func tappedButton(_ sender: UIButton?) {
        print("tapped button")
    }
   
    required init?(coder: NSCoder) {
        super.init(coder: coder)
    }
}

注意

Objective-C方法指针可以加括号,可以使用as操作符来区别不同的重载函数,例如#selector(((UIView.insert(subview:at:)) as (UIView) -> (UIView, Int) -> Void))(译者注:可以参考 Stack Overflow

Objective-C方法的不安全调用

可以使用perform(_:)或者它的变体去调用一个Objective-C方法。用selector调用方法是不安全的,因为编译器对结果不能做任何保证,甚至不能保证对象是否能响应这个selector。除非非要依赖Objective-C运行时的动态解决方案,否则我们不建议使用这些API。例如,你需要实现一个类,使用target-action设计模式,像NSResponder那样,这种情况使用这些API是合适的。大部分情况下,将对象转为AnyObject,再使用可选链来调用,会更安全,更方便。这个在 id兼容性 里有说到(译者注:这里苹果推荐先将对象转为AnyObject,再直接来调用方法,而不是使用selector,出于安全考虑)。

通过selector同步执行方法,例如perform(_:),返回一个隐式解包的Unmanaged指针,指向AnyObject实例(Unmanaged !),因为返回值的类型和所有者在编译期不能确定。按照约定,在一个指定的线程,或者做一个延时再执行一个selector,例如perform(_:on:with:waitUntilDone:modes:)和perform(_:with:afterDelay:)不会返回一个值。更多信息见 非托管对象

let string: NSString = "Hello, Cocoa!"
let selector = #selector(NSString.lowercased(with:))
let locale = Locale.current
if let result = string.perform(selector, with: locale) {
    print(result.takeUnretainedValue())
}
// Prints "hello, cocoa!"

对象调用不能识别的selector,会触发doesNotRecognizeSelector(_:),抛出NSInvalidArgumentException异常。

let array: NSArray = ["delta", "alpha", "zulu"]
 
// Not a compile-time error because NSDictionary has this selector.
let selector = #selector(NSDictionary.allKeysForObject)
 
// Raises an exception because NSArray does not respond to this selector.
array.perform(selector)

Key和Key Path

Objective-C中,key是一个字符串,表示一个对象的属性。key path是一个用点分割的字符串,表示一个对象属性的属性。key和key path经常用于键值编码(KVC),一种通过字符串间接获取对象属性的机制。key和key path也用于健值观察(KVO),一个对象的属性改变,会通知另外一个对象的机制。

Swift中,可以用key-path表达式创建一个key path来获取属性,例如用\Animal.name来获取Animal的name属性,例如下面代码。用key-path表达式创建的key path指向的属性已经包含了类型信息。对一个实例用key path取得的属性值,和直接用属性取得的值一样。key-path表达式可以是一个属性,也可以是链式的属性,如\Animal.name.count。

class Animal: NSObject {
    @objc var name: String
    
    init(name: String) {
        self.name = name
    }
}

let llama = Animal(name: "Llama")
let nameAccessor = \Animal.name
let nameCountAccessor = \Animal.name.count
 
llama[keyPath: nameAccessor]
// "Llama"
llama[keyPath: nameCountAccessor]
// "5"

Swift中,还可以用#keyPath字符串表达式创建一个可以在编译期检查的key和key path,用于KVC方法,如value(forKey:)和value(forKeyPath:),用于KVO方法,如addObserver(_:forKeyPath:options:context:)。#keyPath也支持链式的方法或属性。链中可以有可选值,如#keyPath(Person.bestFriend.name)(译者注:bestFriend就是一个可选值)。和用key-path表达式创建的key path不同,用#keyPath字符串创建的key path所指定的属性或者方法没有类型信息。

注意

#keyPath字符串语法和#selector表达式类似,见 Selectors

class Person: NSObject {
    @objc var name: String
    @objc var friends: [Person] = []
    @objc var bestFriend: Person? = nil
    
    init(name: String) {
        self.name = name
    }
}

let gabrielle = Person(name: "Gabrielle")
let jim = Person(name: "Jim")
let yuanyuan = Person(name: "Yuanyuan")
gabrielle.friends = [jim, yuanyuan]
gabrielle.bestFriend = yuanyuan
 
#keyPath(Person.name)
// "name"
gabrielle.value(forKey: #keyPath(Person.name))
// "Gabrielle"
#keyPath(Person.bestFriend.name)
// "bestFriend.name"
gabrielle.value(forKeyPath: #keyPath(Person.bestFriend.name))
// "Yuanyuan"
#keyPath(Person.friends.name)
// "friends.name"
gabrielle.value(forKeyPath: #keyPath(Person.friends.name))
// ["Yuanyuan", "Jim"]

作者:桔子听

链接:https://www.jianshu.com/p/742c6af3afa


分享给小伙伴们:
本文标签: SwiftObjective-C

相关文章

发表评论愿您的每句评论,都能给大家的生活添色彩,带来共鸣,带来思索,带来快乐。

CopyRight © 2015-2016 QingPingShan.com , All Rights Reserved.

清屏网 版权所有 豫ICP备15026204号