【Swift】 Swift 基础语法：变量、类型、分支与循环

一、Swift基础语法

1.1 基础语法

1. 变量与常量

• 常量（ let） ：声明后不可修改，编译期确定值（值类型/引用类型均不可变引用）。
• 变量（ var）：声明后可修改，支持动态赋值。
• 语法格式 ：let/var 名称: 类型 = 值（类型可省略，Swift 自动推断）。

// 常量：不可修改
let message = "Hello Swift" // 自动推断为 String 类型
let sum = 5 + 3 // 自动推断为 Int 类型
let isGreater = sum > 5 // 自动推断为 Bool 类型

// 变量：可修改
var str = "Hello, UIKit"
str = "Hello UIKit2" // 合法，变量支持重新赋值

// 显式指定类型（推荐在类型模糊时使用）
var userName: String // 仅声明，未赋值（可选类型外需后续赋值）
userName = "Admin" // 赋值后使用

2. 特殊语法规则

• 分号：单行多个语句需用分号分隔，单行单语句可省略。
• 特殊名称转义 ：使用反引号 ````` 包裹关键字/特殊字符作为标识符。
• 打印与输入 ：print() 打印（默认换行，terminator 指定分隔符），readLine() 读取控制台输入（返回 String?）。

// 单行多语句：分号必需
let b = 2; let c = 3

// 特殊名称转义（如关键字 class、let 作为变量名）
let `class` = 123456
let `let` = "let"
print(`let`) // 输出：let

// 打印控制
for x in 0...10 {
    print("\(x)", terminator: " ") // terminator 指定分隔符（此处为空格，不换行）
}
print() // 单独换行

// 控制台输入（返回可选类型 String?，需处理 nil）
let inputValue = readLine() // 读取一行输入，用户未输入时返回 nil
print("用户输入：\(inputValue ?? "无输入")")

1.2 数据类型

1. 基本数据类型

Swift 提供 5 类基本数据类型，均为值类型：

类型分类	具体类型	说明
整数类型	Int/Int8/Int16/Int32/Int64	Int 随系统位数（32/64 位），推荐优先使用
无符号整数类型	UInt/UInt8/UInt16/UInt32/UInt64	仅存非负数，需明确场景时使用
浮点数类型	Float（32 位）/Double（64 位）	Double 精度更高，推荐优先使用
布尔类型	Bool	仅 true/false 两个值
字符类型	Character	单个 Unicode 字符，用双引号包裹
字符串类型	String	Unicode 字符序列，支持不可变/可变

// 整数类型
let Int32_Value: Int32 = 44325435
let Int64_Value: Int64 = -8243334232343243543
let Int_Value: Int = -8243334232343243543 // 随系统位数
let Uint_Value: UInt = 1234 // 无符号，仅非负数

// 浮点数类型
let Float_Value: Float = 0.1234 // 精度较低
let Double_Value: Double = 0.001234 // 精度较高，推荐

// 字符串与字符
let String_Value: String = "112233"
let Charactor_Value: Character = "C" // 单个字符，不可多字符

// 布尔类型
let Bool_Value: Bool = true

2. 类型别名（typealias）

为已有类型起别名，增强代码可读性，访问级别不能高于原类型 。

// 为 Int 起别名 Feet，代表"英尺"
typealias Feet = Int
var aFeet: Feet = 100 // 等价于 var aFeet: Int = 100
print(aFeet) // 输出：100

// 类型别名访问级别限制：原类型为 internal，别名不能为 public
internal typealias MyInt = Int
// public typealias MyInt = Int // 错误：别名级别高于原类型

1.3 可选类型（Optional）

Swift 特有的安全类型，用于表示"值可能存在（非 nil）或不存在（nil）"，避免空指针异常。

1. 可选类型声明

• 语法：类型?（如 String?、Int?），默认值为 nil。
• 本质：Optional 枚举的语法糖，String? 等价于 Optional<String>。

// 声明可选类型（未赋值时默认 nil）
var ExistValue: String? = "Value" // 非 nil
var myString2: String? = nil // 显式 nil
var myString3: String? // 默认 nil

2. 可选值的使用方式

（1）强制解析（!）

• 仅当确定可选值非 nil 时使用，若为 nil 会触发运行时崩溃（不推荐随意使用）。

myString3 = "valid value"
if myString3 != nil {
    print(myString3!) // 输出：valid value（非 nil 时安全）
} else {
    print("myString3 is nil")
}

（2）自动解析可选类型（! 声明）

• 声明时用 类型!，表示"该值初始化后不会为 nil"，可直接使用（无需 ! 解析），但初始化后赋值 nil 仍会崩溃。

var myString4: String! = "1234556" // 自动解析可选类型
if myString4 != nil {
    print(myString4) // 输出：1234556（无需 !）
}

（3）可选绑定（if let/guard let）

• 安全解析可选值：若可选值非 nil，则赋值给临时变量并执行代码块；若为 nil，跳过代码块（推荐使用）。

var myString5: String? = "Hello String"
myString5 = nil // 改为 nil

// if let 绑定：myString5 为 nil 时执行 else
if let yourString = myString5 {
    print("yourString = \(yourString)")
} else {
    print("myString5 is nil and yourString has no value")
}

// guard let 绑定：常用于函数中，提前退出（更优雅）
func printString(_ str: String?) {
    guard let unwrappedStr = str else {
        print("str is nil")
        return // 必须退出当前作用域
    }
    print("unwrappedStr = \(unwrappedStr)")
}

（4）空合运算符（??）

• 简化"可选值为 nil 时使用默认值"的场景，语法：可选值 ?? 默认值（默认值类型需与可选值解包后类型一致）。

let nilValue2: String! = nil
print(nilValue2 ?? "nilValue2 is nil") // 输出：nilValue2 is nil

let nilValue3: String! = "valid String"
print(nilValue3 ?? "nilValue3 is nil") // 输出：valid String

1.4 控制流

1. 分支语句

（1）if-else

• 标准条件判断，支持多条件（else if），条件无需括号包裹。

var AA1 = 10, AA2 = 20
if AA1 > 0 && AA2 > 0 {
    print("AA1 + AA2 = \(AA1 + AA2)") // 输出：30
}

（2）switch

• 支持任意类型（不仅是整数），无需 break（默认不贯穿），可通过 fallthrough 实现贯穿。
• 支持多 case 合并、范围匹配、值绑定。

var index = 10
switch index {
case 10, 15: // 多 case 合并
    print("index 的值为 10 或 15")
case 100:
    print("index 的值为 100")
default:
    print("默认 case")
}

// fallthrough 实现贯穿（类似 C 语言的无 break）
var index2 = 100
switch index2 {
case 100:
    print("index 的值为 100")
    fallthrough // 继续执行下一个 case
case 10, 15:
    print("index 的值为 10 或 15")
default:
    print("默认 case")
}
// 输出：
// index 的值为 100
// index 的值为 10 或 15

2. 循环语句

（1）for-in 循环

• 遍历区间、集合、字符串等，支持闭区间（a...b，包含 b）和半开区间（a..<b，不包含 b）。

// 遍历闭区间（0 到 10，包含 10）
for x in 0...10 {
    print(x, terminator: " ")
}

// 遍历数组
let someInts: [Int] = [10, 20, 30]
for index in someInts {
    print("index 的值为 \(index)")
}

// 遍历数组索引（通过 count 构建区间）
for i in 0..<someInts.count {
    print("value = \(someInts[i])")
}

// 遍历字符串字符
let str2 = "Swift字符串"
for ch in str2 {
    print(ch, terminator: "")
}

// 带索引遍历（enumerated() 返回 (index, element)）
for (index, char) in str2.enumerated() {
    print("位置 \(index)：\(char)")
}

（2）while 循环

• 先判断条件，条件为 true 时执行循环体。

let totalNumber: Int = 4
var while_index = 0
while while_index < totalNumber {
    print("while_index = \(while_index)")
    while_index += 1
}
// 输出：0、1、2、3

（3）repeat-while 循环

• 先执行一次循环体，再判断条件（类似 C 语言的 do-while）。

let boolValue = false
repeat {
    print("At least execute once") // 必执行一次
} while boolValue
// 输出：At least execute once

3. 三目运算符

• 简化二选一判断，语法：条件 ? 表达式1 : 表达式2（条件为 true 执行表达式1，否则执行表达式2）。

let BiggerValue = 10000
let result = (BiggerValue > 100) ? "BiggerValue is bigger than 100" : "BiggerValue is less than 100"
print(result + "，Bigger Value is \(BiggerValue)")
// 输出：BiggerValue is bigger than 100，Bigger Value is 10000

1.5 集合类型

Swift 提供 3 种核心集合类型，均为值类型（赋值时深拷贝）：

1. 数组（Array）

• 有序集合，存储相同类型的元素，支持动态增删。

（1）数组初始化

// 1. 显式类型 + 字面量
var myArray: [Int] = [1, 2, 3, 4, 5]

// 2. 重复元素初始化（count 为元素个数）
var repeatArray = [Int](repeating: 666, count: 6) // [666, 666, 666, 666, 666, 666]

// 3. 空数组初始化
var emptyArray: [String] = []

（2）数组操作

// 添加元素
emptyArray.append("Hello")
emptyArray.append(" ")
emptyArray.append("World") // 结果：["Hello", " ", "World"]

// 修改元素（通过下标）
repeatArray[0] -= 600 // 666 - 600 = 66，repeatArray[0] 变为 66
repeatArray[repeatArray.count - 2] = 0 // 修改倒数第二个元素为 0

// 合并数组（+ 运算符，返回新数组）
let mergeArray = emptyArray + emptyArray // ["Hello", " ", "World", "Hello", " ", "World"]

// 访问元素（下标 + 遍历）
print(myArray[0]) // 输出：1（访问第一个元素）
for (index, item) in emptyArray.enumerated() {
    print("在 index = \(index) 位置上的值为 \(item)")
}

2. 字典（Dictionary）

• 无序集合，存储键值对（Key: Value），键唯一且需遵守 Hashable 协议（默认类型如 Int、String 均满足）。

（1）字典初始化

// 1. 显式类型 + 字面量
var myDict: [Int: String] = [1: "One", 2: "Two", 3: "Three"]

// 2. 空字典初始化
var emptyDict: [String: Int] = [:]

（2）字典操作

// 访问值（下标返回可选类型，需解包）
var dictValue = myDict[1]
print(dictValue!) // 输出：One（非 nil 时强制解包）

// 更新值（两种方式）
myDict[1] = "One Modified" // 直接赋值
myDict.updateValue("One Modified by updateValue", forKey: 1) // updateValue 返回旧值（可选类型）
print(myDict[1]!) // 输出：One Modified by updateValue

// 删除值（两种方式）
myDict.removeValue(forKey: 1) // 返回被删除的值（可选类型）
myDict[2] = nil // 设为 nil 也可删除
print(myDict[1] ?? "myDict[1] is nil") // 输出：myDict[1] is nil

// 遍历字典
for (key, value) in myDict {
    print("key = \(key) value = \(value)")
}

// 字典转数组（keys/values 属性）
let keyArray = myDict.keys // 键数组（类型：Dictionary.Keys）
let valueArray = myDict.values // 值数组（类型：Dictionary.Values）
for key in keyArray {
    print("key = \(key)")
}

3. 字符串（String）

• 存储 Unicode 字符序列，支持多种操作，本质是值类型（Swift 5 后优化了拷贝性能）。

（1）字符串初始化

// 1. 字面量初始化
let stringB: String = "stringBValue"

// 2. 空字符串初始化
var stringA = String() // 等价于 var stringA = ""

// 3. 字符串插值（\(变量/表达式)）
var stringC: String = "stringC \(stringB)" // 输出：stringC stringBValue

（2）字符串操作

// 拼接字符串（+ 运算符或 append 方法）
stringC = stringB + " " + stringB // "stringBValue stringBValue"
var vara: String = "Hello"
let varb: String = "World"
vara.append(varb) // "HelloWorld"

// 字符串长度（count 属性，注意：Unicode 字符占 1 个 count）
print("stringC length is \(stringC.count)") // 输出：23（"stringBValue stringBValue" 的长度）

// 字符串比较（==/!=，比较内容而非引用）
print("stringB == stringC: \(stringB == stringC)") // 输出：false

// 字符串判空（isEmpty 属性）
if stringA.isEmpty {
    print("stringA is empty")
}

资料分享:https://github.com/0voice