Lightweight Generics(轻量级泛型)###

OC类型声明用轻量级泛型规范等同于Swift内容的限制类型。例如，下面OC的属性声明:

@property NSArray<NSDate *> *dates;
@property NSCache<id, id <NSDiscardableContent>> *cacheData;
@property NSDictionary <NSString *, NSArray<NSLocale *>> *supportedLocales;

转化为Swift:

var dates: [Date]
var cacheData: Cache<AnyObject, DiscardableContent>
var supportedLocales: [String: [Locale]]

在OC中规范类类等同于Swift带相同类型参数通用类。所有OC泛型类型等同于Swift符合(T: AnyObject)的类型约束。如果OC的泛型对类限定，那么转化的Swift类有约束，也约束了子类的类型。如果OC泛型进行协议限定，那么转化为Swift类有约束，要求转化为这个协议类型。对于一个没有具体说明的OC类型，Swift对类的类型约束表明通用规范。例如，下列OC类和类别声明：

@interface List<T: ID<NSCopying>> : NSObject
- (List<T> *)listByAppendingItemsInList:(List<T> *)otherList;
@end

@interface ListContainer : NSObject
- (List<NSValue *> *)listOfValue;
@end

@interface ListContainer (ObjectList)
- (List *)listOfObjects;
@end

转换为Swift：

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

class ListContainer : NSObject {
    func listOfValue() -> List<NSValue>
}

extension ListContainer {
    func listOfObjects() -> List<NSCopying>
}

Extensions(扩展)###

Swift的扩展(extension)类似OC的类别(category)。扩展用来增加类、结构体，和枚举的行为。你可以定义一个系统类型或者自定义类型的扩展。导入相关的模块，然后通过相同名字关联类、结构体或者枚举。

例如，你可以扩展UIBezierPath类，基于提供的参数边长和起始点来制作一个等边三角形的贝塞尔路径，

extension UIBezierPath {
    convenience init(triangleSideLenght: 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, heigth: 50.0)
let area = rect.area

你不可以用扩展来否决在OC类型里存在的方法或属性。

Closures(闭包)###

OC的blocks会自动导入为Swift的闭包。例如，下面是一个OC中的block变量:

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

在Swift中的形式为:

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

Swift的闭包和OC的blocks是一样的，所以你可以把一个 Swift 闭包传递给一个把 block 作为参数的 Objective-C 函数。Swift 闭包与函数具有互通的类型，所以你甚至可以传递 Swift 函数的名字。

闭包与 blocks 语义上想通但是在一个地方不同：变量是可以直接改变的，而不是像 block 那样会拷贝变量。换句话说，Swift 中变量的默认行为与 Objective-C 中 __block 变量一致。

Avoiding Strong Reference Cycles When Capturing self(用Self时如何避免循环引用)###

在OC中，如果你需要在block中用self，考虑内存管理是很重要的。

Blocks给代码块中的对象维持强引用,包括self。如果self在block中维持强引用，就像一个属性copy，这将造成强循环引用。为了避免这种情况，你可以用对self进行弱引用:

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

在Swift中，闭包也会给代码块中的对象进行强引用，包括self。为了避免强引用，你可以在闭包中标注self为unowned:

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

Object Comparison(对象比较)###

在Swift中有两种方式类比较两个对象。第一种，使用(==),判断两个对象的内容。第二种，使用(===)，判断常量或变量是否为同一个实例对象。

Swift已经实现了==和===的操作。调用isEqual:方法来实现==操作，并且实现===操作是检查指针相等。

NSObject 类仅仅做了身份的比较，所以你需要在你自己的类中重新实现 isEqual: 方法。因为你可以直接传递 Swift 对象给 Objective-C 的 API，你也应该为这些对象实现自定义的isEqual:方法，如果你希望比较两个对象的内容是否相同而不是仅仅比较他们是不是由相同的对象派生。

Hashing###

Swift采用Hashable协议，并且规定NSObject基类默认实现hashValue属性。hashValue属性的实现调用了hash属性

NSObject的子类自定义实现isEquals:方法也应实现hash属性。

Swift Type Compatibility(Swift类型兼容性)###

当你定义了一个继承Objective-C 类的 Swift 类，这个类和他的成员属性，方法，下标，和初始化-它们与OC是兼容的。下面的这些不包括Swift的特性:

• Generics
• 元组(Tuples)
• 在Swift中不带Intraw value类型的枚举
• 在Swift中定义的结构体
• 在Swift中高级函数
• 在Swift中全局变量
• Typealiases defined in Swift
• Swift-style variadics
• Nested types
• Curried functions

Swift Apis被翻译成OC类似于如何将OC APIs翻译为Swift，但反过来:

• Swift optional types are annotated as __nullable.
• Swift nonoptional types are annotated as __nonnull.
• Swift constant stored properties and computed properties become read-only Objective-C properties.
• Swift variable stored properties become read-write Objective-C properties.
• Swift type properties become Objective-C properties with the class property attribute.
• Swift type methods become Objective-C class methods.
• Swift initializers and instance methods become Objective-C instance methods.
• Swift methods that throw errors become Objective-C methods with an NSError ** parameter. If the Swift method has no parameters, AndReturnError: is appended to the Objective-C method name, otherwise error: is appended. If a Swift method does not specify a return type, the corresponding Objective-C method has a BOOL return type. If the Swift method returns a nonoptional type, the corresponding Objective-C method has an optional return type.

例如，下列是Swift的声明:

class Jukebox: NSObject {
    var library: Set<String>
    
    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<String>(songs)
    }
    
    func playSong(named name: String) throws {
        // play song or throw an error if unavailable
    }
}

转化为OC为:

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

Configuring Swift Interfaces in Objective-C###

在一些情况下，你需要在OC中使用Swift的API.你可以用@objc(name)来改变类名，属性，方法，枚举类型。

例如，如果你Swift特性在OC中不支持，你可以在OC中使用可替代的。如果你为Swift函数提供OC名，用OC的语法。无论哪个选择器的参数，记得加(:)。

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)时，这个类在OC中没有命名空间。这种特性可以在OC转移到Swift时候可以用到。因为归档存储类，你可以用@objc(name)特性来具体说明OC中相同的类，以至于之前的归档可以使用心得Swift类进行接档。

Requiring Dynamic Dispatch###

当Swift在OC的运行时机制下，对属性、方法、下标和初始化不能保证动态分发。在OC的运行时，Swift编译器会虚拟或内联成员访问对你的代码进行优化。

在OC运行时，你可以动态修改你访问的成员叫动态分发。在OC运行时，KVO或method_exchangeImplementations函数还是很有必要用这种API的，
它可以在运行的时候动态替换一个方法的实现。如果Swift编译

注意：用dynamic声明的不能用@nonobjc标记属性。

Selectors###

一个Objective-C 选择器类型指向一个Objective-C的方法名。在Swift中， Objective-C 的选择器被Selector结构体替代，可以用#selector创建。

#selector(MyViewController.tappedButton(sender:))

创建OC属性的getter或setter方法，可以在名字前缀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: String?, bundle nibBundleOrNil: Bundle?) {
        super.init(nibName: nibNameOrNil, bundle: nibBundleOrNil)
        let action = #selector(MyViewController.tappedButton)
        myButton.addTarget(self, action: action, forControlEvents: .touchUpInside)
    }
    
    func tappedButton(sender: UIButton?) {
        print("tapped button")
    }
    
    required init?(coder: NSCoder) {
        super.init(coder: coder)
    }
}

Unsafe Invocation of Objective-C Methods(OC方法的安全隐患)###

你可以用perform(_:)方法调用OC的方法。用这个选择器调用方法存在安全隐患，因为编译器不能保证结果，甚至不能保证对象响应方法。因此强烈反对使用这些APIs，除非你的代码基于OC的运行时机制动态调用方法。例如，如果你需要使用target-action设计模式实现类，用这些可能是合适的。

像perform(:)方法，返回一个AnyObject实例(Unmanaged<AnyObject>!),因为perform选择器不能再编译的时候确定返回值类型。像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!"

尝试调用一个对象没有实现的方法会造成对象接收消息并调用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)

Keys and Key Paths###

在OC中，key是对象特定属性的id标识。一个key path是点分割的keys的字符串，它把对象的一些列属性进行了串连。keys 和 key paths在KVC中经常使用，是一个用id标识间接访问对象属性的机制。keys 和 key paths 也可以用在KVO中，当另外一个对象的属性改变的时候能够通知对象的一个机制。

在Swift中，你可以用#keyPath表达式来让编译器检查keys 和 key paths，它可以用在KVC方法中，像value(forKey:)和value(forKeyPath:)，KVO方法像addObserver(_:forKeyPath:options:context:).这个#keyPath表达式允许链方法或者属性引用，像#keyPath(Person.bestFriend.name).

class Person: NSObject {
    var name: String
    var friends: [Person] = []
    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"]