Swift 备忘清单

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

入门

变量

1
2
3
4
5
6
7
8
9
10
var score = 0 // 变量
let pi = 3.14 // 常数

var greeting = "Hello"
var numberOfToys = 8
var isMorning = true

var numberOfToys: Int = 8
numberOfToys += 1
print(numberOfToys) // 打印 "9"

类型注释

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

算术运算符

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

复合赋值运算符

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

字符串插值

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

多行字符串

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

代码注释

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

组成一个元组

1
2
3
4
let player = ("Maya", 5, 150)

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

分解元组

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

特殊注释语法 (MARK)

1
// MARK: - 查看设置

MARK 可用于在栏中显示评论

特殊注释语法 (TODO)

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

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

特殊注释语法 (FIXME)

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

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

变量

变量声明

变量用 var 声明：

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

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

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

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

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

常数

常量用 let 声明：

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

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

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

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

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

计算变量（get 和 set）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import Foundation

let df = DateFormatter()
df.dateFormat = "d MMMM yyyy"

var birth = df.date(from: "5 June 1999")!

var age: Int {
  Calendar.current
    .dateComponents([.year],
                  from: birth,
                  to: Date()).year!
}

print(age) // 20
birth = df.date(from: "5 June 2002")!
print(age) // 17

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
var distanceInMeters: Float = 100

var distanceInFeet: Float {
  get {
    distanceInMeters * 3.28
  }
  set(newDistance) {
    distanceInMeters = newDistance / 3.28
  }
}

print(distanceInMeters) // 100.0
print(distanceInFeet) // 328.0

distanceInFeet = 250
print(distanceInMeters) // 76.21951
print(distanceInFeet) // 250.0

distanceInMeters = 800
print(distanceInMeters) // 800.0
print(distanceInFeet) // 2624.0

willSet

1
2
3
4
5
6
7
var distance = 5 {
  willSet {
    print("距离将被设置")
  }
}

distance = 10 // 打印: 距离将被设置

可以在 willSet 中访问新值：

1
2
3
4
5
6
7
var distance = 5 {
  willSet(newDistance) {
    print("距离将被设置 \(newDistance)")
  }
}

distance = 10 // 打印: 距离将被设置 10

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

didSet

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

willSet 和 didSet

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

条件和逻辑

if 语句

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

else 语句

1
2
3
4
5
6
7
8
var turbulence = false

if turbulence {
  print("请坐好。")
} else {
  print("你可以自由地四处走动。")
}
// 打印: 你可以自由地四处走动。

else if 语句

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

比较运算符

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

三元条件运算符

1
2
3
4
5
var driverLicense = true

driverLicense 
    ? print("驾驶座") : print("乘客座位") 
// 打印: 驾驶座

switch 语句

1
2
3
4
5
6
7
8
9
10
11
12
13
var secondaryColor = "green"

switch secondaryColor {
  case "orange":
    print("红色和黄色的混合")
  case "purple":
    print("红色和蓝色的混合")
  case "green":
    print("蓝色和黄色的混合")
  default:
    print("这可能不是辅助颜色")
}
// 打印: 蓝色和黄色的混合

switch 语句：区间匹配

1
2
3
4
5
6
7
8
9
10
11
12
let year = 1905
var artPeriod: String

switch year {
  case 1860...1885:
    artPeriod = "印象派"
  case 1886...1910:
    artPeriod = "后印象派"
  default:  
    artPeriod = "未知"
}
// 打印: 后印象派

switch 语句：复合案例

1
2
3
4
5
6
7
8
9
10
11
12
13
let service = "Seamless"

switch service {
  case "Uber", "Lyft":
    print("旅行")
  case "DoorDash", "Seamless", "GrubHub":
    print("餐厅送餐")
  case "Instacart", "FreshDirect":
    print("杂货配送")
  default: 
    print("未知服务")
}
// 打印: 餐厅外卖

switch 语句：where 子句

1
2
3
4
5
6
7
8
9
10
11
12
let num = 7

switch num {
  case let x where x % 2 == 0:
    print("\(num) 是偶数")
  case let x where x % 2 == 1:
    print("\(num) 奇数")
  default:
    print("\(num) 无效")
}

// 打印: 7 奇数

逻辑运算符

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

逻辑运算符 &&

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

逻辑运算符 ||

1
2
3
4
true || true    // true
true || false   // true
false || true   // true 
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
3
4
5
6
7
// 没有括号：
true || true && false || false
// ---->  true 

// 带括号：
(true || true) && (false || false)
// ---->  false

简单的 guard

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

循环

范围

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

stride() 函数

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

for-in 循环

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

continue 关键字

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

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

break 关键字

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

使用下划线

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

遍历指定范围

1
2
3
for i in 0...10 {
  print(i) //0 到 10
}

封闭指定范围操作符（…）

while 循环

1
2
3
4
5
6
7
8
var counter = 1
var stopNum = Int.random(in: 1...10)

// 循环打印，直到满足停止条件
while counter < stopNum {
  print(counter)
  counter += 1
}

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

repeate while

1
2
3
4
5
6
var counter = 1

repeat {
  print(counter)
  counter += 1
} while counter <= 5

至少执行一次

遍历字典对象

1
2
3
4
5
6
7
8
9
// 创建一个字典
var myDictionary = [
  "name": "John", "age": 25
]

// 使用for-in循环遍历字典
for (key, value) in myDictionary {
    print("\(key): \(value)")
}

数组和集合

Array 数组

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

.count 属性

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

索引

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

1
2
3
4
5
6
7
var vowels = ["a", "e", "i", "o", "u"]

print(vowels[0])  // 打印: a
print(vowels[1])  // 打印: e
print(vowels[2])  // 打印: i
print(vowels[3])  // 打印: o
print(vowels[4])  // 打印: u

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

用数组字面量初始化

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

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

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

.insert() 和 .remove() 方法

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

moon.remove(at: 4)
// ["🌕", "🌖", "🌗", "🌘"]

遍历数组

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

集合(Set)

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

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

空集合(Set)

1
2
3
4
var team = Set<String>()

print(team)
// 打印: []

填充集合

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

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

.insert()

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

.remove() 和 .removeAll() 方法

1
2
3
4
5
6
var oddNumbers: Set = [1, 2, 3, 5]

// 移除现有元素
oddNumbers.remove(2)
// 删除所有元素
oddNumbers.removeAll()

.contains() 检测数组中的值

1
2
3
4
5
6
7
8
9
var names: Set = ["Rosa", "Doug", "Waldo"]
print(names.contains("Lola")) //打印: false

if names.contains("Waldo"){
  print("There's Waldo!")
} else {
  print("Where's Waldo?")
}
// 打印: There's Waldo!

迭代一个集合

1
2
3
4
5
var recipe: Set = ["蛋", "面粉", "糖"]

for ingredient in recipe {
  print ("在配方中包含\(ingredient)")
}

.isEmpty 属性

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

var populatedSet: Set = [1, 2, 3]
print(populatedSet.isEmpty) // 打印: false

.count 属性

1
2
3
4
var band: Set = ["张三", "王五", "赵六"]

print("乐队有 \(band.count) 名演奏者。")
// 打印: 乐队有 4 名演奏者。

.intersection() 交叉

1
2
3
4
5
var setA: Set = ["A", "B", "C", "D"]
var setB: Set = ["C", "D", "E", "F"]

var setC = setA.intersection(setB)
print(setC)  // 打印: ["D", "C"]

.union() 合并去重

1
2
3
4
5
6
var setA: Set = ["A", "B", "C", "D"]
var setB: Set = ["C", "D", "E", "F"]

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

.symmetricDifference() 对称差

1
2
3
4
5
6
var setA: Set = ["A", "B", "C", "D"]
var setB: Set = ["C", "D", "E", "F"]

var setC = setA.symmetricDifference(setB)
print(setC) 
// 打印: ["B", "E", "F", "A"]

.subtracting() 减法

1
2
3
4
5
6
var setA: Set = ["A", "B", "C", "D"]
var setB: Set = ["C", "D"]

var setC = setA.subtracting(setB)
print(setC) 
// 打印: ["B", "A"]

字典

基础字典

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

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

Keys

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

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

类型一致性

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

仅包含 String 键和 Int 值

初始化填充字典

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

初始化一个空字典

1
2
3
4
5
// 初始化器语法：
var yearlyFishPopulation = [Int: Int]()

// 空字典字面量语法：
var yearlyBirdPopulation: [Int: Int] = [:]

添加到字典

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

删除键值对

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var bookShelf = [
  "Goodnight": "Margaret Wise Brown",
  "The BFG": "Roald Dahl",
  "Falling Up": "Shel Silverstein",
  "No, David!": "David Shannon"
]

// 通过将 key 设置为 nil 来删除值
bookShelf["The BFG"] = nil

// 使用 .removeValue() 删除值
bookShelf.removeValue(forKey: "Goodnight")

// 删除所有值
bookShelf.removeAll()

修改键值对

1
2
3
4
5
6
7
8
9
10
11
var change = [
  "Quarter": 0.29,
  "Dime": 0.15,
  "Nickel": 0.05
]

// 使用下标语法更改值
change["Quarter"] = .25

// 使用 .updateValue() 更改值
change.updateValue(.10, forKey: "Dime")

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

.isEmpty 属性

1
2
3
4
5
6
7
var bakery = [String:Int]()

// 检查字典是否为空
print(bakery.isEmpty)    // 打印 true
bakery["Cupcakes"] = 12
// 检查字典是否为空
print(bakery.isEmpty)    // 打印 false

.count 属性

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

为变量赋值

1
2
3
4
5
6
7
8
9
10
11
12
13
var hex = [
  "red": "#ff0000",
  "yellow": "#ffff00",
  "blue": "#0000ff",
]

print("蓝色十六进制代码 \(hex["blue"])")
// 打印: 蓝色十六进制代码 Optional("#0000ff")

if let redHex = hex["red"] {
  print("红色的十六进制代码 \(redHex)")
}
// 打印: 红色的十六进制代码 #ff0000

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

遍历字典

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

函数

基础函数

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

返回值为空的函数（void）

调用函数

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

返回值

1
2
3
4
5
6
7
8
let birthYear = 1994
var currentYear = 2020

func findAge() -> Int {
  return currentYear - birthYear
}

print(findAge()) // 打印: 26

多个参数

1
2
3
4
5
6
func convertFracToDec(numerator: Double, denominator: Double) -> Double {
  return numerator / denominator
} 

let decimal = convertFracToDec(numerator: 1.0, denominator: 2.0) 
print(decimal) // Prints:  0.5

省略参数标签

1
2
3
4
5
func findDiff(_ a: Int, b: Int) -> Int {
  return a - b
}

print(findDiff(6, b: 4)) // 打印: 2

返回多个值

1
2
3
4
5
6
7
8
9
func smartphoneModel() -> (name: String, version: String, yearReleased: Int) {
  return ("iPhone", "8 Plus", 2017)
}

let phone = smartphoneModel()

print(phone.name)     // 打印: iPhone
print(phone.version)  // 打印: 8 Plus
print(phone.yearReleased) // 打印: 2017

Parameters & Arguments

1
2
3
4
5
6
7
8
9
func findSquarePerimet(side: Int) -> Int {
  return side * 4
} 

let perimeter = findSquarePerimet(side: 5)
print(perimeter) // 打印: 20

// Parameter: side
// Argument:  5

隐式返回

1
2
3
4
5
6
func nextTotalSolarEclipse() -> String {
  "April 8th, 2024 🌎"
}

print(nextTotalSolarEclipse())
// 打印: April 8th, 2024 🌎

默认参数

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

输入输出参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
var currentSeason = "冬天" 

func season(month:Int, name:inout String) {
  switch month {
    case 1...2:
      name = "冬天 ⛄️" 
    case 3...6:
      name = "春天 🌱"
    case 7...9:
      name = "夏天 ⛱"
    case 10...11: 
      name = "秋天 🍂"
    default: 
      name = "未知"
  } 
} 

season(monthNum: 4, name: &currentSeason)

print(currentSeason) // 春天 🌱

可变参数

1
2
3
4
5
6
7
func totalStudent(data: String...) -> Int {
  let numStudents = data.count
  return numStudents
}

print(totalStudent(data: "王五", "张三"))
// 打印: 2

可选参数

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

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

省略 return 关键字

1
2
3
func multiply(x: Int, y: Int) -> Int {
  x * y
}

额外指定参数命名标签

1
2
3
4
5
6
7
8
9
10
11
12
13
func calculate(of numbers: Int...) -> Int {
  var sum = 0

  for number in numbers {
      sum += number
  }

  return sum
}

// 调用函数时，使用外部参数名
let result = calculate(of: 1, 2, 3, 4, 5)
print("Sum: \(result)")

函数作为参数

1
2
3
4
5
6
7
8
9
10
11
12
13
func doMath(
  operation: (Int, Int) -> Int,
  a: Int, b: Int
) -> Int {
    return operation(a, b)
}
// 定义一些可以作为参数传递的函数
func add(_ a: Int, _ b: Int) -> Int {
    return a + b
}
// 使用 doMath 函数，并将 add 函数作为参数传递
let result = doMath(5, 3, operation: add)
print("Addition Result: \(result)")

闭包

1
2
3
4
5
6
let add: (Int, Int) -> Int = { (a, b) in
    return a + b
}
// 调用闭包
let result = add(3, 5)
print("Sum: \(result)")

结构

结构创建

1
2
3
4
5
6
7
8
9
struct Building {
  var address: String
  var floors: Int

  init(address: String, floors: Int) {
    self.address = address
    self.floors = floors
  }
}

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

默认属性值

1
2
3
4
5
6
7
8
9
struct Car {
  var numOfWheels = 4
  var topSpeed = 80
}

var reliantRobin = Car(numOfWheels: 3)

print(reliantRobin.numOfWheels) // 打印: 3
print(reliantRobin.topSpeed)    // 打印: 80

结构实例创建

1
2
3
4
5
6
7
8
9
10
11
12
struct Person {
  var name: String
  var age: Int

  init(name: String, age: Int) {
    self.name = name
    self.age = age
  }
}

// Person 实例：
var morty = Person(name: "张三", age: 14)

init() 方法

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

使用 TV 类

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

检查类型

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

变异方法(mutating)

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

使用 Menu 类

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

结构方法

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

Class

引用类型（类）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Player {
  var name: String

  init(name: String) {
    self.name = name
  }
}

var player1 = Player(name: "Tomoko")
var player2 = player1
player2.name = "Isabella"

print(player1.name) // Isabella
print(player2.name) // Isabella

类的实例

1
2
3
4
5
6
7
class Person {
  var name = ""
  var age = 0
}

var sonny = Person()
// sonny 现在是 Person 的一个实例

init() 方法

1
2
3
4
5
6
7
8
class Fruit {
  var hasSeeds = true 
  var color: String

  init(color: String) {
    self.color = color
  }
}

使用 Fruit 类

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

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

类属性

1
2
3
4
5
6
var ferris = Student()

ferris.name = "Ferris Bueller"
ferris.year = 12
ferris.gpa = 3.81
ferris.honors = false

继承

假设我们有一个 BankAccount 类：

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

SavingsAccount 继承 BankAccount 类

1
2
3
4
5
6
7
8
class SavingsAccount: BankAccount {
  var interest = 0.0

  func addInterest() {
    let interest = balance * 0.005
    self.deposit(amount: interest)
  }
}

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

示例

使用数据类型

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

使用默认属性值

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

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

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

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

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

类的扩展

1
2
3
4
5
6
extension String {
  var boolValue: Bool {
    return self == "1"
  }
}
let isTure = "0".boolValue

枚举

定义枚举

1
2
3
4
5
6
7
8
9
10
11
enum Day {
  case monday
  case tuesday
  case wednesday
  case thursday
  case friday
  case saturday
  case sunday
}

let casualWorkday: Day = .friday

Switch 语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
enum Dessert {
  case cake(flavor: String)
  case vanillaIceCream(scoops: Int)
  case brownie
}

let custom: Dessert = .cake(flavor: "红色")
switch custom {
  case let .cake(flavor):
    print("你点了一个 \(flavor) 蛋糕")
  case .brownie: 
    print("你点了一块巧克力蛋糕")
}
// 打印: "你点了一个红色天鹅绒蛋糕"

CaseIterable

1
2
3
4
5
6
7
8
9
10
enum Season: CaseIterable {
  case winter
  case spring
  case summer
  case fall
}

for season in Season.allCases {
  print(season)
}

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

原始值

1
2
3
4
5
6
enum Beatle: String {
  case john, paul, george, ringo
}

print("披头士是 \(Beatle.john.rawValue).")
// 打印: 披头士是 john.

相关值

1
2
3
4
5
6
7
enum Dessert {
  case cake(flavor: String)
  case vanillaIceCream(scoops: Int)
  case brownie
}

let order: Dessert = .cake(flavor: "红色")

枚举的可赋值性

1
2
3
4
5
enum Content {
  case empty
  case text(String)
  case number(Int)
}

使用 switch 处理可赋值枚举

1
2
3
4
5
6
7
8
9
10
11
12
13
let content = Content.text("Hello")
switch content {
  case .empty:
    print("Value is empty")
  case .text(let value):
    print("Value is \(value)")
  case .number(_): //不调用时，可以省略
    print("Value is a number")
}
// 或者
if case .text(let value) = content {
    print("Value is \(value)")
}

从原始值初始化

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

计算属性

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

遍历字符串

1
2
3
4
5
enum Currency: String {
  case euro = "EUR"
  case dollar = "USD"
  case pound = "GBP"
}

输出枚举的原始值

1
2
let euroSymbol = Currency.euro.rawValue
print("欧元的货币符号是 \(euroSymbol)")

实例方法

1
2
3
4
5
6
7
8
enum Traffic {
  case light
  case heavy

  mutating func reportAccident() {
    self = .heavy
  }
}

枚举也可以有实例方法

1
2
3
var currentTraffic: Traffic = .light
currentTraffic.reportAccident()
// currentTraffic 现在是 .heavy

实例方法改变了枚举的值，则需要将其标记为 mutating

扩展

声明扩展

1
2
3
4
5
6
7
8
9
10
11
struct Person {
    var name: String
    var age: Int
    func eat() {}
}
extension Person {
    // 添加新功能
}
extension Person: SomeProtocol {
     // 实现协议方法、属性
}

扩展构造器

1
2
3
4
5
6
7
8
9
10
11
12
// 给CGRect结构体提供允许center和size的构造器
extension CGRect {
    init(center: CGPoint, size: CGSize) {
        let x: CGFloat = center.x - size.width * 0.5
        let y: CGFloat = center.y - size.height * 0.5
        self.init(origin: CGPoint(x: x, y: y), 
                  size: size)
    }
}
let frame = CGRect(center: CGPoint(x: 100, y: 100), 
                   size: CGSize(width: 50, height: 50))
print("Origin is \(frame.origin)")

扩展可变实例方法

1
2
3
4
5
6
7
8
extension Double {
    mutating func cube() {
        self = self * self * self
    }
}
var boxCube: Double = 2.0
boxCube.cube()
print(boxCube)

扩展方法

1
2
3
4
5
6
7
8
9
extension String {
    func deletingPrefix(_ prefix: String) -> String {
        guard self.hasPrefix(prefix) else {
          return self 
        }
        return String(self.dropFirst(prefix.count))
    }
}
print("Hello World".deletingPrefix("He"))

扩展计算属性

1
2
3
4
5
6
7
8
9
10
// 扩展可以添加计算属性，不能添加存储属性
extension Double {
    var km: Double { self * 1000 }
    var m: Double { self }
    var cm: Double { self / 100.0 }
    var mm: Double { self / 1000.0 }
}
let metric: Double = 30.48.cm
print("1 metric is \(metric.m) meter")
print("1 metric is \(metric.km) kilometer")

扩展存储属性

1
2
3
4
5
6
7
8
9
10
11
12
// 但可以通过 objc_getAssociatedObject/objc_setAssociatedObject 实现添加存储属性 
private var fuchsiaKey = "fuchsiaKey"
extension UIColor {
    var fuchsia: UIColor? {
        get {
            return objc_getAssociatedObject(self, &fuchsiaKey) as? UIColor
        }
        set {
            objc_setAssociatedObject(self, &fuchsiaKey, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
    }
}

另见

评论
avatar
竹山一叶
技术分享 个人心得
文章
436
标签
26
分类
19
Follow Me
公告
欢迎光临小站，这里是我日常工作和学习中收集和整理的总结，希望能对你有所帮助：）

本站的内容经过个人加工总结而来，也参考了网友们分享的资料，如有侵权，请第一时间联系我，我将及时进行修改或删除😊
目录
  1. 1. 入门
    1. 1.1. 变量
    2. 1.2. 类型注释
    3. 1.3. 算术运算符
      1. 1.3.1. 复合赋值运算符
    4. 1.4. 字符串插值
    5. 1.5. 多行字符串
    6. 1.6. 代码注释
    7. 1.7. 组成一个元组
    8. 1.8. 分解元组
    9. 1.9. 特殊注释语法 (MARK)
    10. 1.10. 特殊注释语法 (TODO)
    11. 1.11. 特殊注释语法 (FIXME)
  2. 2. 变量
    1. 2.1. 变量声明
    2. 2.2. 常数
    3. 2.3. 计算变量（get 和 set）
    4. 2.4. willSet
    5. 2.5. didSet
    6. 2.6. willSet 和 didSet
  3. 3. 条件和逻辑
    1. 3.1. if 语句
    2. 3.2. else 语句
    3. 3.3. else if 语句
    4. 3.4. 比较运算符
    5. 3.5. 三元条件运算符
    6. 3.6. switch 语句
    7. 3.7. switch 语句：区间匹配
    8. 3.8. switch 语句：复合案例
    9. 3.9. switch 语句：where 子句
    10. 3.10. 逻辑运算符
    11. 3.11. 逻辑运算符 &&
    12. 3.12. 逻辑运算符 ||
    13. 3.13. 组合逻辑运算符
    14. 3.14. 控制执行顺序
    15. 3.15. 简单的 guard
  4. 4. 循环
    1. 4.1. 范围
    2. 4.2. stride() 函数
    3. 4.3. for-in 循环
    4. 4.4. continue 关键字
    5. 4.5. break 关键字
    6. 4.6. 使用下划线
    7. 4.7. 遍历指定范围
    8. 4.8. while 循环
    9. 4.9. repeate while
    10. 4.10. 遍历字典对象
  5. 5. 数组和集合
    1. 5.1. Array 数组
    2. 5.2. .count 属性
    3. 5.3. 索引
    4. 5.4. 用数组字面量初始化
    5. 5.5. .append() 方法和 += 运算符
    6. 5.6. .insert() 和 .remove() 方法
    7. 5.7. 遍历数组
    8. 5.8. 集合(Set)
    9. 5.9. 空集合(Set)
    10. 5.10. 填充集合
    11. 5.11. .insert()
    12. 5.12. .remove() 和 .removeAll() 方法
    13. 5.13. .contains() 检测数组中的值
    14. 5.14. 迭代一个集合
    15. 5.15. .isEmpty 属性
    16. 5.16. .count 属性
    17. 5.17. .intersection() 交叉
    18. 5.18. .union() 合并去重
    19. 5.19. .symmetricDifference() 对称差
    20. 5.20. .subtracting() 减法
  6. 6. 字典
    1. 6.1. 基础字典
    2. 6.2. Keys
    3. 6.3. 类型一致性
    4. 6.4. 初始化填充字典
    5. 6.5. 初始化一个空字典
    6. 6.6. 添加到字典
    7. 6.7. 删除键值对
    8. 6.8. 修改键值对
    9. 6.9. .isEmpty 属性
    10. 6.10. .count 属性
    11. 6.11. 为变量赋值
    12. 6.12. 遍历字典
  7. 7. 函数
    1. 7.1. 基础函数
    2. 7.2. 调用函数
    3. 7.3. 返回值
    4. 7.4. 多个参数
    5. 7.5. 省略参数标签
    6. 7.6. 返回多个值
    7. 7.7. Parameters & Arguments
    8. 7.8. 隐式返回
    9. 7.9. 默认参数
    10. 7.10. 输入输出参数
    11. 7.11. 可变参数
    12. 7.12. 可选参数
    13. 7.13. 省略 return 关键字
    14. 7.14. 额外指定参数命名标签
    15. 7.15. 函数作为参数
    16. 7.16. 闭包
  8. 8. 结构
    1. 8.1. 结构创建
    2. 8.2. 默认属性值
    3. 8.3. 结构实例创建
    4. 8.4. init() 方法
    5. 8.5. 检查类型
    6. 8.6. 变异方法(mutating)
    7. 8.7. 结构方法
  9. 9. Class
    1. 9.1. 引用类型（类）
    2. 9.2. 类的实例
    3. 9.3. init() 方法
    4. 9.4. 类属性
    5. 9.5. 继承
    6. 9.6. 示例
    7. 9.7. 这是结构定义和类定义的示例
    8. 9.8. 类的扩展
  10. 10. 枚举
    1. 10.1. 定义枚举
    2. 10.2. Switch 语句
    3. 10.3. CaseIterable
    4. 10.4. 原始值
    5. 10.5. 相关值
    6. 10.6. 枚举的可赋值性
    7. 10.7. 从原始值初始化
    8. 10.8. 计算属性
    9. 10.9. 遍历字符串
    10. 10.10. 实例方法
  11. 11. 扩展
    1. 11.1. 声明扩展
    2. 11.2. 扩展构造器
    3. 11.3. 扩展可变实例方法
    4. 11.4. 扩展方法
    5. 11.5. 扩展计算属性
    6. 11.6. 扩展存储属性
  12. 12. 另见
最新文章
设备唯一标识方法（Unique Identifier）：如何在 Windows 系统上获取设备的唯一标识
设备唯一标识方法（Unique Identifier）：如何在 Windows 系统上获取设备的唯一标识
Python中使用urlencode提示not a valid non-string sequence or mapping object
Python中使用urlencode提示not a valid non-string sequence or mapping object
查看动态链接库dll或exe文件的依赖项
查看动态链接库dll或exe文件的依赖项
应用程序无法正常启动(0xc0150002)的解决思路
应用程序无法正常启动(0xc0150002)的解决思路
10种HTML禁止鼠标右键方法，你知道几种？
10种HTML禁止鼠标右键方法，你知道几种？
分类
标签
HexoGithubButterflyValineMarkdownGitLinuxSSHNginxIntelliJ IDEA/PyCharmAndroid StudioAndroidVisual Studio CodeUVCCameraGradleCMakeChromeToolsC++其他JNAJavaSVNVSCodePythonBAT
归档
网站资讯
文章数目 :
436
已运行时间 :
本站总字数 :
431.5k
本站访客数 :
本站总访问量 :
最后更新时间 :
文章归档文章分类文章标签复制本文标题复制本文地址
新窗口打开转到链接复制链接
随便逛逛