Optional：为什么一个 String? 能让代码少掉很多崩溃？

在 Swift 里，Optional 几乎是每个开发者绕不过去的第一个门槛。

刚开始接触时，很多人会觉得它有点"烦"：

swift 复制代码

var name: String?

为什么不能直接写 String？

为什么取值还要 if let、guard let？

为什么后面还会冒出 ?、!、??？但真正开始做 iOS 项目以后，你会发现，Optional 并不是 Swift 故意增加复杂度，而是在强迫我们把一个很现实的问题考虑清楚：

这个值，到底有没有可能不存在？

为什么 Swift 要专门设计 Optional？

假设我们现在要处理一个用户模型：

swift 复制代码

struct User {
    let name: String
    let email: String
}

看起来没什么问题。但真实业务里，用户可能并没有填写邮箱。如果接口返回：

json 复制代码

{
    "name": "Tom",
    "email": null
}

此时 email 就不能再简单地认为一定存在。 Swift 的处理方式是明确告诉开发者：

swift 复制代码

struct User {
    let name: String
    let email: String?
}

这里的：String?表示的并不是一个普通 String，而是：

这个位置要么有一个字符串，要么什么都没有。

var email: String?

js 复制代码

email = "tom@example.com"
email = nil

Optional 本质上是什么？

从概念上来说，Optional 可以理解成一个枚举。Swift 标准库中的逻辑类似于：

swift 复制代码

enum Optional<Wrapped> {
    case none
    case some(Wrapped)
}

swift 复制代码

//例如：
var age: Int
// 可以理解成如下这种形式：
Optional<Int>
//如果有值
age = 18
Optional.some(18)
//如果没有值
age = nil
Optional.none

所以 Optional 并不是"特殊的 nil"，而是一个明确描述值可能存在，也可能不存在的数据类型。

Swift 中应该怎么安全处理 Optional？

1. `if let`：有值就执行

最常见的方式就是 Optional Binding：

swift 复制代码

var nickname: String? = "SwiftBoy"

if let nickname = nickname {
    print("昵称：\(nickname)")
}

输出：昵称：SwiftBoy 这里其实完成了两件事。先判断：nickname是不是 nil。如果不是，就把里面真正的 String 取出来，赋值给新的：nickname。进入代码块以后，这个变量已经不再是： String?而是：String

2. `guard let`：不满足条件就提前退出

在真实 iOS 项目中，我个人使用 guard let 的频率通常比 if let 更高。例如：

swift 复制代码

func showUser(name: String?) {
    guard let name else {
        print("用户名不存在")
        return
    }

    print("当前用户：\(name)")
}

如果使用多层 if let代码很快就会出现多层嵌套：

swift 复制代码

if let user = user {
    if let token = token {
        if let id = user.id {
            // 真正业务代码
        }
    }
}

使用 guard 可以改成：

swift 复制代码

guard let user else { return }
guard let token else { return }
guard let id = user.id else { return }
// 真正业务代码
....

这样代码的主流程会更加清楚。

if let：有值之后做点什么；guard let：没有值就赶紧退出

??：给 Optional 一个默认值有时候我们并不关心值是否为空，只需要为空时提供一个默认值。实际开发中非常常见。

例如服务端某个字段可能为空：

swift 复制代码

let avatar = user.avatarURL ?? ""

Optional Chaining：一路有值就继续 iOS 开发中经常会出现多层对象访问。

swift 复制代码

struct Address {
    let city: String
}

struct User {
    let address: Address?
}

let user: User? = User(
    address: Address(city: "Shanghai")
)

如果我们想获取城市，可以这样写：

swift 复制代码

let city = user?.address?.city

print(city ?? "未知城市")

?.就是 Optional Chaining。它的逻辑可以理解成：user 有值吗？->有，再看 address 有值吗？->有，再获取 city->中间任何一步为 nil，结果直接变成 nil

最危险的一种方式：! Swift 允许我们直接强制解包：

swift 复制代码

let name: String? = "Tom"

print(name!)

因为这里确实有值，所以可以正常运行。

但如果：

swift 复制代码

let name: String? = nil

print(name!)

程序会直接崩溃！！！

!真正表达的意思是"我向编译器保证这里一定有值，如果没有值，崩溃算我的。" 所以实际项目里，强制解包应该非常谨慎。

最后

如果只记住 Optional 的语法：

swift 复制代码

?
!
??
if let
guard let

其实并没有真正理解 Optional。

它真正解决的是一个很基础，却又非常重要的问题：

程序如何正确表达"一个值可能不存在"。

当我们开始用这种方式思考数据状态时，Optional 就不再是 Swift 里那个让人头疼的问号，而会逐渐变成一个非常自然的类型设计工具。

Optional：为什么一个 String? 能让代码少掉很多崩溃？

为什么 Swift 要专门设计 Optional？

Optional 本质上是什么？

1. if let：有值就执行

2. guard let：不满足条件就提前退出

最后

1. `if let`：有值就执行

2. `guard let`：不满足条件就提前退出