1. Swift语言基础

Swift 语言基础详解与代码实践

1. 变量与常量

在 Swift 中，我们使用 var 关键字声明变量，使用 let 关键字声明常量。变量的值可以改变，而常量的值一旦赋值就不能再改变。

// 声明一个变量
var myAge = 30
myAge = 31 // 可以修改变量的值
// 声明一个常量
let pi = 3.14159
// pi = 3.14 // 错误：不能修改常量的值
​

类型推断: Swift 具有强大的类型推断能力，可以根据初始值自动推断变量或常量的类型。

let name = "John Doe" // 类型推断为 String
var score = 100 // 类型推断为 Int
let price = 99.99 // 类型推断为 Double
​

当然，你也可以显式地指定类型：

let age: Int = 30
var message: String = "Hello, Swift!"
​

2. 数据类型

Swift 支持多种基本数据类型：

• Int: 整数 (例如: 10, -5, 0)

• Double: 双精度浮点数 (例如: 3.14159, -2.5)

• Float: 单精度浮点数 (例如: 3.14, -1.2)

• Bool: 布尔值 (true 或 false)

• String: 字符串 (例如: "Hello", "Swift")

• Character: 字符 (例如: "a", "1")

类型安全: Swift 是一种类型安全的语言。这意味着 Swift 会在编译时检查类型错误，确保你的代码在运行时不会出现类型相关的崩溃。

let number: Int = 10
let text: String = "Hello"
// 编译错误：不能将 String 类型的值赋值给 Int 类型的变量
// number = text
​

3. 运算符

Swift 支持常见的运算符，包括：

• 算术运算符: + (加), - (减), * (乘), / (除), % (取余)

• 赋值运算符: = (赋值), += (加等于), -= (减等于), *=, /=, %=

• 比较运算符: == (等于), != (不等于), > (大于), < (小于), >= (大于等于), <= (小于等于)

• 逻辑运算符: && (逻辑与), || (逻辑或), ! (逻辑非)

let a = 10
let b = 5
let sum = a + b // 15
let difference = a - b // 5
let product = a * b // 50
let quotient = a / b // 2
let remainder = a % b // 0
let isEqual = a == b // false
let isGreater = a > b // true
let andResult = true && false // false
let orResult = true || false // true
let notResult = !true // false
​

4. 字符串

Swift 中的字符串是 Unicode 兼容的，并且提供了强大的字符串操作功能。

let greeting = "Hello"
let name = "World"
// 字符串拼接
let message = greeting + ", " + name + "!" // Hello, World!
// 字符串插值
let age = 30
let ageMessage = "My age is \(age)." // My age is 30.
// 字符串长度
let length = message.count // 13
// 字符串截取 (需要转换为 String.Index)
let startIndex = message.startIndex
let endIndex = message.index(startIndex, offsetBy: 5)
let subString = message[startIndex..<endIndex] // Hello
​

5. 控制流

Swift 提供了 if-else 语句、switch 语句和循环语句来控制程序的流程。

if-else 语句:

let temperature = 25
if temperature > 30 {
    print("It's hot!")
} else if temperature > 20 {
    print("It's warm.")
} else {
    print("It's cold.")
}
​

switch 语句:

let fruit = "apple"
switch fruit {
case "apple":
    print("It's an apple.")
case "banana":
    print("It's a banana.")
default:
    print("It's another fruit.")
}
​

for 循环:

// 循环遍历数组
let numbers = [1, 2, 3, 4, 5]
for number in numbers {
    print(number)
}
// 循环遍历范围
for i in 1...5 { // 包含 5
    print(i)
}
for i in 1..<5 { // 不包含 5
    print(i)
}
​

while 循环:

var count = 0
while count < 5 {
    print(count)
    count += 1
}
​

6. 数组

数组是用来存储相同类型数据的有序集合。

// 创建一个空数组
var numbers: [Int] = []
// 创建一个带有初始值的数组
let names = ["Alice", "Bob", "Charlie"]
// 添加元素
numbers.append(1)
numbers.append(2)
numbers.append(3)
// 访问元素
let firstNumber = numbers[0] // 1
// 修改元素
numbers[1] = 4
// 数组长度
let count = numbers.count // 3
// 遍历数组
for number in numbers {
    print(number)
}
​

7. 字典

字典是用来存储键值对的无序集合，键必须是唯一的。

// 创建一个空字典
var ages: [String: Int] = [:]
// 创建一个带有初始值的字典
let scores = ["Alice": 90, "Bob": 80, "Charlie": 70]
// 添加元素
ages["John"] = 30
ages["Jane"] = 25
// 访问元素
let aliceScore = scores["Alice"] // 90 (Optional Int)
// 修改元素
ages["John"] = 31
// 删除元素
ages.removeValue(forKey: "Jane")
// 字典长度
let count = ages.count // 1
// 遍历字典
for (name, age) in ages {
    print("\(name) is \(age) years old.")
}
​

8. 函数

函数是用来执行特定任务的代码块。

// 定义一个函数
func greet(name: String) -> String {
    let message = "Hello, \(name)!"
    return message
}
// 调用函数
let greeting = greet(name: "Swift") // Hello, Swift!
print(greeting)
// 函数可以没有参数
func sayHello() -> String {
    return "Hello!"
}
// 函数可以没有返回值 (返回 Void)
func printMessage(message: String) {
    print(message)
}
printMessage(message: "This is a message.")
​

9. 可选类型 (Optionals)

可选类型用于处理值可能缺失的情况。一个可选类型的值可以是某个类型的值，也可以是 nil (表示没有值)。

var age: Int? = nil // age 是一个可选的 Int 类型
// 赋值
age = 30
// 解包可选类型 (强制解包，如果 age 为 nil，则会崩溃)
// let unwrappedAge = age!
// 安全解包 (使用 if let 或 guard let)
if let unwrappedAge = age {
    print("The age is \(unwrappedAge).")
} else {
    print("The age is nil.")
}
// guard let 语句 (更适用于提前退出函数)
func printAge(age: Int?) {
    guard let unwrappedAge = age else {
        print("The age is nil.")
        return
    }
    print("The age is \(unwrappedAge).")
}
printAge(age: age)
​

10. 类与结构体

类和结构体是 Swift 中用来创建自定义数据类型的两种方式。它们都可以包含属性 (存储数据) 和方法 (执行操作)。

类 (Class):

• 是引用类型，这意味着多个变量可以引用同一个对象。

• 支持继承。

• 有析构函数 (deinitializer) 来释放资源。

class Dog {
    var name: String
    var breed: String
    init(name: String, breed: String) {
        self.name = name
        self.breed = breed
    }
    func bark() {
        print("Woof!")
    }
}
let myDog = Dog(name: "Buddy", breed: "Golden Retriever")
print(myDog.name) // Buddy
myDog.bark() // Woof!
​

结构体 (Struct):

• 是值类型，这意味着当结构体被赋值给另一个变量时，会创建一个新的副本。

• 不支持继承。

• 没有析构函数。

struct Point {
    var x: Int
    var y: Int
}
var myPoint = Point(x: 10, y: 20)
var anotherPoint = myPoint // 创建一个副本
anotherPoint.x = 30
print(myPoint.x) // 10
print(anotherPoint.x) // 30
​

何时使用类和结构体？

• 类: 当你需要使用继承、引用语义或需要控制对象的生命周期时，使用类。

• 结构体: 当你需要使用值语义、简单的数据结构或不需要继承时，使用结构体。 通常情况下，结构体更轻量级，性能更高。

总结

本文介绍了 Swift 语言的基础知识，包括变量与常量、数据类型、运算符、字符串、控制流、数组、字典、函数、可选类型以及类与结构体。通过阅读本文并实践代码示例，你将能够掌握 Swift 语言的基础知识，并为进一步学习 Swift 开发打下坚实的基础。 记住，实践是学习编程的最佳方式，所以请多多尝试编写代码，并不断探索 Swift 语言的更多特性。