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

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u010960265/article/details/82020702

一、数据

Swift 是类型安全的语言：

• Swift 必须明确数据类型
• 如果取值错误会直接报错
• Swift 会进行溢出检查 （OC 也会检查）
• 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 name
print(name)

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

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

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

let name: String
name = "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! HGPerson
print(obj)
obj = HGPerson()
print(obj)

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

var obj = NSObject()
print(obj)
obj = HGPerson()
print(obj)

let person = obj as! HGPerson
print(person)

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

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

1.2 数据类型

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

public struct String
public 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_value
print(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 来说有以下两个明显的不同：

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

三、类

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

3.1 简单的定义

有两个致命的规律：

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

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 中有以下三种情况：

没有继承，这种情况只能使用在没有继承 NSObject 的 Class 中，不能使用 weak 修饰，毕竟 weak 只能修饰 Class。
继承于 class，这种情况可用于所有的 Class。
继承于 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 中实现，应该如何处理呢？

• OC 中如何使用 Swift 中的协议？
• 如何在 Swift 中给 OC 提供可选协议函数？

一个简单的例子如下：

@objc
protocol 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)