Swift 速查表

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

var apples = 6
print("I have \(apples) apples!")

// 打印: I have 6 apples!

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

// 这行代表 Swift 中的注释。

/*
这全部都被注释掉了。
都不会运行！
*/

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

// MARK: -视图设置

MARK 可用于在列中显示注释

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

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

// FIXME: 修复对现有条目进行更改时的错误行为

FIXME 用于显示需要修复的事项提醒

变量使用 var 声明：

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

为清晰起见，变量声明可以包含类型注解：

var greeting: String = "Hello"
var numberOfToys: Int = 8
var isMorning: Bool = true

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

var numberOfToys: Int = 8
numberOfToys += 1

print(numberOfToys)
// 打印 "9"

常量使用 let 声明：

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

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

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

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

let numberOfToys: Int = 8
numberOfToys += 1
// 错误: numberOfToys 是不可变的

var distance = 5 {
  didSet {
    print("距离已设置为 \(distance)")
    print("它的旧值是: \(oldValue)")
  }
}
distance = 10 // 打印: 距离已设置为 10
              // 打印: 它的旧值是: 5

var distance = 5 {
  willSet(newDistance) {
    print("距离将被设置为 \(newDistance)")
  }
  didSet {
    print("距离已设置为 \(distance)")
    print("它的旧值是: \(oldValue)")
  }
}
distance = 10

var halloween = true
if halloween {
  print("不给糖就捣蛋！")
}
// 打印: 不给糖就捣蛋！
if 5 > 3 {
  print("5 大于 3")
} else {
  print("5 不大于 3")
}
// 输出: "5 大于 3"

var turbulence = false

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

var weather = "rainy"
if weather == "sunny" {
  print("涂点防晒霜")
} else if weather == "rainy" {
  print("带把伞")
} else if weather == "snowing" {
  print("穿上你的雪地靴")
} else {
  print("无效的天气")
}
// 打印: 带把伞

5 > 1      // true
6 < 10     // true
2 >= 3     // false
3 <= 5     // true
"A" == "a" // false
"B" != "b" // true

-< 小于
-> 大于
-<= 小于等于
->= 大于等于
-== 等于
-!= 不等于

a...b      // a 和 b 之间的数字 (包括 a 和 b)
a..<b      // a 和 b 之间的数字 (包括 a 但不包括 b)
...b      // 直到 b 的数字 (包括 b)

-a...b 闭区间
-a..<b 半开区间
-...b 单边区间

var driverLicense = true

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

var secondaryColor = "green"

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

let year = 1905
var artPeriod: String

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

let service = "Seamless"

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

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 是奇数

!true  // false
!false //true

true && true   // true
true && false  // false
false && true  // false
false && false // false

true || true   // true
true || false  // true
false || true  // true
false || false // false

!false && true || false // true

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

false || true && false // false

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

// 没有括号:
true || true && false || false
//----> true

// 有括号:
(true || true) && (false || false)
//----> false

func greet(name: String?) {
  guard let unwrapped = name else {
    print("你好，客人！")
    return
  }
  print("你好 \(unwrapped)！")
}
greet(name: "Asma") // 输出: 你好 Asma！
greet(name: nil)    // 输出: 你好，客人！

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

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

for char in "hehe" {
  print(char)
}
// 打印: h
// 打印: e
// 打印: h
// 打印: e

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

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

for char in "supercalifragilistic" {
if char == "c" {
    break
  }
  print(char)
}
// 打印: s
// 打印: u
// 打印: p
// 打印: e
// 打印: r

for _ in 1...3 {
  print("Ole")
}
// 打印: Ole
// 打印: Ole
// 打印: Ole

var counter = 1
var stopNum = Int.random(in: 1...10)

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

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

var scores = [Int]()
// 数组为空: []

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

// 使用类型推断:
var snowfall = [2.4, 3.6, 3.4, 1.8, 0.0]
// 显式类型:
var temp: [Int] = [33, 31, 30, 38, 44]

var teams = [Int](repeating: 0, count: 3)
print(teams) // 打印: [0, 0, 0]
// 或者使用 Array 类型
var sizes = Array<Int>(repeating: 0, count: 3)
print(sizes) // 打印: [0, 0, 0]

var gymBadges = ["Boulder", "Cascade"]
gymBadges.append("Thunder")
gymBadges += ["Rainbow", "Soul"]
// ["Boulder", "Cascade", "Thunder",
// "Rainbow", "Soul"]

var moon = ["🌖", "🌗", "🌘", "🌑"]
moon.insert("🌕", at: 0)
// ["🌕", "🌖", "🌗", "🌘", "🌑"]

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

var employees = ["Peter", "Denial", "Jame"]
for person in employees {
  print(person)
}
// 打印: Peter
// 打印: Denial
// 打印: Jam

var paintingsInMOMA: Set = [
  "The Dream",
  "The Starry Night",
  "The False Mirror"
]

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

var team = Set<String>()

print(team)
// 打印: []

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

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

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

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

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

var names: Set = ["Rosa", "Doug", "Waldo"]
print(names.contains("Lola")) // 打印: false

if names.contains("Waldo"){
  print("Waldo 在这里！")
} else {
  print("Waldo 在哪里？")
}
// 打印: Waldo 在这里！

var emptyList = [String]()
print(emptyList.isEmpty)     // 打印: true

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

var recipe: Set = ["Egg", "Flour", "Sugar"]

for ingredient in recipe {
  print ("在食谱中加入 \(ingredient)")
}

var emptySet = Set<String>()
print(emptySet.isEmpty)     // 打印: true

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

var band: Set = ["Peter", "Denial", "Jame"]

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

var setA: Set = ["A", "B", "C", "D"]
var setB: Set = ["C", "D", "E", "F"]

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

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"]

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"]

var setA: Set = ["A", "B", "C", "D"]
var setB: Set = ["C", "D"]

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

var dictionaryName = [
  "Key1": "Value1",
  "Key2": "Value2",
  "Key3": "Value3"
]

一个 无序 的数据对或键值对集合

var fruitStand = [
  "Coconuts": 12,
  "Pineapples": 12,
  "Papaya": 12
]

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

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

仅包含 String 键和 Int 值

var employeeID = [
  "Hamlet": 1367,
  "Horatio": 8261,
  "Ophelia": 9318
]

// 初始化器语法:
var yearlyFishPopulation = [Int: Int]()

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

var pronunciation = [
  "library": "lai·breh·ree",
  "apple": "a·pl"
]
// 新键: "programming", 新值: "prow gra"
pronunciation["programming"] = "prow·gra"

var bakery = [String:Int]()

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

var fruitStand = [
  "Apples": 12,
  "Oranges": 17 // 注意：这里原文可能有误，应该是 "Oranges": 17
]
print(fruitStand.count) // 打印: 2

var hex = [
  "red": "#ff0000",
  "yellow": "#ffff00",
  "blue": "#0000ff",
]

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

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

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

var emojiMeaning = [
  "🤔": "思考脸",
  "😪": "困倦脸",
  "😵": "眩晕脸"
]
// 遍历键和值
for (emoji, meaning) in emojiMeaning {
  print("\(emoji) 被称为 '\(meaning)Emoji'")
}
// 仅遍历键
for emoji in emojiMeaning.keys {
  print(emoji)
}
// 仅遍历值
for meaning in emojiMeaning.values {
  print(meaning)
}

func washCar() -> Void {
  print("肥皂")
  print("擦洗")
  print("冲洗")
  print("擦干")
}

func greetLearner() {
 print("欢迎来到 r3f.cn！")
}
// 函数调用:
greetLearner()
// 打印: 欢迎来到 r3f.cn！

let birthYear = 1994
var currentYear = 2020

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

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

func findDiff(_ a: Int, b: Int) -> Int {
  return a -b
}

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

func findSquarePerimet(side: Int) -> Int {
  return side *4
}

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

// 参数: side
// 实际参数: 5

func nextTotalSolarEclipse() -> String {
  "2024年4月8日 🌎"
}

print(nextTotalSolarEclipse())
// 打印: 2024年4月8日 🌎

func greet(person: String = "客人") {
  print("你好 \(person)")
}
greet() // 你好 客人
greet(person: "Aliya") // 你好 Aliya

func totalStudent(data: String...) -> Int {
  let numStudents = data.count
  return numStudents
}

print(totalStudent(data: "Denial", "Peter"))
// 打印: 2

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

函数可以接受可选类型并返回可选类型。当函数无法返回所请求类型的合理实例时，它应该返回 nil

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

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

struct Car {
  var numOfWheels = 4
  var topSpeed = 80
}

var reliantRobin = Car(numOfWheels: 3)

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

struct Person {
  var name: String
  var age: Int

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

// Person 实例:
var morty = Person(name: "Peter", age: 14)

print(type(of: "abc")) // 打印: String
print(type(of: 123))   // 打印: Int (原文为 123，应为 Int)

struct Dog {
  func bark() {
    print("汪")
  }
}
let fido = Dog()
fido.bark() // 打印: 汪

class Person {
  var name = ""
  var age = 0
}

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

// 假设 Student 类已定义
class Student {
    var name: String = ""
    var year: Int = 0
    var gpa: Double = 0.0
    var honors: Bool = false
}

var ferris = Student()

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

使用数据类型

class Student {
  var name: String
  var year: Int
  var gpa: Double
  var honors: Bool
  // 需要初始化器
  init(name: String, year: Int, gpa: Double, honors: Bool) {
      self.name = name
      self.year = year
      self.gpa = gpa
      self.honors = honors
  }
}

使用默认属性值

class Student {
  var name = ""
  var gpa = 0.0
  var honors = false
}

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 的外观，创建结构体或类的实例：

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

enum Day {
  case monday
  case tuesday
  case wednesday
  case thursday
  case friday
  case saturday
  case sunday
}

let casualWorkday: Day = .friday

enum Dessert {
  case cake(flavor: String)
  case vanillaIceCream(scoops: Int)
  case brownie
}

let customerOrder: Dessert = .cake(flavor: "Red Velvet")
switch customerOrder {
  case let .cake(flavor):
    print("你点了一份 \(flavor) 蛋糕")
  case .brownie:
    print("你点了一份巧克力蛋糕") // 原文为 chocolate cake，但 case 是 brownie
  // 应该补充 default 或其他 case
}
// 打印: "你点了一份 red velvet 蛋糕"

enum Season: CaseIterable {
  case winter
  case spring
  case summer
  case falls // 通常是 fall 或 autumn
}

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

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

enum Beatle: String {
  case john, paul, george, ringo // 原文格式有误，应为逗号分隔或单独 case
}

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

###关联值

enum Dessert {
  case cake(flavor: String)
  case vanillaIceCream(scoops: Int)
  case brownie
}

let order: Dessert = .cake(flavor: "Red Velvet")

enum Hello: String {
  case english = "Hello"
  case japanese = "こんにちは" // 原文为 "Hello!"，应为日文
  case emoji = "👋"
}
let hello1 = Hello(rawValue: "こんにちは")
let hello2 = Hello(rawValue: "Привет")
print(hello1) // Optional(Hello.japanese)
print(hello2) // nil

enum ShirtSize: String {
  case small = "S"
  case medium = "M"
  case large = "L"
  case extraLarge = "XL"
  var description: String {
    return "这件衬衫的尺码是 \(self.rawValue)"
  }
}

扩展是一种向现有类、结构体、枚举或协议类型添加新功能的方法。这包括添加新方法、属性、初始化器等。

扩展对于组织和模块化我们的代码特别有用，而无需修改原始类型，尤其是在我们无法访问原始源代码时。

extension SomeType {
    // 要添加的新功能
}

extension Int {
    var isEven: Bool {
        self % 2 == 0
    }
}

print(4.isEven) // 输出: true
print(7.isEven) // 输出: false

extension String {
    func reverse() -> String {
        String(self.reversed())
    }
}

print("abc".reverse()) // 输出: cba

extension Int {
    mutating func square() {
        self = self * self
    }
}

var number = 5
number.square()
print(number) // 输出: 25

extension Date {
    init?(timestamp: Double) {
        self.init(timeIntervalSince1970: timestamp)
    }
}

let timestamp = 1693982400.0 // 2023-09-06 06:40:00 的 Unix 时间戳
if let date = Date(timestamp: timestamp) {
    print(date) // 输出: 2023-09-06 06:40:00 +0000
}

extension String {
    subscript(index: Int) -> Character {
        self[self.index(startIndex, offsetBy: index)]
    }
}

print("Swift"[0]) // 输出: S
print("Swift"[1]) // 输出: w
print("Swift"[2]) // 输出: i
print("Swift"[3]) // 输出: f
print("Swift"[4]) // 输出: t

当我们想要向符合特定协议或具有某些条件的类型添加功能时，这尤其有用。

extension Array where Element: Numeric {
    func sum() -> Element {
        reduce(0, +)
    }
}

let numbers = [1, 2, 3, 4, 5]
print(numbers.sum()) // 输出: 15

let doubles = [1.5, 2.5, 3.5]
print(doubles.sum()) // 输出: 7.5

// 这不起作用，因为 String 不是 Numeric
// let strings = ["a", "b", "c"]
// print(strings.sum()) // 错误：字符串数组无法调用 'sum'

扩展不仅限于添加功能；它们对于代码组织也很有用。我们可以在单独的扩展中对相关的方法、属性或视图进行分组。

import SwiftUI

struct HomeView: View {
    var body: some View {
        ScrollView {
            header
            // 添加其他视图
        }
    }
}

extension HomeView {
    private var header: some View {
        Text("页眉 ...")
    }
}

#Preview {
    HomeView()
}

Swift 中的泛型是一项功能，允许我们创建可以与任何数据类型一起工作的函数、类、结构体和协议。

泛型使我们能够编写清晰简洁的代码，该代码可与任何数据类型一起工作。通过使用占位符（如 T），这降低了引入错误的风险。

struct Box<T> {
    var value: T
}
let intBox = Box(value: 10)
let stringBox = Box(value: "Hello")

print(intBox.value) // 输出: 10
print(stringBox.value) // 输出: "Hello"

func sum<T: Numeric>(_ array: [T]) -> T {
    array.reduce(0, +)
}

print(sum([1, 1.5, 2])) // 输出: 4.5

// 这不起作用，因为 String 不是 Numeric
// print(sum(["a", "b", "c"]))
// 错误：函数 'sum' 要求 'String' 符合 'Numeric'

protocol Foo {
    associatedtype T
    func foo() -> T
}

关联类型用于协议中，以定义稍后将指定的类型的占位符。它们充当泛型占位符。确切的类型未在协议本身中定义；相反，它是在类、结构体或枚举符合协议时确定的。

泛型类型别名允许我们为现有类型创建一个新名称（即，它们不会引入新类型）。

typealias StringDictionary<T> = [String: T]
typealias IntFunction<T> = (Int) -> Int // 这里的 T 似乎未使用，应为 (T) -> T 或 (Int) -> T
typealias Vector<T> = (T, T, T)