Swift 备忘清单

该备忘单提供了使用 Swift 的示例，涵盖 Swift 基础知识、控制流、类型、结构/类、运算符、函数方法等。

入门

变量

  1. var score = 0 // 变量
  2. let pi = 3.14 // 常数
  4. var greeting = "Hello"
  5. var numberOfToys = 8
  6. var isMorning = true
  8. var numberOfToys: Int = 8
  9. numberOfToys += 1
  10. print(numberOfToys) // 打印 "9"

类型注释

  1. var greeting: String = "Hello"
  2. var numberOfToys: Int = 8
  3. var isMorning: Bool = true
  4. var price: Double = 8.99

算术运算符

  • + 添加
  • - 减法
  • * 乘法
  • / 分配
  • % 余数 
  1. var x = 0
  2. x = 4 + 2  // x 现在是 6
  3. x = 4 - 2  // x 现在是 2
  4. x = 4 * 2  // x 现在是 8
  5. x = 4 / 2  // x 现在是 2
  6. x = 4 % 2  // x 现在是 0

复合赋值运算符

  1. var numberOfDogs = 100
  2. numberOfDogs += 1
  3. print("有 \(numberOfDogs) 个斑点狗！")
  4. // 打印: 有 101 个斑点狗！
  • += 添加和分配总和
  • -= 减去并分配差值
  • *= 乘并赋值
  • /= 除并分配商
  • %= 除并分配余数

字符串插值

  1. var apples = 6
  2. print("I have \(apples) apples!")
  3. // 打印: I have 6 apples!

多行字符串

  1. let myLongString = """
  2. Swift?
  3. 这是我最喜欢的语言！
  4. """

代码注释

  1. // 这一行表示 Swift 中的注释。
  2. /*
  3. 这都被注释掉了。
  4. 没有一个会跑！
  5. */

组成一个元组

  1. let player = ("Maya", 5, 150)
  3. print(player) // ("Maya", 5, 150)
  4. print("\(player.0): level \(player.1), \(player.2) pts") // Maya: level 5, 150 pts

分解元组

  1. let player = (name: "Maya", level: 5)
  2. let (currentName, curLevel) = player
  3. print("\(currentName): level \(curLevel)")
  4. // 打印: Maya: level 5

特殊注释语法 (MARK)

  1. // MARK: - 查看设置

MARK 可用于在栏中显示评论

特殊注释语法 (TODO)

  1. // TODO: 更新逻辑以适应数据更改

TODO 用于显示需要完成的事情的提醒

特殊注释语法 (FIXME)

  1. // FIXME: 修复对现有条目进行更改时的故障行为

FIXME 用于显示需要修复的内容的提醒

变量

变量声明

变量用 var 声明：

  1. var greeting = "你好"
  2. var numberOfToys = 8
  3. var isMorning = true

为了清楚起见，变量声明可以包含类型注释：

  1. var greeting: String = "你好"
  2. var numberOfToys: Int = 8
  3. var isMorning: Bool = true

变量是可变的。 它们的值可以改变：

  1. var numberOfToys: Int = 8
  2. numberOfToys += 1
  3. print(numberOfToys) // 打印“9”

常数

常量用 let 声明：

  1. let greeting = "Hello"
  2. let numberOfToys = 8
  3. let isMorning = true

为清楚起见，常量声明可以包含类型注释：

  1. let greeting: String = "Hello"
  2. let numberOfToys: Int = 8
  3. let isMorning: Bool = true

常量是不可变的。它们的值不能改变：

  1. 让 numberOfToys: Int = 8
  2. numberOfToys += 1
  3. // ❌ 错误：numberOfToys 不可变

计算变量（get 和 set）

  1. import Foundation
  3. let df = DateFormatter()
  4. df.dateFormat = "d MMMM yyyy"
  6. var birth = df.date(from: "5 June 1999")!
  8. var age: Int {
  9.   Calendar.current
  10.     .dateComponents([.year],
  11.                   from: birth,
  12.                   to: Date()).year!
  13. }
  15. print(age) // 20
  16. birth = df.date(from: "5 June 2002")!
  17. print(age) // 17

在下面的示例中，distanceInFeet 有一个 getter 和一个 setter。 因为有 setter，所以 getter 需要关键字 get：

  1. var distanceInMeters: Float = 100
  3. var distanceInFeet: Float {
  4.   get {
  5.     distanceInMeters * 3.28
  6.   }
  7.   set(newDistance) {
  8.     distanceInMeters = newDistance / 3.28
  9.   }
  10. }
  12. print(distanceInMeters) // 100.0
  13. print(distanceInFeet) // 328.0
  15. distanceInFeet = 250
  16. print(distanceInMeters) // 76.21951
  17. print(distanceInFeet) // 250.0
  19. distanceInMeters = 800
  20. print(distanceInMeters) // 800.0
  21. print(distanceInFeet) // 2624.0

willSet

  1. var distance = 5 {
  2.   willSet {
  3.     print("距离将被设置")
  4.   }
  5. }
  7. distance = 10 // 打印: 距离将被设置

可以在 willSet 中访问新值：

  1. var distance = 5 {
  2.   willSet(newDistance) {
  3.     print("距离将被设置 \(newDistance)")
  4.   }
  5. }
  7. distance = 10 // 打印: 距离将被设置 10

willSet 可用于在设置变量值之前执行一些代码

didSet

  1. var distance = 5 {
  2.   didSet {
  3.     print("距离设置为 \(distance)")
  4.     print("它的旧值是： \(oldValue)")
  5.   }
  6. }
  7. distance = 10 // 打印: 距离将被设置 10
  8.               // 打印: 它的旧值是：5

willSet 和 didSet

  1. var distance = 5 {
  2.   willSet(newDistance) {
  3.     print("距离将设置为 \(newDistance)")
  4.   }
  5.   didSet {
  6.     print("距离设置为 \(distance)")
  7.     print("它的旧值是： \(oldValue)")
  8.   }
  9. }
  10. distance = 10

条件和逻辑

if 语句

  1. var halloween = true 
  2. if halloween {
  3.   print("不给糖就捣蛋！")
  4. }
  5. // 打印: 不给糖就捣蛋！ 
  6. if 5 > 3 {
  7.   print("5 大于 3")
  8. } else {
  9.   print("5 不超过 3")
  10. }
  11. // 输出: "5 大于 3"

else 语句

  1. var turbulence = false
  3. if turbulence {
  4.   print("请坐好。")
  5. } else {
  6.   print("你可以自由地四处走动。")
  7. }
  8. // 打印: 你可以自由地四处走动。

else if 语句

  1. var weather = "rainy"
  2. if weather == "sunny" {
  3.   print("拿点防晒霜")
  4. } else if weather == "rainy" {
  5.   print("拿一把雨伞")
  6. } else if weather == "snowing" {
  7.   print("穿上你的雪地靴")
  8. } else {
  9.   print("无效天气")
  10. }
  11. // 打印: 拿一把雨伞

比较运算符

  1. 5 > 1          // true 
  2. 6 < 10         // true 
  3. 2 >= 3         // false
  4. 3 <= 5         // true
  5. "A" == "a"     // false
  6. "B" != "b"     // true
  • < 小于
  • > 大于
  • <= 小于或等于
  • >= 大于或等于
  • == 等于
  • != 不等于

三元条件运算符

  1. var driverLicense = true
  3. driverLicense 
  4.     ? print("驾驶座") : print("乘客座位") 
  5. // 打印: 驾驶座

switch 语句

  1. var secondaryColor = "green"
  3. switch secondaryColor {
  4.   case "orange":
  5.     print("红色和黄色的混合")
  6.   case "purple":
  7.     print("红色和蓝色的混合") 
  8.   default: 
  9.     print("这可能不是辅助颜色") 
  10. }
  11. // 打印: 蓝色和黄色的混合

switch 语句：区间匹配

  1. let year = 1905
  2. var artPeriod: String
  4. switch year {
  5.   case 1860...1885:
  6.     artPeriod = "印象派"
  7.   case 1886...1910:
  8.     artPeriod = "后印象派"
  9.   default:  
  10.     artPeriod = "未知"
  11. }
  12. // 打印: 后印象派

switch 语句：复合案例

  1. let service = "Seamless"
  3. switch service {
  4.   case "Uber", "Lyft":
  5.     print("旅行")
  6.   case "DoorDash", "Seamless", "GrubHub":
  7.     print("餐厅送餐")
  8.   case "Instacart", "FreshDirect":
  9.     print("杂货配送")
  10.   default: 
  11.     print("未知服务")
  12. }
  13. // 打印: 餐厅外卖

switch 语句：where 子句

  1. let num = 7
  3. switch num {
  4.   case let x where x % 2 == 0:
  5.     print("\(num) 是偶数")
  6.   case let x where x % 2 == 1:
  7.     print("\(num) 奇数")
  8.   default:
  9.     print("\(num) 无效")
  10. }
  12. // 打印: 7 奇数

逻辑运算符！

  1. !true          // false
  2. !false         // true

逻辑运算符 &&

  1. true && true    // true
  2. true && false   // false 
  3. false && true   // false 
  4. false && false  // false

逻辑运算符 ||

  1. true || true    // true
  2. true || false   // true
  3. false || true   // true 
  4. false || false  // false

组合逻辑运算符

  1. !false && true || false // true

!false && true 首先计算并返回 true 然后，表达式，true || false 评估并返回最终结果 true

  1. false || true && false  // false

true && false 首先计算返回 false 然后，表达式，false || false 评估并返回最终结果 false

控制执行顺序

  1. // 没有括号：
  2. true || true && false || false
  3. // ---->  true 
  5. // 带括号：
  6. (true || true) && (false || false)
  7. // ---->  false

简单的 guard

  1. func greet(name: String?) {
  2.   guard let unwrapped = name else {
  3.     print("Hello guest!")
  4.     return
  5.   }
  6.   print("Hello \(unwrapped)!")
  7. }
  8. greet(name: "Asma") // 输出：Hello Asma!
  9. greet(name: nil)    // 输出：Hello guest!

循环

范围

  1. let zeroToThree = 0...3
  2. // zeroToThree: 0, 1, 2, 3

stride() 函数

  1. for oddNum in stride(from: 1, to: 5, by: 2) {
  2.   print(oddNum)
  3. }
  4. // 打印: 1
  5. // 打印: 3

for-in 循环

  1. for char in "hehe" {
  2.   print(char)
  3. }
  4. // 打印: h
  5. // 打印: e
  6. // 打印: h
  7. // 打印: e

continue 关键字

  1. for num in 0...5 {
  2.   if num % 2 == 0 {
  3.     continue
  4.   }
  5.   print(num)
  6. }
  7. // 打印: 1
  8. // 打印: 3
  9. // 打印: 5

continue 关键字将强制循环继续进行下一次迭代

break 关键字

  1. for char in "supercalifragilistice" {
  2.   if char == "c" {
  3.     break
  4.   }
  5.   print(char)
  6. }
  7. // 打印: s
  8. // 打印: u
  9. // 打印: p
  10. // 打印: e
  11. // 打印: r

使用下划线

  1. for _ in 1...3 {
  2.   print("Olé")
  3. }
  4. // 打印: Olé
  5. // 打印: Olé
  6. // 打印: Olé

while 循环

  1. var counter = 1
  2. var stopNum = Int.random(in: 1...10)
  4. while counter < stopNum {
  5.   print(counter)
  6.   counter += 1
  7. }
  8. // 循环打印，直到满足停止条件

while 循环接受一个条件，并在所提供的条件为 true 时持续执行其主体代码。如果条件从不为假，则循环将继续运行，程序将陷入无限循环

数组和集合

Array 数组

  1. var scores = [Int]()
  2. // 数组为空：[]

.count 属性

  1. var grocery = ["🥓", "🥞", "🍪", "🥛", "🍊"]
  2. print(grocery.count)
  3. // 打印: 5

索引

索引是指项目在有序列表中的位置，使用下标语法 array[index] 从数组中检索单个元素。

  1. var vowels = ["a", "e", "i", "o", "u"]
  3. print(vowels[0])  // 打印: a
  4. print(vowels[1])  // 打印: e
  5. print(vowels[2])  // 打印: i
  6. print(vowels[3])  // 打印: o
  7. print(vowels[4])  // 打印: u

注意：Swift 数组是零索引的，这意味着第一个元素的索引为 0。

用数组字面量初始化

  1. // 使用类型推断：
  2. var snowfall = [2.4, 3.6, 3.4, 1.8, 0.0]
  3. // 明确类型：
  4. var temp: [Int] = [33, 31, 30, 38, 44]

.append() 方法和 += 运算符

  1. var gymBadges = ["Boulder", "Cascade"]
  2. gymBadges.append("Thunder")
  3. gymBadges += ["Rainbow", "Soul"]
  4. // ["Boulder", "Cascade", "Thunder",
  5. //   "Rainbow", "Soul"]

.insert() 和 .remove() 方法

  1. var moon = ["🌖", "🌗", "🌘", "🌑"]
  2. moon.insert("🌕", at: 0)
  3. // ["🌕", "🌖", "🌗", "🌘", "🌑"]
  5. moon.remove(at: 4)
  6. // ["🌕", "🌖", "🌗", "🌘"]

遍历数组

  1. var employees = ["小王", "张三", "王五"]
  2. for person in employees {
  3.   print(person)
  4. }
  5. // 打印: 小王
  6. // 打印: 张三
  7. // 打印: 王五

集合(Set)

  1. var paintingsInMOMA: Set = [
  2.   "The Dream",
  3.   "The Starry Night",
  4.   "The False Mirror"
  5. ]

我们可以使用集合(Set)来存储相同数据类型的唯一元素

空集合(Set)

  1. var team = Set<String>()
  3. print(team)
  4. // 打印: []

填充集合

  1. var vowels: Set = ["a", "e", "i", "o","u"]

要创建一个填充有值的集合，请在赋值运算符之前使用 Set 关键字。

.insert()

  1. var cookieJar: Set = [
  2.   "Chocolate Chip",
  3.   "Oatmeal Raisin"
  4. ]
  5. // 添加一个新元素
  6. cookieJar.insert("Peanut Butter Chip")

.remove() 和 .removeAll() 方法

  1. var oddNumbers: Set = [1, 2, 3, 5]
  3. // 移除现有元素
  4. oddNumbers.remove(2)
  5. // 删除所有元素
  6. oddNumbers.removeAll()

.contains()

  1. var names: Set = ["Rosa", "Doug", "Waldo"]
  2. print(names.contains("Lola")) //打印: false
  4. if names.contains("Waldo"){
  5.   print("There's Waldo!")
  6. } else {
  7.   print("Where's Waldo?")
  8. }
  9. // 打印: There's Waldo!

迭代一个集合

  1. var recipe: Set = ["蛋", "面粉", "糖"]
  3. for ingredient in recipe {
  4.   print ("在配方中包含\(ingredient)")
  5. }

.isEmpty 属性

  1. var emptySet = Set<String>()
  2. print(emptySet.isEmpty)  // 打印: true
  4. var populatedSet: Set = [1, 2, 3]
  5. print(populatedSet.isEmpty) // 打印: false

.count 属性

  1. var band: Set = ["张三", "王五", "赵六"]
  3. print("乐队有 \(band.count) 名演奏者。")
  4. // 打印: 乐队有 4 名演奏者。

.intersection() 交叉

  1. var setA: Set = ["A", "B", "C", "D"]
  2. var setB: Set = ["C", "D", "E", "F"]
  4. var setC = setA.intersection(setB)
  5. print(setC)  // 打印: ["D", "C"]

.union() 合并去重

  1. var setA: Set = ["A", "B", "C", "D"]
  2. var setB: Set = ["C", "D", "E", "F"]
  4. var setC = setA.union(setB)
  5. print(setC) 
  6. // 打印: ["B", "A", "D", "F", "C", "E"]

.symmetricDifference() 对称差

  1. var setA: Set = ["A", "B", "C", "D"]
  2. var setB: Set = ["C", "D", "E", "F"]
  4. var setC = setA.symmetricDifference(setB)
  5. print(setC) 
  6. // 打印: ["B", "E", "F", "A"]

.subtracting() 减法

  1. var setA: Set = ["A", "B", "C", "D"]
  2. var setB: Set = ["C", "D"]
  4. var setC = setA.subtracting(setB)
  5. print(setC) 
  6. // 打印: ["B", "A"]

字典

基础字典

  1. var dictionaryName = [
  2.   "Key1": "Value1",
  3.   "Key2": "Value2",
  4.   "Key3": "Value3"
  5. ]

成对数据或键值对的无序集合

Keys

  1. var fruitStand = [
  2.   "Coconuts": 12,
  3.   "Pineapples": 12,
  4.   "Papaya": 12
  5. ]

每个键都是唯一的，即使它们都包含相同的值

类型一致性

  1. var numberOfSides = [
  2.   "triangle": 3,
  3.   "square": 4,
  4.   "rectangle": 4
  5. ]

仅包含 String 键和 Int 值

初始化填充字典

  1. var employeeID = [
  2.   "Hamlet": 1367,
  3.   "Horatio": 8261,
  4.   "Ophelia": 9318
  5. ]

初始化一个空字典

  1. // 初始化器语法：
  2. var yearlyFishPopulation = [Int: Int]()
  4. // 空字典字面量语法：
  5. var yearlyBirdPopulation: [Int: Int] = [:]

添加到字典

  1. var pronunciation = [
  2.   "library": "lai·breh·ree",
  3.   "apple": "a·pl"
  4. ]
  5. // 新键：“programming”，新值：“prow·gra”
  6. pronunciation["programming"] = "prow·gra"

删除键值对

  1. var bookShelf = [
  2.   "Goodnight": "Margaret Wise Brown",
  3.   "The BFG": "Roald Dahl",
  4.   "Falling Up": "Shel Silverstein",
  5.   "No, David!": "David Shannon"
  6. ]
  8. // 通过将 key 设置为 nil 来删除值
  9. bookShelf["The BFG"] = nil
  11. // 使用 .removeValue() 删除值
  12. bookShelf.removeValue(forKey: "Goodnight")
  14. // 删除所有值
  15. bookShelf.removeAll()

修改键值对

  1. var change = [
  2.   "Quarter": 0.29,
  3.   "Dime": 0.15,
  4.   "Nickel": 0.05
  5. ]
  7. // 使用下标语法更改值
  8. change["Quarter"] = .25
  10. // 使用 .updateValue() 更改值
  11. change.updateValue(.10, forKey: "Dime")

要更改键值对的值，请使用 .updateValue() 方法或下标语法，通过将括号 [ ] 和其中的现有键附加到字典的名称，然后添加赋值运算符 (=) 后跟修改后的值

.isEmpty 属性

  1. var bakery = [String:Int]()
  3. // 检查字典是否为空
  4. print(bakery.isEmpty)    // 打印 true
  5. bakery["Cupcakes"] = 12
  6. // 检查字典是否为空
  7. print(bakery.isEmpty)    // 打印 false

.count 属性

  1. var fruitStand = [
  2.   "Apples": 12,
  3.   "Oranges", 17
  4. ]
  5. print(fruitStand.count)  // 打印: 2

为变量赋值

  1. var hex = [
  2.   "red": "#ff0000",
  3.   "yellow": "#ffff00",
  4.   "blue": "#0000ff",
  5. ]
  7. print("蓝色十六进制代码 \(hex["blue"])")
  8. // 打印: 蓝色十六进制代码 Optional("#0000ff")
  10. if let redHex = hex["red"] {
  11.   print("红色的十六进制代码 \(redHex)")
  12. }
  13. // 打印: 红色的十六进制代码 #ff0000

将键值对的值分配给变量将返回一个可选值。要提取值，请使用可选的展开

遍历字典

  1. var emojiMeaning = [
  2.   "🤔": "Thinking Face",
  3.   "😪": "Sleepy Face",
  4.   "😵": "Dizzy Face"
  5. ]
  6. // 遍历键和值
  7. for (emoji, meaning) in emojiMeaning {
  8.   print("\(emoji)被称为'\(meaning)Emoji'")
  9. }
  10. // 仅通过键迭代
  11. for emoji in emojiMeaning.keys {
  12.   print(emoji)
  13. }
  14. // 仅通过值迭代
  15. for meaning in emojiMeaning.values {
  16.   print(meaning)
  17. }

函数

基础函数

  1. func washCar() -> Void {
  2.   print("Soap")
  3.   print("Scrub")
  4.   print("Rinse")
  5.   print("Dry")
  6. }

调用函数

  1. func greetLearner() {
  2.  print("欢迎来到 Quick Reference!")
  3. }
  4. // 函数调用：
  5. greetLearner()
  6. // 打印: 欢迎来到 Quick Reference!

返回值

  1. let birthYear = 1994
  2. var currentYear = 2020
  4. func findAge() -> Int {
  5.   return currentYear - birthYear
  6. }
  8. print(findAge()) // 打印: 26

多个参数

  1. func convertFracToDec(numerator: Double, denominator: Double) -> Double {
  2.   return numerator / denominator
  3. } 
  5. let decimal = convertFracToDec(numerator: 1.0, denominator: 2.0) 
  6. print(decimal) // Prints:  0.5

省略参数标签

  1. func findDiff(_ a: Int, b: Int) -> Int {
  2.   return a - b
  3. }
  5. print(findDiff(6, b: 4)) // 打印: 2

返回多个值

  1. func smartphoneModel() -> (name: String, version: String, yearReleased: Int) {
  2.   return ("iPhone", "8 Plus", 2017)
  3. }
  5. let phone = smartphoneModel()
  7. print(phone.name)     // 打印: iPhone
  8. print(phone.version)  // 打印: 8 Plus
  9. print(phone.yearReleased) // 打印: 2017

Parameters & Arguments

  1. func findSquarePerimet(side: Int) -> Int {
  2.   return side * 4
  3. } 
  5. let perimeter = findSquarePerimet(side: 5)
  6. print(perimeter) // 打印: 20
  8. // Parameter: side
  9. // Argument:  5

隐式返回

  1. func nextTotalSolarEclipse() -> String {
  2.   "April 8th, 2024 🌎"
  3. }
  5. print(nextTotalSolarEclipse())
  6. // 打印: April 8th, 2024 🌎

默认参数

  1. func greet(person: String = "guest") {
  2.   print("Hello \(person)")
  3. }
  4. greet() // Hello guest
  5. greet(person: "Aliya") // Hello Aliya

输入输出参数

  1. var currentSeason = "冬天" 
  3. func season(month: Int, name: inout String) {
  4.   switch month {
  5.     case 1...2:
  6.       name = "冬天 ⛄️" 
  7.     case 3...6:
  8.       name = "春天 🌱"
  9.     case 7...9:
  10.       name = "夏天 ⛱"
  11.     case 10...11: 
  12.       name = "秋天 🍂"
  13.     default: 
  14.       name = "未知"
  15.   } 
  16. } 
  18. season(monthNum: 4, name: &currentSeason)
  20. print(currentSeason) // 春天 🌱

可变参数

  1. func totalStudent(data: String...) -> Int {
  2.   let numStudents = data.count
  3.   return numStudents
  4. }
  6. print(totalStudent(data: "王五", "张三"))
  7. // 打印: 2

可选参数

  1. func getFirstInitial(from name: String?) -> String? {
  2.   return name?.first
  3. }

函数可以接受可选类型并返回可选类型。当一个函数不能返回请求类型的合理实例时，它应该返回 nil

结构

结构创建

  1. struct Building {
  2.   var address: String
  3.   var floors: Int
  5.   init(address: String, floors: Int) {
  6.     self.address = address
  7.     self.floors = floors
  8.   }
  9. }

结构或结构用于以编程方式在代码中表示现实生活中的对象。结构是使用 struct 关键字创建的，后跟其名称，然后是包含其属性和方法的主体

默认属性值

  1. struct Car {
  2.   var numOfWheels = 4
  3.   var topSpeed = 80
  4. }
  6. var reliantRobin = Car(numOfWheels: 3)
  8. print(reliantRobin.numOfWheels) // 打印: 3
  9. print(reliantRobin.topSpeed)    // 打印: 80

结构实例创建

  1. struct Person {
  2.   var name: String
  3.   var age: Int
  5.   init(name: String, age: Int) {
  6.     self.name = name
  7.     self.age = age
  8.   }
  9. }
  11. // Person 实例：
  12. var morty = Person(name: "张三", age: 14)

init() 方法

  1. struct TV {
  2.   var size: Int
  3.   var type: String
  5.   init(size: Int, type: String) {
  6.     self.size = size
  7.     self.type = type
  8.   }
  9. }

使用 TV 类

  1. var newTV = TV(size: 65, type: "LED")

检查类型

  1. print(type(of: "abc")) // 打印: String
  2. print(type(of: 123))   // 打印: 123

变异方法(mutating)

  1. struct Menu {
  2.   var menuItems = ["Fries", "Burgers"]
  3.   mutating func addToMenu(dish: String) {
  4.     self.menuItems.append(dish)
  5.   }
  6. }

使用 Menu 类

  1. var dinerMenu = Menu()
  2. dinerMenu.addToMenu(dish: "Toast")
  3. print(dinerMenu.menuItems) 
  4. // 打印: ["Fries", "Burgers", "Toast"]

结构方法

  1. struct Dog {
  2.   func bark() {
  3.     print("Woof")
  4.   }
  5. }
  6. let fido = Dog()
  7. fido.bark() // 打印: Woof

Class

引用类型（类）

  1. class Player {
  2.   var name: String
  4.   init(name: String) {
  5.     self.name = name
  6.   }
  7. }
  9. var player1 = Player(name: "Tomoko")
  10. var player2 = player1
  11. player2.name = "Isabella"
  13. print(player1.name) // Isabella
  14. print(player2.name) // Isabella

类的实例

  1. class Person {
  2.   var name = ""
  3.   var age = 0
  4. }
  6. var sonny = Person()
  7. // sonny 现在是 Person 的一个实例

init() 方法

  1. class Fruit {
  2.   var hasSeeds = true 
  3.   var color: String
  5.   init(color: String) {
  6.     self.color = color
  7.   }
  8. }

使用 Fruit 类

  1. let apple = Fruit(color: "red")

可以使用 init() 方法和相应的初始化属性来初始化类，在 init() 方法中，self 关键字用于引用类分配属性值的实际实例

类属性

  1. var ferris = Student()
  3. ferris.name = "Ferris Bueller"
  4. ferris.year = 12
  5. ferris.gpa = 3.81
  6. ferris.honors = false

继承

假设我们有一个 BankAccount 类：

  1. class BankAccount {
  2.   var balance = 0.0
  3.   func deposit(amount: Double) {
  4.     balance += amount
  5.   }
  6.   func withdraw(amount: Double) {
  7.     balance -= amount
  8.   }
  9. }

SavingsAccount 继承 BankAccount 类

  1. class SavingsAccount: BankAccount {
  2.   var interest = 0.0
  4.   func addInterest() {
  5.     let interest = balance * 0.005
  6.     self.deposit(amount: interest)
  7.   }
  8. }

新的 SavingsAccount 类(子类)自动获得了 BankAccount 类(超类)的所有特征。 此外，SavingsAccount 类定义了一个 .interest 属性和一个 .addInterest() 方法。

示例

使用数据类型

  1. class Student {
  2.   var name: String
  3.   var year: Int
  4.   var gpa: Double
  5.   var honors: Bool
  6. }

使用默认属性值

  1. class Student {
  2.   var name = ""
  3.   var gpa = 0.0
  4.   var honors = false
  5. }

这是结构定义和类定义的示例

  1. struct Resolution {
  2.   var width = 0
  3.   var height = 0
  4. }
  5. class VideoMode {
  6.   var resolution = Resolution()
  7.   var interlaced = false
  8.   var frameRate = 0.0
  9.   var name: String?
  10. }

Resolution 结构定义和 VideoMode 类定义仅描述 Resolution 或 VideoMode 的外观，创建结构或类的实例：

  1. let resolution = Resolution(width: 1920)
  2. let someVideoMode = VideoMode()

枚举

定义枚举

  1. enum Day {
  2.   case monday
  3.   case tuesday
  4.   case wednesday
  5.   case thursday
  6.   case friday
  7.   case saturday
  8.   case sunday
  9. }
  11. let casualWorkday: Day = .friday

Switch 语句

  1. enum Dessert {
  2.   case cake(flavor: String)
  3.   case vanillaIceCream(scoops: Int)
  4.   case brownie
  5. }
  7. let customerOrder: Dessert = .cake(flavor: "红色天鹅绒")
  8. switch customerOrder {
  9.   case let .cake(flavor):
  10.       print("你点了一个 \(flavor) 蛋糕")
  11.   case .brownie: 
  12.       print("你点了一块巧克力蛋糕")
  13. }
  14. // 打印: "你点了一个红色天鹅绒蛋糕"

CaseIterable

  1. enum Season: CaseIterable {
  2.   case winter
  3.   case spring
  4.   case summer
  5.   case fall
  6. }
  8. for season in Season.allCases {
  9.   print(season)
  10. }

添加对 CaseIterable 协议的一致性以访问 allCases 属性，该属性返回枚举的所有案例的数组

原始值

  1. enum Beatle: String {
  2.   case john, paul, george, ringo
  3. }
  5. print("披头士是 \(Beatle.john.rawValue).")
  6. // 打印: 披头士是 john.

相关值

  1. enum Dessert {
  2.   case cake(flavor: String)
  3.   case vanillaIceCream(scoops: Int)
  4.   case brownie
  5. }
  7. let order: Dessert = .cake(flavor: "红色天鹅绒")

实例方法

  1. enum Traffic {
  2.   case light
  3.   case heavy
  5.   mutating func reportAccident() {
  6.     self = .heavy
  7.   }
  8. }
  10. var currentTraffic: Traffic = .light
  12. currentTraffic.reportAccident()
  13. // currentTraffic 现在是 .heavy

就像类和结构一样，枚举也可以有实例方法。如果实例方法改变了枚举的值，则需要将其标记为 mutating

从原始值初始化

  1. enum Hello: String {
  2.   case english = "Hello"
  3.   case japanese = "你好呀！"
  4.   case emoji = "👋"
  5. }
  6. let hello1 = Hello(rawValue: "你好呀！")
  7. let hello2 = Hello(rawValue: "Привет")
  8. print(hello1) // Optional(Hello.japanese)
  9. print(hello2) // nil

计算属性

  1. enum ShirtSize: String {
  2.   case small = "S"
  3.   case medium = "M"
  4.   case large = "L"
  5.   case extraLarge = "XL"
  6.     var description: String {
  7.     return "这件衬衫尺码是 \(self.rawValue)"
  8.   }
  9. }

另见