Swift怎么用？Swift基础用法教程详解

Swift是苹果公司在2014年推出的开源现代编程语言，广泛应用于iOS、macOS、watchOS、tvOS及服务器端开发。掌握Swift的核心路径非常清晰：先准备好可运行的代码环境，理解常量变量与强类型推断机制，掌握基础控制流与函数表达，重点攻克其核心特性“可选类型（Optional）”的安全解包，最后理清结构体与类的选型逻辑。遵循这套实用脉络，初学者便能在短时间内建立起编写规范、安全且高效Swift程序的坚实基础。

一、环境准备与第一个Swift程序

要开始编写并运行Swift代码，通常有两种主要途径：图形化的集成开发环境，或者轻量快捷的终端命令行工具。根据当前的操作系统与实际开发需求，可以按需选择适合的工作方式：

• macOS平台：推荐在App Store中下载并安装官方IDE Xcode。在Xcode中可以直接新建“Playground”文件，无需编译整个工程即可实时预览代码运行结果，是测试语法的绝佳沙盒；
• 命令行终端：安装Xcode命令行工具后，在终端直接输入 swift 即可进入交互式REPL（Read-Eval-Print Loop）环境，随输随跑；
• Linux及Windows平台：可访问Swift官方网站（swift.org）下载对应的官方独立工具链，通过终端命令 swift run 进行跨平台编译与运行。

在任意目录下创建一个名为 main.swift 的源文件，输入以下基础代码：

// main.swift：第一个Swift程序
let greeting = "Hello, Swift!"
let year = 2026

print("\(greeting) 欢迎在 \(year) 年开始学习现代Swift语法。")

在终端中切换到该文件所在目录，执行以下运行命令：

swift main.swift

与C、C++或Java不同，Swift在顶级脚本中不需要定义显式的 main() 入口函数，代码自上而下天然顺序执行；语句末尾也无需强制使用分号 ;。

二、常量、变量与基本数据类型

在Swift中定义一个存储值时，必须明确区分该值是否具备可变性。Swift的设计哲学是“默认不可变”，提倡优先使用常量来保证代码的并发安全与确定性：

• let：用于声明常量。一旦完成初始化赋值后，其内存引用或值绝对不可再次修改；
• var：用于声明变量。后续可以多次赋予同类型的新值。

1. 类型推断与显式标注

Swift是一门强类型静态语言，但得益于强大的类型推断能力，在绝大多数场景下无需手动写出冗长的类型名称；编译器会根据初始值自动推导类型：

// 自动类型推断
let maximumScore = 100         // 推断为 Int
let pi = 3.1415926             // 推断为 Double
var isOnline = true            // 推断为 Bool
var siteTitle = "开发技术库"     // 推断为 String

// 显式类型标注（当初始值不明确或需限制特定精度时使用）
let responseCode: Int = 200
let rawRatio: Float = 0.5

2. 核心集合类型：数组、字典与集合

Swift标准库提供了三种核心集合类型：Array（有序列表）、Dictionary（无序键值对）以及 Set（无序不重复值集）。集合类型的可变性同样直接受 let 与 var 控制：

// 1. Array：有序列表
var techStack: [String] = ["Swift", "SwiftUI", "Combine"]
techStack.append("Vapor")
print("首个技术项：\(techStack[0])，当前总数：\(techStack.count)")

// 2. Dictionary：键值对集合
var httpStatus: [Int: String] = [200: "OK", 404: "Not Found"]
httpStatus[500] = "Internal Server Error"
print("状态码200含义：\(httpStatus[200] ?? "未知")")

// 3. Set：唯一集合
var uniqueTags: Set = ["iOS", "macOS", "iOS"]
print("唯一标签数：\(uniqueTags.count)") // 结果为 2

三、Swift核心分水岭：可选类型（Optional）与安全解包

在许多传统编程语言中，变量若指向空指针（null），在运行时调用其属性或方法会引发致命崩溃（NullPointerException）。Swift通过可选类型（Optional）彻底在语言层面解决了这一隐患。

在Swift中，普通类型的变量（如 String）保证永远拥有非空值；若一个变量可能存在值，也可能没有值（即为 nil），则必须显式声明为可选类型，在类型后追加问号 ?：

var userNickname: String? = "CoderK"
userNickname = nil // 合法赋值，表示目前没有昵称

可选类型本质上是一个包装盒（Enum枚举）：盒子里要么装着具体的包裹（Some(Wrapped)），要么空无一物（None）。要使用其中的数据，必须通过解包（Unwrapping）流程。

安全解包的三种标准方案

1. 可选绑定（if let）：在条件分支中安全打开盒子。如果盒中有值，则将其赋值给临时常量并执行作用域内代码；
2. 守卫语句（guard let）：常用于函数内部前置条件检查。若没有值则执行 else 并通过 return 提早退出，成功解包后的变量可在后续代码中全局使用，有效避免多层缩进形成的“末日金字塔”；
3. 空合运算符（??）：若可选变量为 nil，则自动回退并返回右侧设定的默认值。

// 方案 1: if let 条件绑定
if let actualName = userNickname {
    print("用户昵称存在：\(actualName)")
} else {
    print("用户尚未设置昵称")
}

// 方案 2: guard let 扁平化守卫
func displayUserProfile(inputName: String?) {
    guard let name = inputName else {
        print("错误：未提供有效用户名，退出处理。")
        return
    }
    // 解包成功的 name 在 guard 之后直接可见
    print("正在渲染用户面板：\(name)")
}

// 方案 3: ?? 空合默认值
let displayName = userNickname ?? "默认访客"
print("欢迎光临，\(displayName)")

四、逻辑控制与模式匹配

Swift提供了简洁且高度表达性的控制流语句。除了经典的条件判断与循环之外，其强大的 switch 模式匹配是该语言的一大特色。

1. 条件控制：if-else 与 guard

与许多语言不同，Swift的条件表达式中不需要加外层小括号 ()，但执行体的大括号 {} 必须完整保留，条件判断必须是明确的 Bool 类型，不存在数字零转为假的隐式转换。

2. 范围迭代：for-in 与区间运算符

Swift使用区间运算符配合 for-in 可以极度精简地完成循环遍历：

• 1...5：闭区间运算符，包含边界数值 1、2、3、4、5；
• 0..：半开区间运算符，包含起始值 0，直到 count - 1，常用于基于索引访问数组。

// 闭区间遍历
for index in 1...3 {
    print("当前轮次：\(index)")
}

// 遍历字典
let scores = ["语文": 95, "数学": 98, "英语": 91]
for (subject, score) in scores {
    print("科目: \(subject), 得分: \(score)")
}

3. 全能匹配：增强型 switch

在Swift中，switch 语句具备以下现代化特性：

• 无需显式书写 break：每个 case 执行完成后默认自动跳出，杜绝漏写 break 导致的穿透隐患；
• 匹配完备性检查：编译器强制要求覆盖所有可能的分支，若未完全列举则必须提供 default；
• 支持复合匹配、元组匹配与 where 过滤条件：能够直接对值范围与复合状态进行模式匹配。

let httpCode = 404

switch httpCode {
case 200:
    print("请求成功")
case 400..<500:
    print("客户端请求错误，代码：\(httpCode)")
case 500...599 where httpCode == 502:
    print("特定服务网关错误")
case 500...599:
    print("其他服务器故障")
default:
    print("未收录的状态码")
}

五、函数与闭包简明用法

在Swift中，函数是一等公民（First-Class Citizens），可以作为参数传递、作为返回值返回，或者赋值给变量存储。

1. 参数标签与默认参数

Swift函数支持“外部参数标签”与“内部参数名称”分离，使调用端代码如同阅读自然英语句子般清晰易懂：

// 外部标签为 to，内部形参名为 recipient
func sendNotification(to recipient: String, priority: Int = 1) -> Bool {
    print("向 \(recipient) 发送优先级为 \(priority) 的系统消息")
    return true
}

// 调用时外部标签极具可读性
let isSent = sendNotification(to: "Alex", priority: 2)

2. 闭包（Closure）实战

闭包是自包含的代码功能块，类似于其他语言中的匿名函数或Lambda。在集合的转换操作（如 map、filter、sorted）中极为常见。Swift提供了非常简洁的尾随闭包语法与参数简写符号 $0、$1：

let numbers = [12, 5, 27, 8, 43]

// 过滤出所有大于10的数并升序排列
let filtered = numbers.filter { $0 > 10 }.sorted { $0 < $1 }
print("处理结果：\(filtered)") // [12, 27, 43]

六、结构体（Struct）与类（Class）的选择

理解结构体与类的本质差异，是编写地道Swift代码的关键门槛。与其他面向对象为主的语言不同，Swift官方推荐在绝大多数场景下优先使用结构体（Struct）。

核心差异：值类型 vs 引用类型

• 结构体（Struct）是值类型（Value Type）：当它被赋值给新变量或作为函数参数传递时，传递的是其完整的独立副本（Swift采用写时复制 Copy-on-Write 机制保障高性能）。修改副本绝不会影响原始实例；结构体内存分配在高效的栈上，无需引用计数参与；
• 类（Class）是引用类型（Reference Type）：当它被传递时，传递的是指向堆内存中同一实例的引用指针。多个变量指向同一实例时，任意一处修改都会导致所有变量观察到变更；由自动引用计数（ARC）管理生命周期，支持继承与析构器。

// 1. 结构体（值语义示例）
struct Position {
    var x: Int
    var y: Int
}

var posA = Position(x: 10, y: 20)
var posB = posA      // 执行内存值拷贝
posB.x = 99
print("posA.x=\(posA.x), posB.x=\(posB.x)") // 输出: 10, 99（互不干扰）

// 2. 类（引用语义示例）
class SessionState {
    var token: String
    init(token: String) { self.token = token }
}

let sessionA = SessionState(token: "INIT_TOKEN")
let sessionB = sessionA // 复制的是内存地址指针
sessionB.token = "NEW_TOKEN"
print("sessionA.token=\(sessionA.token)") // 输出: NEW_TOKEN（同一实例）

七、错误处理与稳健编程

Swift采用显式类型化的错误处理模型。函数如果可能抛出错误，必须在签名中标记 throws。调用端必须配合 do-catch 与 try 关键字完成调用：

// 1. 定义遵循 Error 协议的枚举
enum DataParseError: Error {
    case emptyInput
    case invalidFormat(field: String)
}

// 2. 抛出错误的函数
func parsePayload(_ input: String) throws -> String {
    guard !input.isEmpty else {
        throw DataParseError.emptyInput
    }
    return "解析完成: \(input)"
}

// 3. do-catch 安全捕获
do {
    let result = try parsePayload("")
    print(result)
} catch DataParseError.emptyInput {
    print("错误提示：输入内容为空，终止解析。")
} catch {
    print("捕获未知错误：\(error)")
}

// 4. try? 转换为可选类型
// 若执行成功则返回 Optional，若抛出异常则静默返回 nil
let optionalResult = try? parsePayload("valid_data")

八、总结与进阶学习路线

通过本文的讲解，我们可以将“Swift怎么用”的核心答案浓缩为以下四部曲：

• 从安全常量起步：默认使用 let 声明，仅在必要时使用 var，借助自动类型推断保持代码整洁；
• 掌握防崩之盾：遇到不确定值时必须封装为 Optional，在消费时坚决采用 if let、guard let 或 ?? 安全解包，杜绝随意强制解包；
• 优先拥抱值语义：业务实体与界面层优先选用轻量、线程安全的 struct，仅在需要共享状态与引用标识时选用 class；
• 函数式与模式匹配组合：善用闭包与无穿透 switch 处理复杂逻辑分支。