Swift的类型系统 - 《Swift编程指南》 - 严富坤的知识库专栏(yanfukun.com)

1. 基本数据类型
2. 可选类型
- 声明和解包可选类型
- 可选链
3. 集合类型
4. 字符串和字符
- 字符串操作
- 字符操作
5. 枚举
6. 结构体和类
7. 协议和扩展
- 协议
- 扩展
8. 泛型
- 泛型函数
- 泛型类型
9. 类型转换
- 简单类型转换
- Any和AnyObject
10. 类型安全和类型推断
- 类型安全
- 类型推断
11. 高级类型特性
结论

Swift是一门由苹果公司开发的现代编程语言，其类型系统是Swift设计中最重要的组成部分之一。Swift的类型系统既灵活又强大，旨在帮助开发者编写安全、可靠、高性能的代码。本文将详细探讨Swift的类型系统，从基本类型到高级类型，涵盖各种数据类型及其用法，帮助开发者深入理解Swift类型系统的精髓。

1. 基本数据类型

Swift的基本数据类型包括整数、浮点数、布尔值和字符串等。这些类型在日常开发中非常常见。

整数

Swift提供了多种整数类型，包括Int、UInt及其具体位数版本（如Int8、UInt32等）。

let age: Int = 25
let maxUInt: UInt = UInt.max
let minInt8: Int8 = Int8.min

浮点数

浮点数用于表示带有小数的数值。Swift提供了Double和Float两种类型。

let pi: Double = 3.14159
let gravity: Float = 9.8

布尔值

布尔类型Bool只有两个可能的值：true和false。

let isSwiftFun: Bool = true
let isJavaFun: Bool = false

字符串

字符串用于表示一系列字符，String类型在Swift中是值类型。

let greeting: String = "Hello, Swift!"

2. 可选类型

可选类型用于表示可能有值也可能没有值的情况。可选类型是Swift类型系统中一个重要的特性，可以帮助避免空指针异常。

声明和解包可选类型

可选类型使用?声明，可以通过if let、guard let或强制解包来获取可选类型的值。

var optionalName: String? = "John Appleseed"
optionalName = nil
if let name = optionalName {
    print("Name is \(name)")
} else {
    print("No name provided")
}
let forcedUnwrapName: String = optionalName!

可选链

可选链用于在调用属性、方法或子脚本时进行安全操作。

let optionalAddress: String? = "123 Main Street"
let optionalUppercaseAddress = optionalAddress?.uppercased()
print(optionalUppercaseAddress ?? "No address provided")

3. 集合类型

Swift提供了多种集合类型，包括数组、集合和字典。

数组

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

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)

4. 字符串和字符

字符串操作

字符串在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)

5. 枚举

定义枚举

枚举用于定义一组相关的值，可以附加关联值和方法。

enum CompassDirection {
    case north
    case south
    case east
    case west
    func description() -> String {
        switch self {
        case .north:
            return "North"
        case .south:
            return "South"
        case .east:
            return "East"
        case .west:
            return "West"
        }
    }
}
let direction = CompassDirection.north
print(direction.description())

关联值

枚举可以关联其他类型的值，用于存储附加信息。

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!)

6. 结构体和类

定义结构体

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

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()

值类型和引用类型

值类型在赋值或传递时会进行复制，而引用类型在赋值或传递时会传递引用。

var personA = Person(name: "Alice", age: 30)
var personB = personA
personB.age = 35
print(personA.age) // 30
print(personB.age) // 35
let animalA = Animal(name: "Cat")
let animalB = animalA
animalB.name = "Kitty"
print(animalA.name) // Kitty
print(animalB.name) // Kitty

7. 协议和扩展

协议

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

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

8. 泛型

泛型函数

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

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

9. 类型转换

简单类型转换

Swift支持使用as、as?和as!进行类型转换。

let doubleValue: Double = 3.14
let intValue = Int(doubleValue) // 3
let optionalInt: Int? = 42
let number = optionalInt as? Double
print(number ?? 0.0) // 0.0
let anyValue: Any = "Hello"
if let stringValue = anyValue as? String {
    print(stringValue) // Hello
}

Any和AnyObject

Any表示任何类型，包括函数类型；AnyObject表示任何类类型的实例。

var anyArray: [Any] = [1, "Hello", 3.14]
for item in anyArray {
    if let number = item as? Int {
        print("Integer: \(number)")
    } else if let string = item as? String {
        print("String: \(string)")
    } else if let double = item as? Double {
        print("Double: \(double)")
    }
}
class Animal {}
class Dog: Animal {}
let animals: [AnyObject] = [Animal(), Dog()]
for animal in animals {
    if let dog = animal as? Dog {
        print("Found a dog")
    } else {
        print("Found an animal")
    }
}

10. 类型安全和类型推断

类型安全

Swift是类型安全的语言，这意味着编译器会在编译时检查类型，以确保类型的一致性，防止类型错误。

var age: Int = 25
age = "Twenty-five" // 编译错误：不能将String赋值给Int类型

类型推断

Swift编译器可以根据上下文推断出变量或常量的类型。

let meaningOfLife = 42 // 推断为Int类型
let pi = 3.14159 // 推断为Double类型
let swiftIsFun = true // 推断为Bool类型

11. 高级类型特性

类型别名

类型别名为现有类型定义一个新的名字，增加代码可读性。

typealias AudioSample = UInt16
var maxAmplitude = AudioSample.max

嵌套类型

Swift允许在类型内部定义嵌套类型。

struct BlackjackCard {
    enum Suit: Character {
        case spades = "♠", hearts = "♥", diamonds = "♦", clubs = "♣"
    }
    enum Rank: Int {
        case two = 2, three, four, five, six, seven, eight, nine, ten
        case jack, queen, king, ace
        struct Values {
            let first: Int, second: Int?
        }
        var values: Values {
            switch self {
            case .ace:
                return Values(first: 1, second: 11)
            case .jack, .queen, .king:
                return Values(first: 10, second: nil)
            default:
                return Values(first: self.rawValue, second: nil)
            }
        }
    }
    let rank: Rank, suit: Suit
}
let card = BlackjackCard(rank: .ace, suit: .spades)
print("Card suit is \(card.suit.rawValue), value is \(card.rank.values.first) or \(card.rank.values.second!)")

元组

元组是一种将多个值组合成一个复合值的类型，适用于临时组合值。

let http404Error = (404, "Not Found")
let (statusCode, statusMessage) = http404Error
print("Status code is \(statusCode), message is \(statusMessage)")

递归枚举

递归枚举是一种枚举类型，其一个或多个枚举案例的关联值是该枚举类型的另一实例。

enum ArithmeticExpression {
    case number(Int)
    indirect case addition(ArithmeticExpression, ArithmeticExpression)
    indirect case multiplication(ArithmeticExpression, ArithmeticExpression)
}
func evaluate(_ expression: ArithmeticExpression) -> Int {
    switch expression {
    case .number(let value):
        return value
    case .addition(let left, let right):
        return evaluate(left) + evaluate(right)
    case .multiplication(let left, let right):
        return evaluate(left) * evaluate(right)
    }
}
let five = ArithmeticExpression.number(5)
let four = ArithmeticExpression.number(4)
let sum = ArithmeticExpression.addition(five, four)
let product = ArithmeticExpression.multiplication(sum, ArithmeticExpression.number(2))
print(evaluate(product)) // 18

结论

Swift的类型系统设计注重安全性、灵活性和性能，为开发者提供了强大的工具。通过类型推断、类型别名、可选类型、泛型等特性，Swift能够帮助开发者编写简洁、可靠的代码。在本文中，我们深入探讨了Swift的各种类型及其用法，希望能帮助开发者更好地理解和利用Swift的类型系统，提升开发效率和代码质量。