基础语法 - 《Swift编程指南》 - 严富坤的知识库专栏(yanfukun.com)

1. 变量和常量
- 声明变量和常量
- 类型注解
2. 数据类型
3. 操作符
4. 控制流
5. 函数
6. 闭包
- 闭包表达式
- 尾随闭包
7. 集合类型
8. 字符串和字符
- 字符串操作
- 字符操作
9. 枚举
10. 结构体和类
- 定义结构体
- 定义类
11. 属性和方法
#
- 计算属性
- 方法
12. 继承
13. 初始化
14. 错误处理
15. 协议和扩展
- 协议
- 扩展
16. 泛型
- 泛型函数
- 泛型类型
结论

Swift是苹果公司推出的一种现代编程语言，它具有简洁、强大、安全的特点，被广泛应用于iOS、macOS、watchOS和tvOS的开发中。本文将详细介绍Swift的基础语法，帮助初学者快速上手。

1. 变量和常量

声明变量和常量

在Swift中，变量用var关键字声明，常量用let关键字声明。

var variableName = 10
let constantName = 20

类型注解

虽然Swift具有强大的类型推断功能，但有时我们也需要明确指定变量或常量的类型。这时可以使用类型注解。

var variableName: Int = 10
let constantName: Double = 20.0

2. 数据类型

基本数据类型

Swift提供了多种基本数据类型，包括整数、浮点数、布尔值和字符串。

let intValue: Int = 42
let doubleValue: Double = 3.14159
let boolValue: Bool = true
let stringValue: String = "Hello, Swift"

可选类型

可选类型用于表示可能有值也可能没有值的情况。使用?来声明一个可选类型。

var optionalString: String? = "Hello"
optionalString = nil

解包可选类型

在使用可选类型时，需要将其解包以获取实际值。可以使用if let或guard let来安全地解包。

if let unwrappedString = optionalString {
    print(unwrappedString)
} else {
    print("optionalString is nil")
}

3. 操作符

算术操作符

Swift支持常见的算术操作符，如加、减、乘、除和取余。

let sum = 3 + 2
let difference = 5 - 3
let product = 4 * 2
let quotient = 8 / 2
let remainder = 9 % 2

赋值操作符

赋值操作符用于给变量或常量赋值。

var a = 10
a += 5 // 相当于 a = a + 5

比较操作符

比较操作符用于比较两个值的大小关系。

let isEqual = (a == 5)
let isNotEqual = (a != 5)
let isGreater = (a > 5)
let isLesser = (a < 5)
let isGreaterOrEqual = (a >= 5)
let isLesserOrEqual = (a <= 5)

逻辑操作符

逻辑操作符用于进行布尔值的逻辑运算。

let andResult = true && false
let orResult = true || false
let notResult = !true

4. 控制流

条件语句

Swift提供了if、else if和else条件语句来执行条件判断。

let score = 85
if score >= 90 {
    print("Excellent")
} else if score >= 80 {
    print("Good")
} else {
    print("Needs Improvement")
}

Switch语句

switch语句用于根据不同的情况执行不同的代码块。Swift的switch语句功能强大，支持模式匹配和区间匹配。

let grade = "B"
switch grade {
case "A":
    print("Excellent")
case "B":
    print("Good")
case "C":
    print("Average")
case "D":
    print("Below Average")
default:
    print("Fail")
}

循环语句

Swift支持for-in、while和repeat-while循环。

let items = ["Apple", "Banana", "Cherry"]
for item in items {
    print(item)
}
var count = 5
while count > 0 {
    print(count)
    count -= 1
}
repeat {
    print("This will run at least once")
} while count > 0

5. 函数

定义函数

函数是执行特定任务的代码块。使用func关键字来定义函数。

func greet(name: String) -> String {
    return "Hello, \(name)!"
}
let greeting = greet(name: "Swift")
print(greeting)

函数参数与返回值

函数可以有多个参数和返回值。

func add(a: Int, b: Int) -> Int {
    return a + b
}
let sum = add(a: 3, b: 5)
print(sum)

参数标签

参数标签可以在函数调用时提供更多的可读性。

func greet(person name: String) -> String {
    return "Hello, \(name)!"
}
let greeting = greet(person: "Swift")
print(greeting)

6. 闭包

闭包表达式

闭包是自包含的代码块，可以在代码中传递和使用。闭包表达式语法简洁，类似于匿名函数。

let numbers = [1, 2, 3, 4, 5]
let doubledNumbers = numbers.map { (number: Int) -> Int in
    return number * 2
}
print(doubledNumbers)

尾随闭包

如果闭包是函数的最后一个参数，可以使用尾随闭包语法。

let sortedNumbers = numbers.sorted { $0 > $1 }
print(sortedNumbers)

7. 集合类型

数组

数组是有序的集合，可以存储相同类型的元素。

var fruits: [String] = ["Apple", "Banana", "Cherry"]
fruits.append("Date")
print(fruits)

集合

集合是无序的集合，存储唯一的元素。

var uniqueFruits: Set<String> = ["Apple", "Banana", "Cherry"]
uniqueFruits.insert("Date")
print(uniqueFruits)

字典

字典是键值对的集合，可以存储唯一键与对应值的映射。

var fruitColors: [String: String] = ["Apple": "Red", "Banana": "Yellow", "Cherry": "Red"]
fruitColors["Date"] = "Brown"
print(fruitColors)

8. 字符串和字符

字符串操作

Swift中的字符串是Unicode字符的集合，支持多种操作。

let hello = "Hello"
let world = "World"
let greeting = hello + ", " + world + "!"
print(greeting)

字符操作

字符串中的字符可以通过遍历或索引访问。

for char in greeting {
    print(char)
}
let firstChar = greeting[greeting.startIndex]
print(firstChar)

9. 枚举

定义枚举

枚举用于定义一组相关的值。

enum CompassDirection {
    case north
    case south
    case east
    case west
}
let direction = CompassDirection.north

关联值

枚举可以有关联值，以便在枚举值中存储附加信息。

enum Barcode {
    case upc(Int, Int, Int, Int)
    case qrCode(String)
}
var productBarcode = Barcode.upc(8, 85909, 51226, 3)
productBarcode = .qrCode("ABCDEFGHIJK")

原始值

枚举可以有原始值，原始值类型可以是字符串、整数或浮点数。

enum Planet: Int {
    case mercury = 1, venus, earth, mars
}
let earth = Planet(rawValue: 3)
print(earth!)

10. 结构体和类

定义结构体

结构体是一种值类型，适用于定义简单的数据模型。

struct Person {
    var name: String
    var age: Int
}
var john = Person(name: "John", age: 25)
john.age = 26
print(john)

定义类

类是一种引用类型，适用于定义复杂的数据模型和行为。

class Animal {
    var name: String
    init(name: String) {
        self.name = name
    }
    func speak() {
        print("\(name) makes a sound")
    }
}
let dog = Animal(name: "Dog")
dog.speak()

11. 属性和方法

#

存储属性

类和结构体可以有存储属性，用于存储常量或变量。

struct FixedLengthRange {
    var firstValue: Int
    let length: Int
}
var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
rangeOfThreeItems.firstValue = 6

计算属性

计算属性不直接存储值，而是通过计算得出。

struct Point {
    var x = 0.0, y = 0.0
    var distanceFromOrigin: Double {
        return sqrt(x * x + y * y)
    }
}
var point = Point(x: 3.0, y: 4.0)
print(point.distanceFromOrigin) // 5.0

方法

方法是与特定类型相关联的函数。

class Counter {
    var count = 0
    func increment() {
        count += 1
    }
    func increment(by amount: Int) {
        count += amount
    }
    func reset() {
        count = 0
    }
}
let counter = Counter()
counter.increment()
counter.increment(by: 5)
counter.reset()
print(counter.count) // 0

12. 继承

基类

类可以从基类继承方法、属性和其他特性。

class Vehicle {
    var currentSpeed = 0.0
    var description: String {
        return "traveling at \(currentSpeed) miles per hour"
    }
    func makeNoise() {
        print("Generic vehicle noise")
    }
}
let someVehicle = Vehicle()
print(someVehicle.description) // traveling at 0.0 miles per hour

子类

子类可以继承基类，并重写基类的方法或属性。

class Bicycle: Vehicle {
    var hasBasket = false
}
let bicycle = Bicycle()
bicycle.hasBasket = true
bicycle.currentSpeed = 15.0
print(bicycle.description) // traveling at 15.0 miles per hour

重写

使用override关键字来重写基类的方法或属性。

class Train: Vehicle {
    override func makeNoise() {
        print("Choo Choo")
    }
}
let train = Train()
train.makeNoise() // Choo Choo

13. 初始化

初始化器

初始化器用于创建类、结构体或枚举的实例。

struct Fahrenheit {
    var temperature: Double
    init() {
        temperature = 32.0
    }
}
var f = Fahrenheit()
print(f.temperature) // 32.0

自定义初始化

可以自定义初始化器以接收参数。

struct Celsius {
    var temperatureInCelsius: Double
    init(fromFahrenheit fahrenheit: Double) {
        temperatureInCelsius = (fahrenheit - 32.0) / 1.8
    }
    init(fromKelvin kelvin: Double) {
        temperatureInCelsius = kelvin - 273.15
    }
}
let boilingPointOfWater = Celsius(fromFahrenheit: 212.0)
print(boilingPointOfWater.temperatureInCelsius) // 100.0

初始化器委托

初始化器可以调用其他初始化器来完成实例的部分初始化。

class Vehicle {
    var currentSpeed = 0.0
    init() {}
    init(speed: Double) {
        self.currentSpeed = speed
    }
}
class Car: Vehicle {
    var gear = 1
    init(speed: Double, gear: Int) {
        self.gear = gear
        super.init(speed: speed)
    }
}
let car = Car(speed: 60.0, gear: 3)
print(car.currentSpeed, car.gear) // 60.0 3

14. 错误处理

错误类型

错误类型是遵循Error协议的类型，通常使用枚举来定义。

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

抛出错误

使用throw关键字来抛出错误。

func vend(itemNamed name: String) throws {
    throw VendingMachineError.outOfStock
}

捕获错误

使用do-catch语句来捕获和处理错误。

do {
    try vend(itemNamed: "Candy Bar")
} catch VendingMachineError.invalidSelection {
    print("Invalid Selection")
} catch VendingMachineError.insufficientFunds(let coinsNeeded) {
    print("Insufficient funds. Please insert an additional \(coinsNeeded) coins.")
} catch VendingMachineError.outOfStock {
    print("Out of Stock")
}

可选错误处理

使用try?和try!来处理可选错误和强制错误。

let x = try? vend(itemNamed: "Candy Bar") // 返回nil，因为vend抛出了错误
let y = try! vend(itemNamed: "Candy Bar") // 运行时错误，因为vend抛出了错误

15. 协议和扩展

协议

协议定义了一组方法和属性，任何遵循该协议的类型都必须实现这些方法和属性。

protocol FullyNamed {
    var fullName: String { get }
}
struct Person: FullyNamed {
    var fullName: String
}
let john = Person(fullName: "John Appleseed")
print(john.fullName) // John Appleseed

扩展

扩展为现有类型添加新功能，包括计算属性和方法。

extension Int {
    var isEven: Bool {
        return self % 2 == 0
    }
    func squared() -> Int {
        return self * self
    }
}
let number = 4
print(number.isEven) // true
print(number.squared()) // 16

16. 泛型

泛型函数

泛型函数可以处理任何类型的参数。

func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
    let temporaryA = a
    a = b
    b = temporaryA
}
var firstInt = 1
var secondInt = 2
swapTwoValues(&firstInt, &secondInt)
print(firstInt, secondInt) // 2 1

泛型类型

泛型类型可以用于定义泛型类、结构体或枚举。

struct Stack<Element> {
    var items = [Element]()
    mutating func push(_ item: Element) {
        items.append(item)
    }
    mutating func pop() -> Element {
        return items.removeLast()
    }
}
var stackOfStrings = Stack<String>()
stackOfStrings.push("First")
stackOfStrings.push("Second")
print(stackOfStrings.pop()) // Second

结论

Swift是一门现代化的编程语言，结合了简洁性、安全性和高性能的特点，极大地提升了开发者的生产力。本文详细介绍了Swift的基础语法，包括变量和常量、数据类型、操作符、控制流、函数、闭包、集合类型、字符串和字符、枚举、结构体和类、属性和方法、继承、初始化、错误处理、协议和扩展以及泛型。希望这篇文章能帮助你更好地理解和使用Swift，为你的开发工作提供有力支持。