Swift入门

1. 变量和常量

2. 数据类型（字符串、整数、浮点数、布尔值等）

3. 运算符（算术、比较、逻辑）

4. 条件语句（if、switch）

5. 循环（for、while）

6. 函数

7. 数组和字典

8. 可选类型（Optional）（Swift 的特殊概念）

1. 变量 (var) 和常量 (let)

在 Swift 中，var 用于声明变量（值可以改变），let 用于声明常量（值不能改变）。

var myVariable = 10  // 变量，可以修改
myVariable = 20      // 变量值修改为 20

let myConstant = 30  // 常量，不能修改
// myConstant = 40   // 这样会报错

2. 数据类型（Strings、Integers、Doubles、Booleans）

Swift 是强类型语言，每个变量都有固定的数据类型，例如整数、字符串、浮点数等。

常见数据类型：

• Int（整数）

• Double（双精度浮点数）

• Float（单精度浮点数）

• Bool（布尔值）

• String（字符串）

示例代码：

var age: Int = 25        // 整数类型
var height: Double = 1.75 // 双精度浮点数
var isSwiftFun: Bool = true // 布尔值
var name: String = "Alice" // 字符串

Swift 也支持类型推断，可以省略类型声明，Swift 会自动判断：

var age = 25          // Swift 自动推断为 Int
var pi = 3.1415       // 自动推断为 Double
var isSunny = false   // 自动推断为 Bool
var greeting = "Hello, Swift!"  // 自动推断为 String

3. 运算符（Operators）

Swift 提供了多种运算符，包括算术运算符、比较运算符和逻辑运算符。

1️⃣ 算术运算符（Arithmetic Operators）

用于数学计算，如加、减、乘、除、取余。

let a = 10
let b = 3

print(a + b)  // 加法，输出 13
print(a - b)  // 减法，输出 7
print(a * b)  // 乘法，输出 30
print(a / b)  // 整数除法，输出 3（注意：整数相除仍是整数）
print(a % b)  // 取余，输出 1

👉 注意：如果要得到小数结果，需要使用 Double 类型：

let x = 10.0
let y = 3.0
print(x / y)  // 输出 3.3333333333333335

2️⃣  赋值运算符（Assignment Operators）

用 = 赋值，并可以结合其他运算符：

var number = 5
number += 3  // 相当于 number = number + 3，结果是 8
number -= 2  // 结果是 6
number *= 4  // 结果是 24
number /= 6  // 结果是 4
number %= 3  // 结果是 1

3️⃣  比较运算符（Comparison Operators）

用于比较两个值，返回 true 或 false。

print(10 > 5)  // true
print(10 < 5)  // false
print(10 >= 10) // true
print(10 <= 5)  // false
print(10 == 10) // true（等于）
print(10 != 5)  // true（不等于）

4️⃣  逻辑运算符（Logical Operators）

用于逻辑判断，常用于 if 语句。

let isAdult = true
let hasID = false

print(isAdult && hasID) // false（必须都为 true 才返回 true）
print(isAdult || hasID) // true（只要有一个为 true 就返回 true）
print(!isAdult)         // false（取反）

✅ 练习

试着预测下面的代码输出，然后在 Xcode Playground 里运行看看答案是否正确！

let x = 8
let y = 3

print(x + y * 2)  
print((x + y) * 2)  
print(x > y && y < 10)  
print(!(x == y))  

4. 条件语句（if 和 switch）

在 Swift 中，条件语句用于执行不同的代码分支，主要有 if 语句和 switch 语句。

1️⃣ if 语句

if 语句用于执行特定条件下的代码。

let age = 18

if age >= 18 {
    print("你已经成年了！")
} else {
    print("你还未成年。")
}

👉 你还可以使用 else if 来添加多个条件：

let score = 85

if score >= 90 {
    print("优秀！")
} else if score >= 75 {
    print("良好！")
} else {
    print("需要努力！")
}

2️⃣ switch 语句

switch 语句适用于多个可能的情况，通常比多个 if-else 更清晰。

let grade = "B"

switch grade {
case "A":
    print("优秀！")
case "B":
    print("良好！")
case "C":
    print("及格！")
default:
    print("不及格！")
}

👉 switch 还可以匹配数值范围：

let number = 7

switch number {
case 1...5:
    print("数字在 1 到 5 之间")
case 6...10:
    print("数字在 6 到 10 之间")
default:
    print("数字超出范围")
}

✅ 练习

试着预测下面代码的输出，然后在 Xcode Playground 里运行看看你的答案是否正确！

let temperature = 30

if temperature > 35 {
    print("太热了！")
} else if temperature >= 25 {
    print("天气刚刚好！")
} else {
    print("有点冷！")
}

let fruit = "香蕉"

switch fruit {
case "苹果", "橙子":
    print("这是一种常见水果")
case "香蕉":
    print("这是我的最爱！")
default:
    print("我不认识这种水果")
}

5. 循环（for 和 while）

循环用于重复执行某段代码，Swift 主要有两种循环方式：for 循环和 while 循环。

1️⃣ for 循环

用于遍历数组、范围（range）等集合数据。

遍历范围

for i in 1...5 {
    print("第 \(i) 次循环")
}

📌 1...5 代表从 1 到 5（包含 5）。

使用 _ 忽略变量

for _ in 1...3 {
    print("Hello, Swift!")
}

📌 如果不需要 i，可以用 _ 代替。

遍历数组

let fruits = ["苹果", "香蕉", "橙子"]

for fruit in fruits {
    print("我喜欢吃 \(fruit)")
}

2️⃣ while 循环

while 适用于不知道循环次数的情况，只要条件满足就一直执行。

var count = 3

while count > 0 {
    print("倒计时：\(count)")
    count -= 1
}

print("时间到！")

3️⃣ repeat-while（类似 do-while）

至少执行一次，然后检查条件是否继续。

var number = 0

repeat {
    print("当前值是 \(number)")
    number += 1
} while number < 3

📌 repeat-while 至少执行一次，即使 number 初始值不满足 while 条件。

✅ 练习

试着预测下面代码的输出，然后在 Xcode Playground 里运行看看你的答案是否正确！

for i in 1..<4 {  // `<` 代表不包含 4
    print("第 \(i) 次循环")
}

var x = 5
while x > 0 {
    print("x 现在是 \(x)")
    x -= 2
}

6. 函数（Functions）

函数用于封装代码，提高代码复用性，使程序更加模块化。

1️⃣ 定义和调用函数

使用 func 关键字定义一个函数。

func sayHello() {
    print("Hello, Swift!")
}

sayHello()  // 调用函数，输出 "Hello, Swift!"

2️⃣ 带参数的函数

函数可以接受参数来进行计算或操作。

func greet(name: String) {
    print("你好, \(name)!")
}

greet(name: "Alice")  // 输出：你好, Alice!

多个参数：

func add(a: Int, b: Int) {
    print("结果是 \(a + b)")
}

add(a: 3, b: 5)  // 输出：结果是 8

3️⃣ 返回值的函数

如果函数需要返回计算结果，使用 -> 指定返回类型。

func square(number: Int) -> Int {
    return number * number
}

let result = square(number: 4)
print(result)  // 输出：16

4️⃣ 省略参数标签

默认情况下，调用函数时需要写参数名，但可以用 _ 省略它。

func multiply(_ a: Int, _ b: Int) -> Int {
    return a * b
}

print(multiply(4, 5))  // 直接传参，输出 20

5️⃣ 默认参数

可以为参数提供默认值。

func greet(name: String = "朋友") {
    print("你好, \(name)!")
}

greet()         // 输出：你好, 朋友！
greet(name: "Jack")  // 输出：你好, Jack！

✅ 练习

试着运行以下代码，看看输出结果是否符合你的预期：

func isEven(_ number: Int) -> Bool {
    return number % 2 == 0
}

print(isEven(4))  // true
print(isEven(7))  // false

7. 数组（Array）和字典（Dictionary）

Swift 提供了数组（Array）和字典（Dictionary）来存储多个值。

1️⃣ 数组（Array）

数组用于存储同类型的多个值。

定义数组

var fruits: [String] = ["苹果", "香蕉", "橙子"]

📌 也可以让 Swift 自动推断类型：

var numbers = [1, 2, 3, 4, 5]  // 自动推断为 [Int]

访问数组元素

print(fruits[0])  // 输出 "苹果"
print(fruits[1])  // 输出 "香蕉"

修改数组

fruits.append("葡萄")  // 添加元素
fruits[1] = "草莓"    // 修改元素
fruits.remove(at: 0)  // 删除索引 0 位置的元素
print(fruits)

2️⃣ 字典（Dictionary）

字典用于存储键值对（key-value）。

定义字典

var person: [String: String] = [
    "name": "Alice",
    "city": "Beijing"
]

📌 也可以省略类型：

var scores = ["Alice": 90, "Bob": 85]  // 自动推断为 [String: Int]

访问字典元素

print(person["name"])  // 输出 "Alice"
print(scores["Bob"])   // 输出 85

📌 由于字典中的键可能不存在，返回的是 Optional 值，可以用 ?? 提供默认值：

print(person["age"] ?? "未知")  // 输出 "未知"

修改字典

person["city"] = "Shanghai"  // 修改值
person["age"] = "25"         // 添加新键值对
person.removeValue(forKey: "age")  // 删除键
print(person)

✅ 练习

试着运行以下代码，看看是否符合你的预期！

var shoppingList = ["牛奶", "鸡蛋", "面包"]
shoppingList.append("苹果")
shoppingList.remove(at: 1)
print(shoppingList)

var studentScores = ["Alice": 95, "Bob": 88]
studentScores["Charlie"] = 76
print(studentScores)

8. 可选类型（Optionals）——Swift 的特殊概念

在 Swift 中，并不是所有变量都会有值。有时候，一个变量可能是空的（nil），这时候就需要使用 可选类型（Optional）。

1️⃣ 什么是 Optional？

Swift 的 Optional 允许变量存储 “有值” 或 “没有值（nil）”。

var name: String? = "Alice"  // 可能有值，也可能是 nil
print(name)  // 输出 Optional("Alice")

name = nil  // 变量变为空
print(name)  // 输出 nil

📌 注意： nil 代表“没有值”，只有 Optional 变量才能赋值为 nil。

2️⃣ 解包（Unwrapping）Optional

由于 Optional 可能为 nil，所以在使用它之前，需要解包（取出值）。

方式 1：可选绑定（Optional Binding）（推荐✅）

var name: String? = "Alice"

if let unwrappedName = name {
    print("名字是 \(unwrappedName)")
} else {
    print("名字为空")
}

📌 if let 检查 name 是否有值，如果有，就解包并赋值给 unwrappedName。

方式 2：强制解包（Forced Unwrapping）（不推荐❌）

var name: String? = "Alice"
print(name!)  // 强制解包，输出 "Alice"

⚠️ 危险！ 如果 name 是 nil，强制解包会导致程序崩溃！

方式 3：Nil 合并运算符（??）（推荐✅）

如果 Optional 为 nil，可以提供默认值：

var nickname: String? = nil
print(nickname ?? "默认昵称")  // 输出 "默认昵称"

3️⃣ 可选类型的实际应用

Optional 让代码更安全

func getLength(of string: String?) -> Int {
    return string?.count ?? 0  // ?. 安全访问，?? 处理 nil
}

print(getLength(of: "Hello"))  // 输出 5
print(getLength(of: nil))      // 输出 0

✅ 练习

预测下面代码的输出，然后运行看看结果：

var age: Int? = 20
print(age ?? 18)  

age = nil
print(age ?? 18)