Swift 编程语言入门教程 – wiki基地

---

Swift 编程语言入门教程：从零开始掌握这门强大的语言

引言：Swift 是什么？为何学习它？

欢迎来到 Swift 的世界！Swift 是由苹果公司开发的一种强大而直观的编程语言，用于为 iOS、macOS、watchOS、tvOS 乃至 Linux、Windows 等平台构建各种应用。自2014年发布以来，Swift 以其现代化的特性、卓越的性能和高度的安全性迅速获得了开发者的青睐。

为何选择学习 Swift？

1. 现代化与安全： Swift 吸收了现代编程语言的精华，去除了 C 和 Objective-C 中一些潜在的安全隐患，例如空指针问题（通过引入 Optional 类型）。它的语法简洁、易读，有助于写出更安全、更可靠的代码。
2. 性能卓越： Swift 的设计目标之一就是高性能。它的编译器经过优化，能够生成运行速度极快的机器码，在许多任务上甚至能媲美 C++。
3. 功能强大： Swift 支持面向对象、面向协议和函数式编程等多种编程范式，提供了灵活的工具来解决复杂问题。
4. 苹果生态核心： 如果你希望开发 iPhone、iPad、Mac、Apple Watch 或 Apple TV 应用，Swift 无疑是首选语言。它与 Apple 的 Cocoa 和 Cocoa Touch 框架无缝集成。
5. 社区活跃： Swift 是一个开源项目，拥有一个庞大的、充满活力的社区，提供了丰富的学习资源和支持。
6. 应用广泛： 不仅限于苹果平台，Swift 也在服务器端开发（如 Vapor、Kitura 框架）、命令行工具、甚至机器学习等领域展现出潜力。

本教程旨在帮助完全没有 Swift 基础，或只有少量编程经验的初学者快速入门。我们将从零开始，一步步了解 Swift 的基础语法、核心概念，并通过动手实践来巩固知识。

第一步：准备开发环境

学习 Swift 最简单的方式是在 macOS 系统上使用 Xcode。Xcode 是苹果官方的集成开发环境（IDE），包含了 Swift 编译器以及用于构建各种苹果应用所需的工具。

1. 获取 Xcode： 如果你使用的是 macOS，可以直接从 App Store 免费下载 Xcode。安装过程可能需要一些时间，因为它包含了大量组件。
2. 使用 Playgrounds： Xcode 中的 Swift Playgrounds 是一个绝佳的入门工具。它允许你实时书写和运行 Swift 代码，立即看到结果，无需创建完整的项目。对于初学者学习语法和概念来说，Playgrounds 非常方便。
   • 打开 Xcode。
   • 选择 “File” -> “New” -> “Playground…”。
   • 选择一个模板（例如 “Blank” 或 “iOS”）。
   • 命名你的 Playground 文件并保存。
   • 一个新的窗口将打开，你可以在左侧的代码编辑区输入 Swift 代码，右侧的结果边栏会显示代码的执行结果。

如果你没有 macOS 设备，也可以考虑以下选择（但可能功能受限或配置复杂）：
* Swift Playgrounds for iPad： 在 iPad 上提供一个可视化的学习和实践环境。
* 在线 Swift 编译器： 搜索 “online swift compiler” 可以找到一些网站，让你在浏览器中运行 Swift 代码（通常只支持基础语法）。
* Swift on Linux/Windows： 如果你有 Linux 或 Windows 系统，可以安装 Swift toolchain。但这通常更适合有一定经验的开发者进行命令行开发或服务器端开发。

本教程将主要基于 Xcode Playgrounds 进行讲解。

第二步：Swift 基础语法

我们从最基础的部分开始。

1. 注释 (Comments)

注释用于解释代码，编译器会忽略它们。
* 单行注释： 使用双斜杠 //
swift
// 这是一个单行注释
* 多行注释： 使用 /* ... */
swift
/*
这是一个
多行注释
可以跨越多行
*/

2. 打印输出 (Printing Output)

使用 print() 函数可以在控制台或 Playground 的结果边栏中显示信息。
swift
print("你好，Swift！") // 输出: 你好，Swift！

3. 变量和常量 (Variables and Constants)

• 常量 (Constants)： 使用 let 声明，一旦赋值后不能更改。推荐优先使用常量，这有助于编写更安全、更易预测的代码。
  swift
let maximumNumberOfLoginAttempts = 10 // 登录尝试的最大次数
let pi = 3.14159 // 圆周率
• 变量 (Variables)： 使用 var 声明，可以多次更改其值。
  swift
var currentLoginAttempt = 0 // 当前登录尝试次数
var welcomeMessage = "欢迎使用 Swift" // 欢迎消息
welcomeMessage = "欢迎回来！" // 可以修改变量的值

类型推断 (Type Inference)： Swift 是一门静态类型语言，意味着每个变量或常量都有一个特定的类型（如整数、字符串等）。Swift 具有强大的类型推断能力，通常你无需明确指定类型，编译器会自动推断。

swift
let meaningOfLife = 42 // Swift 推断为 Int 类型
let pi = 3.14159 // Swift 推断为 Double 类型
let name = "Alice" // Swift 推断为 String 类型

类型标注 (Type Annotation)： 如果需要或希望明确指定类型，可以使用类型标注，在变量名后加冒号和类型名称。
swift
var greeting: String = "Hello, playground" // 明确标注为 String 类型
var age: Int // 声明一个 Int 类型的变量，但暂时不赋值
age = 30 // 后续赋值

4. 基本数据类型 (Basic Data Types)

Swift 提供了多种内置的基本数据类型：

• 整数类型 (Integer Types)： Int 是最常用的整数类型，其大小与当前平台的原生字长相同（32位或64位）。还有指定大小的类型如 Int8, Int16, Int32, Int64 以及无符号类型 UInt, UInt8 等。
  swift
let integerLiteral = 100
let decimalInteger = -17
let binaryInteger = 0b10001 // 二进制表示
let octalInteger = 0o21 // 八进制表示
let hexadecimalInteger = 0x11 // 十六进制表示

• 浮点数类型 (Floating-Point Types)： 用于表示带小数的数字。Double 表示64位浮点数（精度更高），Float 表示32位浮点数。Double 是首选。
  swift
let doubleValue = 3.14159 // 默认推断为 Double
let anotherDouble: Double = 3.14 // 明确指定 Double
let floatValue: Float = 3.14 // 明确指定 Float

• 布尔类型 (Boolean Type)： Bool 类型只有两个值：true 和 false。
  swift
let orangesAreOrange = true
let turnipsAreDelicious = false

• 字符串类型 (String Type)： String 用于表示文本。
  swift
let someString = "这是一串字符串"
let multiLineString = """
这是一个多行字符串
可以用三个双引号包裹
"""
  字符串插值 (String Interpolation)： 在字符串中包含常量、变量或其他表达式的值。
  swift
let numberOfOranges = 5
let orangeMessage = "我有 \(numberOfOranges) 个橙子。" // 输出: 我有 5 个橙子。
let price = 1.25
let total = Double(numberOfOranges) * price // 需要将 Int 转为 Double 进行计算
let totalPriceMessage = "总价是 \(total) 元。" // 输出: 总价是 6.25 元。

5. 可选类型 (Optional Types)

这是 Swift 中一个非常重要的概念。 可选类型用来处理值可能缺失的情况。一个可选类型变量或者包含一个值，或者包含 nil，表示“没有值”。

你可以通过在类型名称后面加上问号 ? 来声明一个可选类型。

“`swift
var serverResponseCode: Int? = 404 // serverResponseCode 可能包含一个 Int 值，也可能没有 (nil)
print(serverResponseCode) // 输出: Optional(404)

serverResponseCode = nil // 现在它没有值了
print(serverResponseCode) // 输出: nil

var surveyAnswer: String? // 默认就是 nil
print(surveyAnswer) // 输出: nil
“`

强制解包 (Forced Unwrapping)： 如果你确定可选类型 肯定 包含一个值，可以使用感叹号 ! 来强制解包。如果此时值为 nil，程序会崩溃 (runtime error)。 因此，强制解包是危险的，应尽量避免。

swift
let possibleNumber = "123"
let convertedNumber = Int(possibleNumber) // convertedNumber 是 Int? 类型 (可选 Int)
print(convertedNumber!) // 确定 convertedNumber 不是 nil，强制解包并打印值 123

swift
let possibleNumber = "hello"
let convertedNumber = Int(possibleNumber) // convertedNumber 是 nil
// print(convertedNumber!) // !!! 这里会崩溃，因为 convertedNumber 是 nil

可选绑定 (Optional Binding)： 这是更安全的方式来检查可选类型是否包含值，并在有值时将其解包到一个临时常量或变量中。使用 if let 或 guard let。

swift
let anotherPossibleNumber = "456"
if let actualNumber = Int(anotherPossibleNumber) {
// 进入这个代码块说明 Int("456") 成功，actualNumber 现在是解包后的 Int 值 456
print("字符串 \"\(anotherPossibleNumber)\" 可以转换为整数 \(actualNumber)")
} else {
// 进入这个代码块说明转换失败 (比如字符串是 "hello")
print("字符串 \"\(anotherPossibleNumber)\" 无法转换为整数")
}

guard let 主要用于提前退出函数或循环，要求条件必须为真才能继续执行后续代码。

“`swift
func greet(person: [String: String]) {
guard let name = person[“name”] else {
// 如果 person 字典中没有 “name” 键，或者值为 nil，就进入这里
print(“找不到名字”)
return // 提前退出函数
}

// 如果找到了 name，它在这里已经被解包为 String 类型
print("你好，\(name)！")

}

greet(person: [“name”: “Bob”]) // 输出: 你好，Bob！
greet(person: [“city”: “Paris”]) // 输出: 找不到名字
“`

空合运算符 (Nil-Coalescing Operator)： 使用 ?? 来为可选类型提供一个默认值，如果可选类型有值，则使用其值；如果为 nil，则使用默认值。

“`swift
let defaultColorName = “红色”
var userDefinedColorName: String? // 默认为 nil

var colorNameToUse = userDefinedColorName ?? defaultColorName // userDefinedColorName 是 nil，使用 defaultColorName
print(colorNameToUse) // 输出: 红色

userDefinedColorName = “蓝色”
colorNameToUse = userDefinedColorName ?? defaultColorName // userDefinedColorName 有值，使用 userDefinedColorName
print(colorNameToUse) // 输出: 蓝色
“`

6. 运算符 (Operators)

Swift 支持常见的数学、赋值、比较和逻辑运算符。

• 算术运算符： +, -, *, /, % (取余)
  swift
let sum = 10 + 5 // 15
let difference = 20 - 7 // 13
let product = 4 * 6 // 24
let quotient = 10 / 2 // 5
let remainder = 10 % 3 // 1

• 赋值运算符： = (简单的赋值), +=, -=, *=, /=, %= (复合赋值)
  swift
var a = 10
a += 5 // a 现在是 15

• 比较运算符： == (等于), != (不等于), > (大于), < (小于), >= (大于等于), <= (小于等于)
  swift
let isEqual = (5 == 5) // true
let isNotEqual = (5 != 6) // true
let isGreater = (10 > 5) // true

• 逻辑运算符： && (逻辑与), || (逻辑或), ! (逻辑非)
  swift
let conditionsMet = (true && true) // true
let eitherOr = (true || false) // true
let isFalse = !true // false

第三步：控制流程 (Control Flow)

控制流程用于决定代码的执行顺序。

1. 条件语句 (Conditional Statements)

• if, else if, else：根据条件的布尔值执行不同的代码块。
  “`swift
  let temperature = 25

  if temperature < 0 {
  print(“非常冷”)
  } else if temperature >= 0 && temperature < 10 {
  print(“有点冷”)
  } else if temperature >= 10 && temperature < 25 {
  print(“凉爽”)
  } else { // 25度或更高
  print(“温暖或炎热”)
  }
  “`

• switch：更简洁地处理多个可能的匹配情况。Swift 的 switch 语句非常强大，它必须是穷尽的（覆盖所有可能的值），而且默认不会贯穿 (fallthrough)。
  “`swift
  let weather = “雨”

  switch weather {
  case “晴”:
  print(“天气晴朗”)
  case “多云”, “阴”: // 可以匹配多个值
  print(“有点阴沉”)
  case “雨”:
  print(“下雨了，带伞”)
  case “雪”:
  print(“下雪了，注意保暖”)
  default: // 必须包含 default 以覆盖所有其他可能性
  print(“未知天气”)
  }
  ``switch` 还可以用于范围匹配、元组匹配等高级用法，这里只介绍基本用法。

2. 循环 (Loops)

• for-in 循环：遍历序列（如数组、范围、字符串的字符等）。
  “`swift
  // 遍历范围
  for i in 1…5 { // 包含 1 到 5
  print(i)
  }
  // 输出: 1, 2, 3, 4, 5

  for i in 1..<5 { // 包含 1 到 4 (不包含 5)
  print(i)
  }
  // 输出: 1, 2, 3, 4

  // 遍历数组 (稍后会讲数组)
  let names = [“Anna”, “Alex”, “Brian”, “Jack”]
  for name in names {
  print(“你好，(name)”)
  }
  “`

• while 循环：当条件为真时重复执行代码块。
  swift
var count = 0
while count < 5 {
print("Count is \(count)")
count += 1
}
// 输出: Count is 0, Count is 1, Count is 2, Count is 3, Count is 4

• repeat-while 循环：先执行一次代码块，然后当条件为真时重复执行。
  swift
var i = 0
repeat {
print("Index is \(i)")
i += 1
} while i < 5
// 输出: Index is 0, Index is 1, Index is 2, Index is 3, Index is 4

第四步：集合类型 (Collection Types)

Swift 提供了三种主要的集合类型来存储值：数组 (Arrays)、字典 (Dictionaries) 和集合 (Sets)。它们都要求存储的元素类型一致。

可变性 (Mutability)： 使用 var 声明的集合是可变的（可以添加、删除或修改元素），使用 let 声明的集合是不可变的。

1. 数组 (Arrays)

有序的数据集合，元素通过索引（从0开始）访问。
“`swift
// 创建空数组
var someInts = Int // 类型标注 [Int]
print(“someInts 是一个包含 (someInts.count) 个 Int 值的空数组。”) // 输出: … 0 个 …

// 创建带初始值的数组
var shoppingList = [“猫粮”, “面包”, “牛奶”] // 类型推断为 [String]

// 访问和修改元素
print(shoppingList[0]) // 输出: 猫粮
shoppingList[1] = “香蕉” // 修改第二个元素
print(shoppingList) // 输出: [“猫粮”, “香蕉”, “牛奶”]

// 添加元素
shoppingList.append(“苹果”)
shoppingList += [“巧克力”, “芝士”]
print(shoppingList) // 输出: [“猫粮”, “香蕉”, “牛奶”, “苹果”, “巧克力”, “芝士”]

// 移除元素
shoppingList.remove(at: 0) // 移除第一个
let removedItem = shoppingList.removeLast() // 移除最后一个并返回其值
print(shoppingList) // 输出: [“香蕉”, “牛奶”, “苹果”, “巧克力”]
print(removedItem) // 输出: 芝士

// 遍历数组
for item in shoppingList {
print(item)
}
// 或同时获取索引和值
for (index, value) in shoppingList.enumerated() {
print(“Item (index + 1): (value)”)
}
“`

2. 字典 (Dictionaries)

无序的键值对集合，每个值都关联唯一的键。键必须是可哈希的类型（Swift 的基本类型默认都可哈希）。
“`swift
// 创建空字典
var namesOfIntegers = Int: String // 类型标注 [Int: String]
namesOfIntegers[16] = “sixteen” // 添加一个键值对

// 创建带初始值的字典
var airports: [String: String] = [“YYZ”: “Toronto Pearson”, “DUB”: “Dublin”] // 明确标注类型
// 或者使用类型推断
var airportsInfer = [“YYZ”: “Toronto Pearson”, “DUB”: “Dublin”] // 推断为 [String: String]

// 访问和修改值
print(airports[“YYZ”]) // 输出: Optional(“Toronto Pearson”) – 返回的是可选类型，因为键可能不存在
airports[“LHR”] = “London Heathrow” // 添加新的键值对
airports[“LHR”] = “London Heathrow Airport” // 修改现有值

if let airportName = airports[“DUB”] {
print(“都柏林的机场是 (airportName)”) // 安全地访问
} else {
print(“找不到 DUB 对应的机场”)
}

// 移除键值对
airports[“ART”] = “Artimis” // 添加一个
airports[“ART”] = nil // 将值设为 nil 即可移除对应的键值对

// 遍历字典
for (airportCode, airportName) in airports {
print(“(airportCode): (airportName)”)
}

// 遍历键或值
for airportCode in airports.keys {
print(“Code: (airportCode)”)
}

for airportName in airports.values {
print(“Name: (airportName)”)
}
“`

3. 集合 (Sets)

无序的唯一值集合。集合中的元素没有固定的顺序，且每个元素都必须是唯一的。元素类型必须是可哈希的。
“`swift
// 创建空集合
var letters = Set() // 类型标注 Set
letters.insert(“a”) // 添加元素

// 创建带初始值的集合
var favoriteGenres: Set = [“摇滚”, “古典”, “嘻哈”] // 明确标注类型
// 或者使用类型推断，但通常需要明确标注 Set 类型，因为看起来像数组
var favoriteGenresInfer: Set = [“摇滚”, “古典”, “嘻哈”] // 推断为 Set

// 插入元素 (如果元素已存在，不会重复添加)
favoriteGenres.insert(“爵士”)
print(favoriteGenres) // 输出可能顺序不同，例如: [“爵士”, “摇滚”, “古典”, “嘻哈”]

// 移除元素
if let removedGenre = favoriteGenres.remove(“古典”) {
print(“(removedGenre) 已被移除。”)
} else {
print(“找不到该元素。”)
}

// 检查是否包含某元素
if favoriteGenres.contains(“摇滚”) {
print(“我喜欢摇滚乐。”)
}

// 集合操作 (交集、并集、差集等)
let oddDigits: Set = [1, 3, 5, 7, 9]
let evenDigits: Set = [0, 2, 4, 6, 8]
let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]

oddDigits.union(evenDigits).sorted() // 并集: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
oddDigits.intersection(evenDigit).sorted() // 交集: [] (空集)
oddDigits.intersection(singleDigitPrimeNumbers).sorted() // 交集: [3, 5, 7]
oddDigits.subtracting(singleDigitPrimeNumbers).sorted() // oddDigits 减去共有部分: [1, 9]
oddDigits.symmetricDifference(singleDigitPrimeNumbers).sorted() // 对称差集 (不包含共有部分): [1, 2, 9]
“`

第五步：函数 (Functions)

函数是执行特定任务的代码块，可以接受参数并返回值。

“`swift
// 无参数、无返回值函数
func sayHello() {
print(“Hello!”)
}
sayHello() // 调用函数

// 带参数、无返回值函数
func greet(person: String) {
print(“你好，(person)！”)
}
greet(person: “张三”) // 调用函数，参数标签是 person

// 带参数、带返回值函数
func addTwoNumbers(_ a: Int, _ b: Int) -> Int { // -> Int 表示返回 Int 类型
return a + b // 使用 return 关键字返回值
}
let sum = addTwoNumbers(5, 3) // 调用函数，参数标签是 _ 表示调用时可以省略参数标签
print(sum) // 输出: 8

// 函数参数标签和参数名称
func greet(person name: String, alreadyGreeted: Bool) { // name 是内部参数名称，person 是外部参数标签
if alreadyGreeted {
print(“欢迎回来，(name)！”)
} else {
print(“你好，(name)！”)
}
}
greet(person: “李四”, alreadyGreeted: true) // 调用时必须使用外部参数标签

// 省略参数标签：使用 _
func multiply(_ a: Int, _ b: Int) -> Int {
return a * b
}
let product = multiply(4, 5) // 调用时无需参数标签
print(product) // 输出: 20

// 默认参数值
func greetWithDefault(person name: String, from city: String = “未知城市”) { // city 有默认值
print(“你好 (name)，来自 (city)。”)
}
greetWithDefault(person: “王五”) // 输出: 你好 王五，来自 未知城市。
greetWithDefault(person: “赵六”, from: “北京”) // 输出: 你好 赵六，来自 北京。
“`

第六步：结构体与类 (Structures and Classes)

结构体 (Struct) 和类 (Class) 是构建复杂数据结构的基础。它们都可以定义属性（存储值）和方法（执行功能）。

主要区别：值类型 vs 引用类型

• 结构体 (Struct)： 是值类型 (Value Type)。当你复制一个结构体实例时，会创建一个全新的副本。修改副本不会影响原实例。Swift 中的基本类型（Int, String, Array, Dictionary, Set 等）大都是结构体。
• 类 (Class)： 是引用类型 (Reference Type)。当你复制一个类实例时，复制的是引用，两个变量指向同一个内存中的实例。修改其中一个变量的属性会影响到另一个变量。

结构体示例：
“`swift
struct Point {
var x = 0.0 // 存储属性
var y = 0.0

// 存储属性的初始值可以在声明时指定，或者在 init 方法中指定

// 结构体的构造器 (Initializer)
init(x: Double, y: Double) {
    self.x = x // self 指代当前结构体的实例
    self.y = y
}

// 结构体的方法
func description() -> String { // 默认方法是不可修改属性的
    return "(\(x), \(y))"
}

mutating func moveBy(deltaX: Double, deltaY: Double) { // mutating 关键字允许方法修改结构体的属性
    x += deltaX
    y += deltaY
}

}

var origin = Point(x: 0.0, y: 0.0) // 创建结构体实例
var point1 = origin // 复制 origin 到 point1 (值复制)

print(“Origin: (origin.description())”) // 输出: Origin: (0.0, 0.0)
print(“Point1: (point1.description())”) // 输出: Point1: (0.0, 0.0)

point1.moveBy(deltaX: 10.0, deltaY: 5.0) // 修改 point1 的属性

print(“Origin after move: (origin.description())”) // 输出: Origin after move: (0.0, 0.0) – origin 不受影响
print(“Point1 after move: (point1.description())”) // 输出: Point1 after move: (10.0, 5.0)
“`

类示例：
“`swift
class Person {
var name: String // 存储属性，需要通过 init 方法初始化
var age: Int

// 类的构造器
init(name: String, age: Int) {
    self.name = name
    self.age = age
}

// 类的方法
func introduce() {
    print("我叫 \(name)，今年 \(age) 岁。")
}

}

let person1 = Person(name: “Tom”, age: 25) // 创建类实例
let person2 = person1 // 复制 person1 到 person2 (引用复制)

person1.introduce() // 输出: 我叫 Tom，今年 25 岁。
person2.introduce() // 输出: 我叫 Tom，今年 25 岁。

person2.age = 26 // 修改 person2 的 age 属性

person1.introduce() // 输出: 我叫 Tom，今年 26 岁。 – person1 也被影响了
person2.introduce() // 输出: 我叫 Tom，今年 26 岁。
“`

何时使用结构体，何时使用类？

通常推荐优先使用结构体，因为它更简单，且避免了引用类型可能带来的复杂问题（如意外修改）。在以下情况考虑使用类：
* 需要继承 (Inheritance) 时（结构体不支持继承）。
* 需要引用计数来管理内存时（Cocoa 框架中的许多对象就是类）。
* 当你需要两个实例引用同一个对象状态时。

第七步：枚举 (Enumerations)

枚举 (enum) 定义了一组相关的可能值。在 Swift 中，枚举功能非常强大，可以有关联值，甚至定义方法。

“`swift
// 简单的枚举
enum CompassPoint {
case north
case south
case east
case west
}

var directionToHead = CompassPoint.west // 使用枚举成员
directionToHead = .north // 当类型已知时可以省略枚举名称

// 在 switch 语句中使用枚举
switch directionToHead {
case .north:
print(“向北前进”)
case .south:
print(“向南前进”)
case .east:
print(“向东前进”)
case .west:
print(“向西前进”)
}

// 带原始值的枚举 (Raw Values)
enum Planet: Int { // 原始值类型为 Int，从 1 开始自动递增
case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune
}

let earthOrder = Planet.earth.rawValue // 获取原始值
print(“地球是太阳系的第 (earthOrder) 颗行星”) // 输出: … 第 3 颗行星

// 通过原始值初始化枚举 (返回可选类型)
let possiblePlanet = Planet(rawValue: 7) // 尝试通过原始值 7 创建 Planet 实例
if let somePlanet = possiblePlanet {
print(“第 7 颗行星是 (somePlanet)”) // 输出: 第 7 颗行星是 uranus
} else {
print(“没有对应的行星”)
}

// 带关联值的枚举 (Associated Values)
enum Barcode {
case upc(Int, Int, Int, Int) // UPC 条形码，关联四个 Int 值
case qrCode(String) // QR 码，关联一个 String 值
}

var productBarcode = Barcode.upc(8, 85909, 51226, 3) // 创建一个 UPC 条形码实例
productBarcode = .qrCode(“ABCDEFGHIJKLMNOPQRSTUVWXYZ”) // 修改为 QR 码实例

// 使用 switch 和关联值
switch productBarcode {
case .upc(let numberSystem, let manufacturer, let product, let check): // 解包关联值
print(“UPC: (numberSystem), (manufacturer), (product), (check).”)
case .qrCode(let productCode):
print(“QR code: (productCode).”)
}
// 或者更简洁的解包方式
switch productBarcode {
case let .upc(numberSystem, manufacturer, product, check):
print(“UPC: (numberSystem), (manufacturer), (product), (check).”)
case let .qrCode(productCode):
print(“QR code: (productCode).”)
}
“`

第八步：下一步去哪里？

恭喜你！你已经掌握了 Swift 的基础知识，包括变量、常量、数据类型、控制流程、集合类型、函数、结构体、类和枚举。但这仅仅是开始。Swift 还有很多更高级的概念，例如：

• 协议 (Protocols)
• 扩展 (Extensions)
• 泛型 (Generics)
• 错误处理 (Error Handling)
• 内存管理 (ARC – Automatic Reference Counting)
• 并发编程 (Concurrency)

继续学习的建议：

1. 官方文档： 阅读 The Swift Programming Language（英文）是最好的学习资源。它详细而权威。
2. 动手实践： 尝试在 Playground 中编写更多代码，解决小问题。
3. 构建小项目： 一旦掌握基础，尝试创建一个简单的 iOS 应用或 macOS 命令行工具，将学到的知识应用到实际项目中。
4. 在线课程和教程： 网上有很多优质的 Swift 和 iOS 开发课程，可以选择适合你的风格和进度的。
5. 参与社区： 加入 Swift 开发者社区，参与讨论，提问，学习其他人的经验。
6. 学习 Apple 框架： 如果目标是开发 Apple 平台应用，你需要深入学习 Foundation、UIKit (iOS) 或 AppKit (macOS)、SwiftUI 等框架。

结论

Swift 是一门充满活力且功能强大的语言。掌握它不仅能让你进入苹果应用开发的广阔世界，也能为你打开通向其他编程领域的大门。学习编程是一个持续的过程，关键在于不断练习和探索。希望本教程为你提供了一个坚实的基础，祝你在 Swift 的学习旅程中一切顺利！

现在就开始你的 Swift 编程之旅吧！打开 Xcode Playground，写下你的第一行 Swift 代码！

---