从 OC 到 Swift 的快速入门与专业实践

只会详情与 OC 有显著区别的地方，不会详情 OC 中没有的，比方元组。当前总结也只是蜻蜓点水而已，但是有 OC 的基础，看这些已经足够。

一、数据

Swift 是类型安全的语言：

1. Swift 必需明确数据类型
2. 假如取值错误解直接报错
3. Swift 会进行溢出检查 （OC 也会检查）
4. Swift 没有隐式类型转换, 不允许不同类型的数据类型进行运算

1.1 简单用

Swift 很接近脚本语言，尤其是在数据类型方面。定义数据类型只允许用 let 与 var，let 标识的是常量， var 标识的是变量。那么问题来了：那应该如何用？在 Swift 中有可变类型么？

let name = "CoderHG"print(name)

上面简单的定义了一个 name，假如没有看到后面具体的值，根本就不知道 name 是一个字符串类型。但是打断点查看，name 就是一个 String 类型的数据。将上面的代码中的 let 换成 var，会发现在上面的用上没有任何的区别， 能正常用。

var name = "CoderHG"print(name)

但是还是有区别的，上面已经详情 let 标识的是常量， var 标识的是变量。尽然是变量，可否将一个数字类型的 2 赋值给 name 呢？答案一定是不可以的。在 Swift 中的定义，必需在定义的那一刻就要决定其数据类型。所以下面的这种定义是错误的：

var nameprint(name)

这样的话，Xcode 是会直接报错的，由于在定义的时候没有指明 name 是什么类型。那么问题又来了，如何定义一个字符串，而又不希望有初始值呢？

var name: Stringname = "CoderHG"print(name)

这样，name 就是一个字符串类型的了。那么又出先了一个新问题，我可否这样定义：

let name: Stringname = "CoderHG"print(name)

用 OC 的套路来思考上面的代码，一定是不行的，由于一个常量只可能在定义的那一刻赋值，以后都是能读取其值，即为 只读。但是在 Swift 中有点不一样，Swift 在意的是第一次赋值，而不是定义时。所以上面的代码是没有问题的，但是假如再次给 name 赋值，那么一定就出错了。

接下来主要详情一下：在 Swift 中的可变类型。，在 OC 中一般用 NSMutable￥ 来表示一个可变类型，那么在 Swift 中如何表示呢？其实 var 不仅代表一个变量，也代表着 OC 中的可变性。比方，可以这么用：

var name = "CoderHG"name.append(", Very GOOD!")print(name)

假如换成 let 一定是不行的。

上面简单的详情了一下 let 与 var 的简单使用法与注意事项。

看到这里，能否会不由自主的想到 OC 中这样的代码：

id obj = [[NSObject alloc] init];   obj = [[HGPerson alloc] init];

而后 Swift 中也来了这么一段：

var obj = NSObject()// var obj:HGPerson = NSObject() as! HGPersonprint(obj)obj = HGPerson()print(obj)

以上两段代码说明在 Swift 中的 var 也有 OC 中 id 的影子，所以在 Swift 中做类型检测也是很有必要的。所以在 Swift 中会经常看相似这样的代码：

var obj = NSObject()print(obj)obj = HGPerson()print(obj)let person = obj as! HGPersonprint(person)

在上面使用到了一个类型转换的标识 as!，在 Swift 中的一律类型转换标识，如下：

1. is : 使用于判断一个实例能否是某一种类型
2. as : 将实例转成某一种类型 （比方子类->父类转换）
3. as?：将某个类型转成可选类型,通过判断可选类型能否有值,来决定能否转化成功
4. as!： 将某个类型转成具体的类型,但是注意:假如不是该类型,那么程序会崩溃

1.2 数据类型

在 OC 中的数据类型主要分成两种：基本数据类型与对象类型，在 Swift 中也一样。但是在 Swift 中最为常见的是 结构体（基本数据类型），比方 String 与 Int8：

public struct Stringpublic struct Int8 : FixedWidthInteger, SignedInteger

在 OC 中字符串是对象类型，数字是基本数据类型（NSNumber 除外）。当然这些结构体类型的数据，都是可以无缝衔接到对象类型，比方 NSString，一般用 String 就能满足很多的场景。

1.3 可选与非可选数据类型

在 Swift 中，一个变量没有 默认值 这种说法。一个变量要么是有值、要么没有值，这就叫做 可选类型。Swift 中的可选类型，是一种单独的数据类型。有可选类型，那么就有非可选类型。
关于这部分，前不久在简书上简单的总结了一下，可以参考 对 Swift 中可选类型的了解。

有值与没值、是两种状态，而不是两种具体的值。

1.4 结构体

先看一个简单的结构体：

// 定义一个结构体struct HGStruct {    var name:String?    var des:String?        func desFunc() -> Void {        print(name! + "_" + des!)    }}// 可以这样用：// 无参构造函数var st = HGStruct()// 逐一构造函数st = HGStruct(name: "HG", des: "Good")// 调使用结构体函数st.desFunc()

对于一个结构体来说，只需是有属性，系统默认生成两个构造函数，一个是无参构造函数，一个是 逐一构造函数。

逐一构造函数: 将所有的属性作为参数的构造函数。

构造函数：不使用 func 作为修饰，函数名统一为 init。

以上的两种构造函数是自动生成的，也可以自己设置构造函数。比方：

// 自己设置构造函数init(name:String) {    self.name = name    des = "Good!"}

自己设置的构造函数有一个显著的特点，不需要加 func 关键字。还有一个特点是：一旦自己设置了构造函数，那么自动生成的构造函数都将失效。
这里有一个方法可以做到构造函数的随便组合，就是重写 逐一构造函数，将所有的参数都弄一个默认值。如下：

// 重写 逐一构造函数init(name:String = "", des:String = "") {    self.name = name    self.des = des}

关于结构体，也是属于基本数据类型，是 值 类型，是不能直接在结构体内部直接修改其 属性 的值的。比方：

// 升级名字func update(name:String) -> Void {    self.name = name}

这样是会直接报错的，必需在 func 的前面加一个关键字 mutating。如：

// 升级名字mutating func update(name:String) -> Void {    self.name = name}

到这里，关于 Swift 中结构体的用详情，基本差不多了。在 Swift 的实际开发中，结构体的用也是比较频繁的。由上面的详情可以知道，功能也比 OC 中的多，主要的起因是有 函数。在上面的代码中也能看在，也有 self 关键字，用方式与 Class 几乎一致。所以在少量轻量级的场合，可以直接选择用结构体。

1.5 枚举

简单的定义：

// 枚举定义enum HGEnum {    case go    case back}

可以这样的用：

{    direction(d: HGEnum.go)}func direction(d:HGEnum) -> Void {    switch d {    case .go:        print("go")    case .back:        print("back")            }}

从上面也能看出获取枚举的方式，HGEnum.go 与 .go 是同一个，但是要保证只有这个枚举有这个 go，否则出错。

关于枚举的值

直接这样打印：

print(HGEnum.go)

发现打印结果是：go，枚举值仅仅是一个符号, 不代表任何类型。假如想要绑定原始值, 必需指明枚举的类型，比方：

// 枚举定义enum HGEnum:String {    case go   = "go_value"    case back = "back_value"}

一旦指明了枚举的类型，在用上没有区别，可以用 rawValue 获取具体的值：

print(HGEnum.go.rawValue)  // go_valueprint(HGEnum.go)           // go

枚举有能定义函数

func enumFunc() {    print(self.rawValue, "_哈哈哈哈哈")}

代使用方式：

HGEnum.go.enumFunc()HGEnum.back.enumFunc()

二、方法到函数

在 Swift 中就没有方法这种叫法了，统一称函数。函数定义的模板如下：

func 函数名(参数列表) -> 返回值类型 {     代码块     return 返回值 } 

对于函数这一块，没有什么特别的。这里有一个规律，就是 Swift 函数转成 OC 方法的时候，是这样的：

// Swift 函数func hello(name:String, from:String) -> String {    return "你好!我是 " + name + ", 来自于 " + from}// 转成 OC 是这样的 // - (NSString*)helloWithName:(NSString*)name from:(NSString*)from;

上面代码的亮点是函数名与方法名，是有规律的。这也给我们一个在 OC 中方法命名规范的提示：第一个参数以 With 做拼接，并首字母大写，其它参数前的方法名部分直接用参数的名称。当然，规范仅仅是一个规范而已，苹果的 API 也并非一律按照这样的规范，比方：

// tap- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {    // TODO: 待解决}

关于 函数 这一块，相对 OC 来说有以下两个显著的不同：

1. 函数中可以定义函数，这个功能在 OC 也有相似的，就是方法中定义 Block。
2. 函数重载，这个在 OC 中是实现不了的。

三、类

在 OC 中有三种 Class：Block，NSProxy 与 NSObject。据我现在所知，在 Swift 中没有了 Block，但是有了一种闭包的东西。除此之外，在 Swift 中的 Class 可以不使用继承任何的基类。
在 OC 中即便是一个简单的数据模型都需要继承于 NSObeject，显得有些重量级。但是在实际上还是有很多区别的。

3.1 简单的定义

有两个致命的规律：

1. 定义的 Class 肯定要有属性，否则直接报错
2. 创立一个类的实例, 必需在创立之后, 里面所有的非可选属性必需有值，否则报错

class HGPerson {    }

没有任何属性，直接报错。

class HGPerson {    var name:String}

name 为非可选，创立实例之后 name 没有值，直接报错。

class HGPerson {    var name:String    // var name:String = ""    // 构造函数    init() {        name = ""    }}

重写构造函数，非可选属性 name 默认有值。每个 Class 都会有一个默认的无参构造函数，一旦有重写，默认构造函数将失效。

在用上，与 OC 中的几乎完全一样。

3.2 特殊方法

在一个 Class 中，我们往往比较在乎的是一个实例的生命周期。总之一句话：生于构造函数，毁于虚构函数。
构造函数：一个特殊的函数，与结构体中的一样。不使用 func 作为修饰，函数名统一为 init。
虚构函数：实例销毁时系统调使用的函数 deinit，功能与 OC 中的 dealloc 一样。

3.3 setter 与 getter 方法

这里的 setter 与 getter 方法，和 OC 中的还有点不一样。比方：

var doSomething:String {    set {        // setter            }        get {        // getter        return ""    }}

这里需要注意一点，在 Swift 中的只读属性，将上面的 set 去掉，就是只读属性的。

3.4 属性监听

var sex:String = "" {    willSet(newValue) {        print("当前的值 = " + self.sex + ",新值 = " + newValue)    }    didSet(oldValue) {        print("当前的值 = " + self.sex + ",之前的值 = " + oldValue)    }}

这里要注意一个问题：在构造函数中的 setter 方法是不会被监听到的。

3.3 注意事项

Swift 中的 Class 是可以没有基类的。

四、协议（代理商）

4.1 简单用

定义

/// MARK 定义一个代理商protocol DetailDelegate: NSObjectProtocol {    // 从控制器返回 content 内容    func detail(vc:DelegateDetailController?, content:String?)}

关键字：protocol 与 NSObjectProtocol。这里需要注意一点的是，在 Swift 中的协议也是可以没有基类的，在 OC 中也一样，但是一般都是继承于 NSObject 协议。在 Swift 中有以下三种情况：

1. 没有继承，这种情况只能用在没有继承 NSObject 的 Class 中，不能用 weak 修饰，毕竟 weak 只能修饰 Class。
2. 继承于 class，这种情况可使用于所有的 Class。
3. 继承于 NSObjectProtocol，这种情况可使用于所有的 Class。与第2中的区别是，这个协议自带了很多的系统协议。所以继承于这种协议的不推荐用在没有继承于 NSObject 的 Class 中，由于在 Swift 中的所有协议函数都是强制必需要实现的。

综上，继承于 class一般用在没有继承于 NSObject 的 Class 中，而继承于 NSObjectProtocol一般用于继承于 NSObject 的 Class 中。没有继承的用在结构体与枚举中，这个就很厉害了，在上面的结构体与枚举中就知道，这两种数据结构也是可以定义函数的，所以有这样的的协议场景也是很相当正当的。

delegate变量

// 定义个代理商变量weak var delegate:DetailDelegate?

与 OC 一致，需要弱化。

执行

let cell = tableView.cellForRow(at: indexPath)delegate?.detail(vc: self, content: cell?.textLabel?.text)

五、控制器中的代码布局

这里说的控制器代码布局，仅仅是一个例子，只需是 Class 都是同样的套路
在 OC 中，默认的代码结构是这样的：

#import "HomeController.h"@interface HomeController ()@end@implementation HomeController- (void)viewDidLoad {    [super viewDidLoad];    // Do any additional setup after loading the view.}@end

核心的代码都是写在 @implementation 与 @end 之间，假如要将其中的功能分开，只能是通过 分类 或者者直接另建文件。在 Swift 中，默认的结构是这样的：

class HomeController: UIViewController {    override func viewDidLoad() {        super.viewDidLoad()    }}

一律的代码，都是写在第一个大括号中。但是可以借助 extension 来做分割：

/// 系统相关函数实现class HomeController: UIViewController {        override func viewDidLoad() {        super.viewDidLoad()        // Do any additional setup after loading the view.    }}/// 登录 相关的函数实现extension HomeController {    }/// 叫车 相关的函数实现extension HomeController {    }/// UITableViewDelegate 的协议函数extension HomeController: UITableViewDelegate {    }/// UITableViewDataSource 的协议函数extension HomeController: UITableViewDataSource {    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {        return 45;    }        func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {        let cell = tableView.dequeueReusableCell(withIdentifier: "id")                return cell!    }}/// HGObjectDelegate 协议函数extension HomeController: HGObjectDelegate {    }

以上是一个简单的分割，在实际的开发中，可能没有这么简单，毕竟实际的项目的代码更加复杂。
上面简单的代码中可以看到可以通过 extension 做针对性的分离。

六、@objc

@objc 这个关键组合，作使用是在 Swift 中实现，在 OC 中用。

6.1 协议中用

在协议中，会看到这个关键词。在上面的详情中，Swift 中的协议一旦被遵循，那所有的函数都必需是先实现的，没有可选函数这一说。换成 OC 的说法就是必选的。在 OC 中没有实现必选方法是报警告，在 Swift 中是直接报错。那么问题来了：在 OC 中是有可选协议方法的，假如这个协议是在 Swift 中实现，应该如何解决呢？

1. OC 中如何用 Swift 中的协议？
2. 如何在 Swift 中给 OC 提供可选协议函数？

一个简单的例子如下：

@objcprotocol HGObjectDelegate {    // 可选的协议方法    @objc optional func optionalFunc()}

@objc 代表可以在 OC 中用，optional 在 OC 中是可选的协议方法。

现在看在 HGObjectDelegate 没有任何的集成，相当于在 OC 中没有继承 NSObject 一样。但是可以直接用与 OC 中的所有 Class 中。在 Swift 中，这个协议是不能用在没有继承的 Class 中的。

6.2 函数中用

在 Swift 实现的函数，是可以很好的转换成 OC 方法的，一般不用转换，其实在上面也已经有详情。但是 Swift 中的函数与 OC 中的方法还是有所差异的，比方在 Swift 中有重载，然而。。。。这种情况就需要 @objc 做一下转换。比方以下的代码：

@objc(sumIntWithA:b:)func sum(a:Int, b:Int) -> Int {    print("Int")    return a+b;}@objc(sumDoubleWithA:b:)func sum(a:Double, b:Double) -> Double {    print("Double")    return a+b}

一看就懂，无需详情。
在 OC 中这么用：

HGObject* obj = [HGObject new];NSInteger int_Result = [obj sumIntWithA:9 b:4];float doble_Result = [obj sumDoubleWithA:3.2 b:2.3];NSLog(@"%zd %f", int_Result, doble_Result);

在 Swift 中这么用：

let obj = HGObject();let sum1 = obj.sum(a: 1, b: 2)let sum2 = obj.sum(a: 2.3, b: 2.5)print(sum1, sum2)