Swift 5.9 知识整理 Done

本质上都是结构体

单独的类型，不是结构体

单独的类型，不是结构体

Array

Dictionary

Set

单独类型，非结构体

是什么

详见03、中的函数类型子分支

在 Swift 中，引用类型包括：

* 类
* 闭包
* 泛型类型
* 可变类型，例如 `var` 和 `let`

## 类

类是引用类型，因为它们是通过引用传递的。这意味着当您将类实例赋值给另一个变量或将其作为参数传递给函数时，将创建对该实例的引用。

以下是一些示例：

```swift
// 创建一个类实例
class Person {
  var name: String
  var age: Int

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

var person1 = Person(name: "John Doe", age: 30)

// 将类实例赋值给另一个变量
var person2 = person1

// 将类实例作为参数传递给函数
func printPerson(person: Person) {
  print(person.name)
  print(person.age)
}

printPerson(person: person1)
```

在此示例中，`person2` 是 `person1` 的引用。对 `person2` 所做的任何更改都会影响 `person1`。

## 闭包

闭包是引用类型，因为它们是通过引用传递的。这意味着当您将闭包赋值给另一个变量或将其作为参数传递给函数时，将创建对该闭包的引用。

以下是一些示例：

```swift
// 创建一个闭包
let closure = { (name: String) -> String in
  return "Hello, \(name)!"
}

// 将闭包赋值给另一个变量
let anotherClosure = closure

// 将闭包作为参数传递给函数
func printGreeting(closure: (String) -> String) {
  let greeting = closure("John Doe")
  print(greeting)
}

printGreeting(closure: closure)
```

在此示例中，`anotherClosure` 是 `closure` 的引用。对 `anotherClosure` 所做的任何更改都会影响 `closure`。

## 泛型类型

泛型类型是引用类型，因为它们是通过引用传递的。这意味着当您将泛型类型实例赋值给另一个变量或将其作为参数传递给函数时，将创建对该实例的引用。

以下是一些示例：

```swift
// 创建一个泛型类型实例
struct Array<T> {
  var elements: [T]

  init(elements: [T]) {
    self.elements = elements
  }
}

var array1 = Array(elements: [1, 2, 3])

// 将泛型类型实例赋值给另一个变量
var array2 = array1

// 将泛型类型实例作为参数传递给函数
func printArray(array: Array<Int>) {
  for element in array.elements {
    print(element)
  }
}

printArray(array: array1)
```

在此示例中，`array2` 是 `array1` 的引用。对 `array2` 所做的任何更改都会影响 `array1`。

## 可变类型

可变类型是引用类型，因为它们是通过引用传递的。这意味着当您将可变类型赋值给另一个变量或将其作为参数传递给函数时，将创建对该变量的引用。

以下是一些示例：

```swift
// 创建一个可变类型
var number = 1

// 将可变类型赋值给另一个变量
var anotherNumber = number

// 将可变类型作为参数传递给函数
func printNumber(number: Int) {
  print(number)
}

printNumber(number: number)
```

在此示例中，`anotherNumber` 是 `number` 的引用。对 `anotherNumber` 所做的任何更改都会影响 `number`。

## 总结

在 Swift 中，引用类型包括类、闭包、泛型类型和可变类型。引用类型是通过引用传递的，这意味着当您将引用类型赋值给另一个变量或将其作为参数传递给函数时，将创建对该类型的引用。

类型转换是指将一种类型的值转换为另一种类型的值的操作。类型转换可以分为隐式类型转换和显式类型转换。

**隐式类型转换**

隐式类型转换是指编译器自动执行的类型转换。在大多数情况下，隐式类型转换是安全的，因为编译器会确保转换后的值不会丢失精度或导致数据溢出。

以下是一些常见的隐式类型转换：

* 将较小的整数类型转换为较大的整数类型，例如将 `Int8` 转换为 `Int32`。
* 将浮点数类型转换为整数类型，例如将 `Int` 转换为 `Double`。
* 将字符类型转换为整数类型，例如将 `Character` 转换为 `UInt8`。

**显式类型转换**

显式类型转换是指程序员使用强制类型转换运算符（`as` 或 `as?`）来指定类型的转换。显式类型转换可以用于将一种类型的值转换为另一种类型，即使转换可能导致数据丢失或溢出。

以下是一些常见的显式类型转换：

* 将 `Int` 类型的值转换为 `String` 类型，例如：

```swift
let number = 10
let string = String(number)
```

* 将 `String` 类型的值转换为 `Int` 类型，例如：

```swift
let string = "10"
let number = Int(string)
```

**类型转换的注意事项**

* 在使用隐式类型转换时，需要注意转换后的值是否会丢失精度或导致数据溢出。
* 在使用显式类型转换时，需要注意转换是否安全，是否会导致数据丢失或溢出。
* 在使用类型转换时，需要考虑代码的可读性和可维护性。

**以下是一些使用类型转换的示例：**

```swift
// 将 Int 类型的值转换为 String 类型
let number = 10
let string = String(number)

// 将 String 类型的值转换为 Int 类型
let string = "10"
let number = Int(string)

// 将 Double 类型的值转换为 Int 类型
let doubleValue = 3.14
let intValue = Int(doubleValue) // 结果为 3

// 将 Int 类型的值转换为 Double 类型
let intValue = 10
let doubleValue = Double(intValue) // 结果为 10.0

// 使用 as? 进行类型转换
let string = "123"
let number = Int(string) // 隐式类型转换，结果为 123

let string2 = "abc"
let number2 = Int(string2) // 隐式类型转换，结果为 nil

let number3 = string2 as? Int // 显式类型转换，结果为 nil
```

**总结:**

* 类型转换是将一种类型的值转换为另一种类型的值的操作。
* 类型转换可以分为隐式类型转换和显式类型转换。
* 在使用类型转换时，需要注意转换是否安全，是否会导致数据丢失或溢出。
* 理解类型转换可以帮助您编写更优雅、更高效、更安全的 Swift 代码。

```在 Swift 中，将 Double 转换为 Int 有五种常见的方法：as和as?、构造方法、数学函数、自定义函数以及第三方库```

**1. 使用强制类型转换运算符 `as` 或 `as?`**

* `as` 运算符会将 Double 值转换为 Int 值，如果转换失败，则结果为 nil。
* `as?` 运算符会将 Double 值转换为 Int 值，如果转换失败，则结果为 nil。

**示例:**

```swift
let doubleValue: Double = 3.14

// 使用 as 运算符
let intValue = doubleValue as Int // 结果为 3

// 使用 as? 运算符
let intValue2 = doubleValue as? Int // 结果为 3

let doubleValue2: Double = "abc"

// 使用 as 运算符
let intValue3 = doubleValue2 as Int // 结果为 nil

// 使用 as? 运算符
let intValue4 = doubleValue2 as? Int // 结果为 nil
```

**2. 使用初始化器**

* 可以使用 Double 的初始化器将 Int 值转换为 Double 值。
示例:
```
Swift
let intValue: Int = 10

// 使用 Double 的初始化器
let doubleValue5 = Double(intValue) // 结果为 10.0
```

**3. 使用数学函数**

* 使用 `floor()` 函数可以将 Double 值向下取整为 Int 值。
* 使用 `ceil()` 函数可以将 Double 值向上取整为 Int 值。
* 使用 `round()` 函数可以将 Double 值四舍五入为 Int 值。

**示例:**

```swift
let doubleValue: Double = 3.14

// 使用 floor() 函数
let intValue5 = floor(doubleValue) // 结果为 3

// 使用 ceil() 函数
let intValue6 = ceil(doubleValue) // 结果为 4

// 使用 round() 函数
let intValue7 = round(doubleValue) // 结果为 3
```

**4. 使用自定义函数**

您可以定义一个自定义函数来执行 Double 到 Int 的转换。例如：

```swift
func doubleToInt(_ doubleValue: Double) -> Int {
  return Int(floor(doubleValue))
}

let doubleValue = 3.14

// 使用自定义函数
let intValue8 = doubleToInt(doubleValue) // 结果为 3
```

**5. 使用第三方库**

您可以使用第三方库来执行 Double 到 Int 的转换。例如，`Numeric` 库提供了一个 `toInt()` 方法可以将 Double 值转换为 Int 值。

```swift
import Numeric

let doubleValue = 3.14

// 使用第三方库
let intValue9 = doubleValue.toInt() // 结果为 3
```

**选择哪种方法取决于您的具体需求:**

* 如果您需要确保转换成功，请使用 `as` 运算符。
* 如果您需要处理转换失败的情况，请使用 `as?` 运算符。
* 如果您需要对 Double 值进行取整或四舍五入，请使用相应的数学函数。
* 如果您需要更复杂的转换逻辑，可以定义自定义函数。
* 如果您需要使用第三方库提供的功能，可以使用第三方库。

**总结:**

* 在 Swift 中，将 Double 转换为 Int 有多种方法。
* 选择哪种方法取决于您的具体需求。
* 理解如何将 Double 转换为 Int 可以帮助您编写更优雅、更高效、更安全的 Swift 代码。

**注意:**

* 将 Double 转换为 Int 时可能会丢失精度。
* 如果 Double 值太大或太小，转换可能会导致溢出。

[0...3]

[0..<3]

0...3

0..<3

单条件写法

多条件合并层写法：逗号隔开

单条件写法：guard let unwrapped = optinal else {}

多条件和并写法：逗号隔开

a??b

a是可选项

b是可选项或者不是可选项

b跟a的存储类型必须相同

如果a不为nil，就返回a

如果a为nil，就返回b

如果b不是可选项，返回a时会自动解包

多个?? 一起使用

??跟if let 配合使用：if let c = a ?? b {}

使用lazy可以定义一个延迟存储属性

延迟初始化

lazy属性必须是var，不能是let

不可以设置属性观察器

如果多条线程同时第一次访问lazy属性时，无法保证属性只被初始化1次

当结构体包含一个延迟存储属性时，只有var才能访问延迟存储属性

计算属性的值是可能发生变化，所以不可以使用let修饰

调用函数时，先复制实参的值，产生副本【get】

将副本的内存地址传入函数（副本进行引用传递），在函数内部可以修改副本的值

函数返回后，再将副本的值覆盖实参的值【set】

疑问，todo：产生了副本是什么意思，开辟新的空间了吗？

实例计算属性间接设置属性观察器。
操作静态和类属性同时添加属性观察器。

在Swift中，类属性（包括静态属性和类属性）是不能直接设置属性观察器的。属性观察器（`willSet` 和 `didSet`）只能用于实例属性。

如果你想要在类属性的值发生改变时执行某些操作，你可以使用计算属性和存储属性的组合，利用其中一个来存储值，另一个来提供属性观察器的功能。例如，你可以使用类方法来修改类属性，并在类方法中实现属性观察器的功能。

下面是一个示例，演示了如何通过类方法修改类属性，并在类方法中实现属性观察器的功能：

```swift
class MyClass {
    private static var _myClassProperty: Int = 0

    static var myClassProperty: Int {
        get {
            return _myClassProperty
        }
        set {
            // 在设置新值之前执行 willSet 观察器的功能
            willSet {
                print("Will set new value for myClassProperty: \(newValue)")
            }
            _myClassProperty = newValue
            // 在设置新值之后执行 didSet 观察器的功能
            didSet {
                print("Did set new value for myClassProperty: \(myClassProperty)")
            }
        }
    }

    static func updateClassProperty(newValue: Int) {
        myClassProperty = newValue
    }
}

MyClass.updateClassProperty(newValue: 10)
// 输出:
// Will set new value for myClassProperty: 10
// Did set new value for myClassProperty: 10
```

在上面的示例中，`MyClass` 类有一个私有的存储属性 `_myClassProperty` 用于存储类属性的值，然后通过 `myClassProperty` 计算属性来提供对外的访问接口，并在其中实现了属性观察器的功能。同时，类方法 `updateClassProperty` 用于修改类属性的值。

在 Swift 中，mutating 关键字用于在结构体（struct）或枚举（enum）的实例方法中修改它们的值。由于结构体和枚举是值类型，在默认情况下，你不能在它们的方法中直接修改它们的属性，因为方法内部操作的是值的副本。mutating 关键字允许你声明一个方法将修改调用它的结构体或枚举实例本身。
下面是一个使用 mutating 关键字的例子：
swift
复制代码
struct Point { 
    var x: Int 
    var y: Int 
     
    // 使用 mutating 关键字来声明一个可以修改 Point 实例的方法 
    mutating func moveBy(dx: Int, dy: Int) { 
        x += dx 
        y += dy 
    } 
} 
var point = Point(x: 1, y: 1) 
print("原始位置: (\(point.x), \(point.y))") // 输出: 原始位置: (1, 1) 
 
// 调用 moveBy 方法来修改 point 实例的 x 和 y 值 
point.moveBy(dx: 2, dy: 3) 
print("移动后的位置: (\(point.x), \(point.y))") // 输出: 移动后的位置: (3, 4)
在上面的例子中，我们定义了一个名为 Point 的结构体，它有两个属性 x 和 y。我们还定义了一个 moveBy 方法，并使用 mutating 关键字来标记它。这意味着这个方法会修改调用它的 Point 实例的 x 和 y 值。当我们创建一个 Point 实例 point 并调用 moveBy 方法时，point 的 x 和 y 值会被修改。
需要注意的是，mutating 关键字只能用于结构体和枚举的实例方法，而不能用于类（class）的实例方法，因为类是引用类型，它们的实例方法默认就可以修改实例的状态。此外，mutating 也不能用于静态方法或类方法，因为这些方法不与特定的实例关联。

直接存

移位存

增强指针存

直接取

移位如何取

增强指针如何取

普通的如何销毁

增强的如何销毁

示例

startIndex 、 endIndex 属性、index 方法

String、Array 都遵守了这个协议

pappend、insert、remove 方法

String、Array 都遵守了这个协议

如果你觉得String的API过于复杂难用，可以考虑将String转为NSString

String使用 == 运算符

NSString使用isEqual方法，也可以使用 == 运算符(本质还是调用了isEqual方法)

示例

示例

示例

示例

默认情况，extension不可以增加存储属性 

示例

示例2

示例3

示例

示例

示例

dispatch_once在Swift中已被废弃，取而代之 p可以用类型属性或者全局变量\常量

示例