Swift 入门指南：全面认识这门现代编程语言

编程世界不断发展，新的语言层出不穷，每一门都力求解决前代语言的痛点，提升开发效率与软件质量。在众多现代语言中，Swift 无疑是备受瞩目的一颗新星。自2014年由苹果公司推出以来，Swift 凭借其安全性、速度、表现力以及易用性，迅速成为构建苹果生态系统（iOS、macOS、watchOS、tvOS）应用的首选语言。如今，随着其开源和跨平台能力的发展，Swift 的应用场景已远超苹果平台，延伸至服务器端和嵌入式开发。

本篇文章将带你全面认识 Swift，从它的起源、核心设计理念，到最基本的语法元素和高级特性，为你打开 Swift 编程世界的大门。

第一章：Swift 的诞生与设计哲学

在 Swift 出现之前，苹果平台的主要开发语言是 Objective-C。Objective-C 是一门功能强大且成熟的语言，但在现代软件开发中，其语法略显冗余，且缺乏一些现代语言的特性，尤其是在安全性和性能方面存在一些可以改进的空间。

Swift 的出现，正是为了解决这些问题。苹果公司从零开始设计了 Swift，汲取了现代编程语言的最佳实践，同时又保留了与 Objective-C 的良好互操作性。Swift 的设计哲学可以用几个关键词概括：

安全 (Safe)： Swift 旨在消除常见的编程错误，如空指针引用（Null Pointer Dereferencing）。通过引入可选类型（Optionals）和严格的类型检查，Swift 强制开发者在编译时处理潜在的空值和类型不匹配问题，大大减少运行时崩溃的可能性。错误处理（Error Handling）机制也让潜在的失败路径更加明确和可控。
快速 (Fast)： Swift 被设计为高性能语言。它使用了高性能的 LLVM 编译器技术，并对代码进行了高度优化。其数据结构和算法性能可以与 C++ 相媲美，甚至在某些场景下表现更优。
富有表现力 (Expressive)： Swift 的语法简洁、清晰，易于阅读和编写。它支持多种编程范式，包括面向对象、函数式和面向协议编程，让开发者能够用更少的代码实现复杂的功能。
现代 (Modern)： Swift 借鉴了如 Rust, Haskell, Ruby, Python 等语言的特性，包含了闭包、泛型、类型推断、模式匹配等现代高级特性。
与 Objective-C 互操作 (Interoperable)： Swift 可以无缝地调用 Objective-C 代码，反之亦然。这使得开发者可以逐步将现有 Objective-C 项目迁移到 Swift，或者在同一个项目中混合使用两种语言。
开源 (Open Source)： Swift 于2015年底开源，成立了 Swift.org 社区。这使得 Swift 不再局限于苹果平台，可以在 Linux 等其他系统上运行，极大地拓展了其应用范围。

理解了 Swift 的设计哲学，我们就能更好地理解它为什么会采用某些特定的语法和特性。

第二章：Swift 基础语法入门

让我们从最基础的 Swift 语法元素开始。

变量与常量 (Variables and Constants)

在 Swift 中，你可以使用 var 声明一个变量，使用 let 声明一个常量。常量的值在确定后不能修改，这有助于写出更安全、更易于理解的代码。Swift 倾向于优先使用 let，只有在值需要改变时才使用 var。

“`swift
let maximumNumberOfLoginAttempts = 10 // 常量
var currentLoginAttempt = 0 // 变量

// 尝试修改常量会引发编译错误
// maximumNumberOfLoginAttempts = 11 // 错误！
“`

Swift 是类型安全的语言，这意味着它在编译时会检查你的代码，确保你使用的类型是正确的。Swift 通常可以通过“类型推断”(Type Inference) 来自动确定变量或常量的类型，而无需你显式声明。

swift let meaningOfLife = 42 // 推断为 Int let pi = 3.14159 // 推断为 Double let anotherInt = 3 + 5 // 推断为 Int let greeting = "Hello, Swift!" // 推断为 String

当然，你也可以显式地指定类型，尤其是在类型推断不明确或需要指定特定类型时：

swift let explicitDouble: Double = 70 let explicitString: String = "This is a string." let explicitBool: Bool = true

基本数据类型 (Basic Data Types)

Swift 提供了丰富的基础数据类型：

整型 (Integers)： Int (默认，长度与平台字长相同)、UInt (无符号整型)、以及各种特定位宽的整型，如 Int8, UInt32, Int64 等。
浮点型 (Floating-Point Numbers)： Double (64位浮点数，精度更高，默认使用) 和 Float (32位浮点数)。
布尔型 (Booleans)： Bool，只有两个值：true 和 false。
字符串 (Strings)： String，支持 Unicode，功能强大。
字符 (Characters)： Character，表示一个 Unicode 字符。

你可以使用 print() 函数输出变量或常量的值：

swift let name = "Alice" let age = 30 print("My name is \(name) and I am \(age) years old.") // 字符串插值 // 输出: My name is Alice and I am 30 years old.

运算符 (Operators)

Swift 支持 C 语言中大多数标准运算符，并改进了一些功能：

算术运算符： +, -, *, /, %。注意，Swift 的 % 运算符也适用于浮点数。
比较运算符： ==, !=, >, <, >=, <=。
逻辑运算符： && (逻辑与), || (逻辑或), ! (逻辑非)。
区间运算符：
- a...b (闭合区间，包含 a 和 b)
- a..<b (半开区间，包含 a 但不包含 b)
空合运算符： a ?? b (如果 a 不是 nil，则解包 a；否则返回 b。用于处理可选类型)
三元条件运算符： 条件 ? 值1 : 值2

swift let sum = 10 + 5 let isAdult = age >= 18 let firstElement = [1, 2, 3].first ?? 0 // 使用空合运算符

控制流 (Control Flow)

控制流语句用于控制代码的执行顺序。

条件语句 (Conditional Statements)： if, else if, else

swift let temperature = 25 if temperature < 0 { print("It's freezing cold.") } else if temperature >= 0 && temperature < 20 { print("It's a bit chilly.") } else { print("It's warm.") }
开关语句 (Switch Statement)： Swift 的 switch 语句非常强大，支持各种模式匹配，并且不需要在每个 case 的末尾写 break (除非你想让它继续执行到下一个 case，可以使用 fallthrough)。

swift let dayOfWeek = "Monday" switch dayOfWeek { case "Monday": print("Start of the week.") case "Friday": print("Weekend is coming!") case "Sunday", "Saturday": // 多个值匹配一个 case print("It's the weekend!") default: // 必须包含一个 default case，除非所有可能的值都被覆盖 print("Just another day.") }
循环语句 (Loop Statements)： for-in, while, repeat-while

“`swift
// for-in 循环遍历序列
for i in 1…5 {
print(“Count: (i)”)
}

let fruits = [“Apple”, “Banana”, “Cherry”]
for fruit in fruits {
print(“I like (fruit).”)
}

// while 循环
var count = 0
while count < 3 {
print(“While count: (count)”)
count += 1
}

// repeat-while 循环 (至少执行一次)
var i = 0
repeat {
print(“Repeat-while i: (i)”)
i += 1
} while i < 3
“`

集合类型 (Collection Types)

Swift 提供了三种主要的集合类型来存储值：数组 (Arrays)，字典 (Dictionaries) 和集合 (Sets)。

数组 (Arrays)： 有序的同类型元素集合。

swift var shoppingList = ["Eggs", "Milk"] // 类型推断为 [String] print(shoppingList.count) // 输出: 2 shoppingList.append("Flour") // 添加元素 shoppingList[0] = "Six eggs" // 修改元素 print(shoppingList[0]) // 输出: Six eggs shoppingList.remove(at: 1) // 移除元素
字典 (Dictionaries)： 无序的键值对集合，键必须是唯一的且可哈希的。

swift var occupations = ["Malcolm": "Captain", "Kaylee": "Mechanic"] // 类型推断为 [String: String] occupations["Jayne"] = "Public Relations" // 添加或更新键值对 print(occupations["Malcolm"] ?? "Unknown") // 访问值，使用可选链和空合运算符 // 输出: Captain occupations.removeValue(forKey: "Jayne") // 移除键值对
集合 (Sets)： 无序的同类型且唯一元素的集合。当元素的顺序不重要，且需要确保元素唯一时使用。

swift var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"] // 显式指定 Set 类型 favoriteGenres.insert("Jazz") // 添加元素 print(favoriteGenres.contains("Rock")) // 检查是否存在 // 输出: true favoriteGenres.remove("Classical") // 移除元素

函数 (Functions)

函数是一段执行特定任务的独立代码块。

“`swift
// 简单函数
func greet(person: String) -> String {
let greeting = “Hello, ” + person + “!”
return greeting
}
print(greet(person: “Anna”)) // 输出: Hello, Anna!

// 无参数无返回值函数
func sayHello() {
print(“Hello!”)
}
sayHello() // 输出: Hello!

// 多参数函数，带参数标签 (argument label)
func greet(person: String, alreadyGreeted: Bool) -> String {
if alreadyGreeted {
return greet(person: person) // 调用上面定义的 greet 函数
} else {
return “Nice to meet you, (person).”
}
}
print(greet(person: “Tim”, alreadyGreeted: true)) // 输出: Hello, Tim!
print(greet(person: “Tim”, alreadyGreeted: false)) // 输出: Nice to meet you, Tim.

// 无参数标签的参数 (使用 )
func printNumber( number: Int) {
print(“The number is (number)”)
}
printNumber(100) // 调用时不需要参数标签
“`

闭包 (Closures)

闭包是自包含的函数代码块，可以在代码中传递和使用。它们捕获和存储其定义上下文中的任何常量和变量的引用。在 Swift 中，函数实际上是特殊的闭包。

闭包语法可以非常简洁：

“`swift
let names = [“Chris”, “Alex”, “Ewa”, “Barry”, “Daniella”]

// 使用标准函数作为排序方法
func backward(_ s1: String, _ s2: String) -> Bool {
return s1 > s2
}
var reversedNames = names.sorted(by: backward)
print(reversedNames) // 输出: [“Ewa”, “Daniella”, “Chris”, “Barry”, “Alex”]

// 使用闭包表达式作为排序方法
reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
return s1 > s2
})

// 根据类型推断简化
reversedNames = names.sorted(by: { s1, s2 in return s1 > s2 })

// 根据单表达式闭包隐式返回简化
reversedNames = names.sorted(by: { s1, s2 in s1 > s2 })

// 使用参数名称缩写 $0, $1 等
reversedNames = names.sorted(by: { $0 > $1 })

// 使用运算符方法 (最简洁)
reversedNames = names.sorted(by: >)

print(reversedNames) // 输出: [“Ewa”, “Daniella”, “Chris”, “Barry”, “Alex”]
“`

闭包在 Swift 中无处不在，尤其是在处理异步操作、UI 事件、集合操作（如 map, filter, reduce）时。

第三章：面向对象与面向协议编程 (OOP & POP)

Swift 支持面向对象编程（OOP），但同时也提倡面向协议编程（POP），这被认为是 Swift 的核心设计理念之一。

类与结构体 (Classes and Structs)

Swift 使用 class 和 struct 定义类和结构体。它们都可以定义属性（存储值）和方法（执行功能）。然而，它们之间有一个根本性的区别：

类 (Classes)： 是引用类型 (Reference Type)。当你创建一个类的实例并将其赋值给一个变量或常量时，实际上是将该实例的引用赋给了它。多个变量或常量可以引用同一个实例，修改其中一个会影响所有引用。
结构体 (Structs)： 是值类型 (Value Type)。当你创建一个结构体的实例并将其赋值给一个变量或常量，或者传递给函数时，实际上是创建了一个该实例的副本。修改其中一个副本不会影响其他副本。

“`swift
// 结构体 (值类型)
struct Point {
var x = 0.0
var y = 0.0
}

// 类 (引用类型)
class Rectangle {
var width = 0.0
var height = 0.0
}

var p1 = Point(x: 1.0, y: 2.0)
var p2 = p1 // 复制了 p1 的值
p2.x = 3.0
print(“p1.x: (p1.x), p2.x: (p2.x)”) // 输出: p1.x: 1.0, p2.x: 3.0 (p1 不受影响)

var r1 = Rectangle()
r1.width = 10.0
var r2 = r1 // r2 引用了同一个实例
r2.width = 20.0
print(“r1.width: (r1.width), r2.width: (r2.width)”) // 输出: r1.width: 20.0, r2.width: 20.0 (r1 受影响)
“`

在 Swift 中，结构体的使用频率非常高，因为它更安全（避免了意外的副作用）且在许多情况下性能更好（不需要额外的内存管理开销）。Swift 中的许多基本类型（如 Int, String, Array, Dictionary, Set）都是结构体。

类支持继承、引用计数（ARC）和运行时类型检查，这使其适合构建复杂的对象层级。结构体不支持继承，但支持协议。

枚举 (Enumerations)

枚举定义了一组相关的可能值。

“`swift
enum CompassPoint {
case north
case south
case east
case west
}

var directionToHead = CompassPoint.west
directionToHead = .east // 类型已知后可以简化语法

// 枚举可以关联值 (Associated Values)
enum Barcode {
case upc(Int, Int, Int, Int) // UPC 条形码通常有四个整数
case qrCode(String) // QR 码通常是一个字符串
}

var productBarcode = Barcode.upc(8, 85909, 51226, 3)
productBarcode = .qrCode(“ABCDEFGHIJKLMNOP”)

// 使用 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).”)
}
// 输出: QR code: ABCDEFGHIJKLMNOP.
“`

协议 (Protocols)

协议定义了方法、属性或其他的特定任务或功能所需的蓝图。类、结构体或枚举可以采纳 (adopt) 一个或多个协议，并提供这些要求功能的实现。

协议是 Swift 面向协议编程的核心。它可以让你编写更灵活、可复用和模块化的代码。

“`swift
// 定义一个协议
protocol Describable {
var description: String { get } // 读属性要求
func describe() // 方法要求
}

// 一个结构体采纳并实现协议
struct Circle: Describable {
var radius: Double

var description: String {
    return "A circle with radius \(radius)."
}

func describe() {
    print(description)
}

}

// 一个类采纳并实现协议
class RectangleShape: Describable {
var width: Double
var height: Double

init(width: Double, height: Double) {
    self.width = width
    self.height = height
}

var description: String {
    return "A rectangle with width \(width) and height \(height)."
}

func describe() {
    print(description)
}

}

let circle = Circle(radius: 5.0)
circle.describe() // 输出: A circle with radius 5.0.

let rectangle = RectangleShape(width: 4.0, height: 6.0)
rectangle.describe() // 输出: A rectangle with width 4.0 and height 6.0.

// 可以创建包含遵循相同协议的不同类型实例的数组
let shapes: [Describable] = [circle, rectangle]
for shape in shapes {
shape.describe() // 多态性
}
“`

面向协议编程鼓励你思考数据类型可以做什么（它们遵循哪些协议），而不是它们是什么（它们是哪个类的实例）。

第四章：Swift 的核心特性与安全机制

Swift 语言在安全性方面做了很多努力，其中最重要的两个机制是可选类型（Optionals）和错误处理（Error Handling）。

可选类型 (Optionals)

可选类型是 Swift 中处理值缺失的核心方式。一个可选类型要么包含一个值，要么包含 nil，表示没有值。这避免了在 C 和 Objective-C 中常见的空指针问题。

声明一个可选类型需要在类型后面加上问号 ?：

“`swift
let possibleNumber = “123”
let convertedNumber = Int(possibleNumber) // convertedNumber 是一个 Int? 类型 (Optional)

let nilString: String? = nil // 明确声明一个可选的 String，值为 nil

var serverResponseCode: Int? = 404 // 可以赋值为 Int 值
serverResponseCode = nil // 也可以赋值为 nil
“`

要访问可选类型中的值，需要进行“解包”(Unwrapping)。由于直接访问 nil 会导致运行时错误，Swift 强制你安全地处理可选类型。

常见的解包方式：

强制解包 (Forced Unwrapping)： 使用 ! 符号。如果可选类型包含 nil，这将导致运行时错误（crash）。应谨慎使用。

swift let assumedString: String? = "An implicitly unwrapped optional string." let implicitString: String = assumedString! // 强制解包
还有一种“隐式解包可选类型”(Implicitly Unwrapped Optionals)，用 ! 声明，它在第一次赋值后会被认为是正常的类型，但在访问前如果值为 nil 仍然会崩溃。通常只在确定可选类型总会有值时使用（如 IBOutlet）。
可选绑定 (Optional Binding)： 使用 if let 或 guard let 安全地检查可选类型是否包含值，如果包含，则将其绑定到一个临时常量或变量。

“`swift
if let actualNumber = Int(possibleNumber) {
print(“The string \”(possibleNumber)\” has an integer value of (actualNumber)”)
} else {
print(“The string \”(possibleNumber)\” could not be converted to an integer”)
}

func processNumber(input: String?) {
guard let number = Int(input) else {
// 如果 input 不能转换为 Int，则执行此处的代码，并退出函数
print(“Invalid input: (input ?? “nil”)”)
return
}
// 如果成功解包，可以在此处使用 number
print(“Processing valid number: (number)”)
}

processNumber(input: “456”) // 输出: Processing valid number: 456
processNumber(input: “hello”) // 输出: Invalid input: hello
``guard let` 通常用于提前退出条件不满足的函数。
可选链 (Optional Chaining)： 使用 ? 在访问可选类型的方法、属性或下标之前。如果可选类型为 nil，整个链式调用会优雅地失败，返回 nil，而不会引发错误。

“`swift
class Residence {
var numberOfRooms = 1
}

class Person {
var residence: Residence? // Residence 是可选的
}

let john = Person()
// let roomCount = john.residence.numberOfRooms // 错误！不能直接访问可选类型的属性

if let roomCount = john.residence?.numberOfRooms { // 使用可选链
print(“John’s residence has (roomCount) room(s).”)
} else {
print(“John does not have a residence.”) // 输出此行
}

john.residence = Residence() // 现在 John 有了 Residence
if let roomCount = john.residence?.numberOfRooms {
print(“John’s residence has (roomCount) room(s).”) // 输出: John’s residence has 1 room(s).
}
“`

错误处理 (Error Handling)

Swift 的错误处理机制使得你可以在运行时应对可能失败的操作。与 Optional 用来处理值可能缺失的情况不同，错误处理用于处理操作“出错了”的情况。

一个函数可以通过标记 throws 来表明它可能抛出错误。调用一个抛出错误的函数需要使用 try 关键字，并在一个 do-catch 语句块中处理可能的错误。

首先，需要定义遵循 Error 协议的枚举或结构体来表示不同的错误情况：

swift enum VendingMachineError: Error { case invalidSelection case insufficientFunds(coinsNeeded: Int) case outOfStock }

然后，定义一个可能抛出错误的函数：

“`swift
struct Item {
var price: Int
var count: Int
}

class VendingMachine {
var inventory = [
“Candy Bar”: Item(price: 12, count: 7),
“Chips”: Item(price: 10, count: 4),
“Pretzels”: Item(price: 7, count: 11)
]
var coinsDeposited = 0

func dispense(snack: String) {
    print("Dispensing \(snack)")
}

func buy(itemNamed name: String) throws {
    guard let item = inventory[name] else {
        throw VendingMachineError.invalidSelection
    }

    guard item.count > 0 else {
        throw VendingMachineError.outOfStock
    }

    guard item.price <= coinsDeposited else {
        throw VendingMachineError.insufficientFunds(coinsNeeded: item.price - coinsDeposited)
    }

    coinsDeposited -= item.price
    var newItem = item
    newItem.count -= 1
    inventory[name] = newItem
    dispense(snack: name)
}

}
“`

调用这个函数并处理错误：

“`swift
let machine = VendingMachine()
machine.coinsDeposited = 8

do {
try machine.buy(itemNamed: “Candy Bar”) // 抛出 insufficientFunds 错误
print(“Success! Enjoy your snack.”)
} catch VendingMachineError.invalidSelection {
print(“Invalid Selection.”)
} catch VendingMachineError.outOfStock {
print(“Out of Stock.”)
} catch VendingMachineError.insufficientFunds(let coinsNeeded) {
print(“Insufficient funds. Please insert (coinsNeeded) more coins.”) // 捕获关联值
} catch {
print(“An unknown error occurred.”) // 捕获其他所有错误
}
// 输出: Insufficient funds. Please insert 4 more coins.
“`

你也可以使用 try? 或 try!：

try?：如果函数抛出错误，则整个表达式结果为 nil；否则，结果是一个包含函数返回值的可选类型。
try!：强制禁用错误传播。如果函数抛出错误，将导致运行时错误。仅在你确定不会抛出错误时使用。

第五章：Swift 的其他重要特性

泛型 (Generics)

泛型允许你编写灵活且可重用的代码，同时保持类型安全。它让你可以定义不依赖于具体类型的函数、类、结构体和枚举。

“`swift
func swapTwoValues(_ a: inout T, _ b: inout T) {
let temporaryA = a
a = b
b = temporaryA
}

var someInt = 3
var anotherInt = 107
swapTwoValues(&someInt, &anotherInt) // T 被推断为 Int
print(“someInt is now (someInt), and anotherInt is now (anotherInt)”)
// 输出: someInt is now 107, and anotherInt is now 3

var someString = “hello”
var anotherString = “world”
swapTwoValues(&someString, &anotherString) // T 被推断为 String
print(“someString is now (someString), and anotherString is now (anotherString)”)
// 输出: someString is now world, and anotherString is now hello
“`

Swift 的集合类型（Array, Dictionary, Set）都是通过泛型实现的。

内存管理 (Memory Management) – ARC

Swift 使用自动引用计数 (Automatic Reference Counting, ARC) 来管理应用程序的内存使用。ARC 会跟踪和计算引用到类实例的属性、常量和变量的数量。只要存在对类实例的引用，ARC 就不会释放该实例占用的内存。当最后一个引用被释放时，ARC 会回收内存。

ARC 简化了内存管理，但在处理循环引用时需要注意，可能需要使用 weak 或 unowned 关键字来打破引用循环。

Playgrounds

Xcode 中的 Swift Playgrounds 是一个交互式的环境，你可以在其中编写 Swift 代码并立即看到结果。它是学习和尝试 Swift 语法、算法或框架的绝佳工具。Playgrounds 会实时编译并运行你的代码，并在侧边栏或内联显示结果。

第六章：如何开始学习 Swift

安装 Xcode： Swift 开发通常在苹果的集成开发环境 (IDE) Xcode 中进行。从 Mac App Store 免费下载并安装 Xcode。
使用 Playgrounds： 打开 Xcode，创建一个新的 Playground (File -> New -> Playground)。选择一个模板（如 Blank），然后命名并保存。在 Playground 中，你可以直接输入 Swift 代码并查看实时结果。
阅读官方文档： Swift 官方文档 (swift.org) 是最权威的学习资源。특히 “The Swift Programming Language” (TSPL) 这本书详细介绍了 Swift 的方方面面。
在线教程和课程： 有大量的在线平台提供 Swift 入门教程和课程，如 Apple Developer 官网、Udemy, Coursera, Bilibili 等。
动手实践： 学习编程最好的方式是多写代码。尝试解决小的编程问题，或者从构建一个简单的命令行工具、macOS 应用或 iOS 应用开始。

总结

Swift 是一门现代、强大且富有表现力的编程语言。它的设计着重于安全性、速度和易用性，使得构建高质量的软件更加高效。通过可选类型和错误处理，Swift 极大地降低了常见的运行时错误的风险。其强大的类型系统、值类型（Structs）的广泛使用以及面向协议编程的理念，鼓励开发者编写更健壮、灵活和可维护的代码。

虽然 Swift 最初为苹果平台而生，但其开源和跨平台的发展使其潜力无限。无论你是想进入 iOS/macOS 开发领域，还是对构建高性能的服务器应用感兴趣，学习 Swift 都是一个非常有价值的投资。

掌握 Swift 的基础语法只是第一步，更重要的是理解其设计哲学，并多加实践。随着你的学习深入，你将能够利用 Swift 的强大特性，构建出令人惊叹的应用程序。祝你在 Swift 的学习旅程中取得成功！

Swift 入门指南：全面认识这门语言 – wiki基地

Swift 入门指南：全面认识这门现代编程语言

第一章：Swift 的诞生与设计哲学

第二章：Swift 基础语法入门

变量与常量 (Variables and Constants)

基本数据类型 (Basic Data Types)

运算符 (Operators)

控制流 (Control Flow)

集合类型 (Collection Types)

函数 (Functions)

闭包 (Closures)

第三章：面向对象与面向协议编程 (OOP & POP)

类与结构体 (Classes and Structs)

枚举 (Enumerations)

协议 (Protocols)

第四章：Swift 的核心特性与安全机制

可选类型 (Optionals)

错误处理 (Error Handling)

第五章：Swift 的其他重要特性

泛型 (Generics)

内存管理 (Memory Management) – ARC

Playgrounds

第六章：如何开始学习 Swift

总结

发表评论取消回复

Swift 入门指南：全面认识这门现代编程语言

第一章：Swift 的诞生与设计哲学

第二章：Swift 基础语法入门

变量与常量 (Variables and Constants)

基本数据类型 (Basic Data Types)

运算符 (Operators)

控制流 (Control Flow)

集合类型 (Collection Types)

函数 (Functions)

闭包 (Closures)

第三章：面向对象与面向协议编程 (OOP & POP)

类与结构体 (Classes and Structs)

枚举 (Enumerations)

协议 (Protocols)

第四章：Swift 的核心特性与安全机制

可选类型 (Optionals)

错误处理 (Error Handling)

第五章：Swift 的其他重要特性

泛型 (Generics)

内存管理 (Memory Management) – ARC

Playgrounds

第六章：如何开始学习 Swift

总结

发表评论 取消回复

发表评论取消回复