可信赖的昆明网站建设,云服务器建设网站,网站编写语言什么好,云南企业建站目录
一、数据类型
1. 流程控制
2. 访问控制
3. 功能修饰词
4. 错误处理
5. 泛型和类型
6. 其它关键字
二、部分关键字说明
1. guard
2. class 和 struct
struct#xff08;结构体#xff09;
class#xff08;类#xff09;
使用场景
3. mutating
4. proto…目录
一、数据类型
1. 流程控制
2. 访问控制
3. 功能修饰词
4. 错误处理
5. 泛型和类型
6. 其它关键字
二、部分关键字说明
1. guard
2. class 和 struct
struct结构体
class类
使用场景
3. mutating
4. protocol
定义协议
遵循协议
继承协议
协议作为类型
协议组合
5. extension
6. weak和strong
Strong
Weak
Unowned 官网Documentationhttps://docs.swift.org/swift-book/documentation/the-swift-programming-language/guidedtour
一、数据类型 class: 定义一个类
enum: 定义一个枚举
struct: 定义一个结构体
protocol: 定义一个协议 typealias: 定义一个类型别名
var: 定义一个变量
let: 定义一个常量
func: 定义一个函数 1. 流程控制 if: 条件语句
else: 条件语句的另一部分
switch: 多选择语句
case: switch 语句中的一个分支
for: for-loop循环语句
in: for-loop 中用于区间或集合的遍历
while: while-loop循环语句
repeat: do-while-loop 的开始部分
do: do-while 或 do-catch 的开始部分
break: 跳出循环或 switch 语句
continue: 跳过当前循环的其余部分进行下一次循环 2. 访问控制
public: 可以被任何地方访问
internal: 只能在当前模块内访问
fileprivate: 只能在当前文件内访问
private: 只能在当前声明里和扩展中访问 3. 功能修饰词
static: 静态方法或属性
class: 类方法或属性可以被子类重写的 static
dynamic: 允许动态派发
final: 阻止子类重写
mutating: 允许值类型的方法修改其所属实例
nonmutating: 标记方法在改变值类型属性时不会改变它的状态
lazy: 延迟加载属性直到第一次被调用
optional: 表示协议中的方法或属性是可选的 4. 错误处理
throw: 抛出一个错误
throws: 标记一个函数可能抛出错误
rethrows: 标记一个函数为仅当闭包参数抛出错误时才抛出错误
try: 调用可能抛出错误的函数
catch: 捕获并处理异常 5. 泛型和类型
associatedtype: 定义一个协议的关联类型
where: 指定类型约束条件
Any: 表示任意类型
Self: 表示类型本身 6. 其它关键字
import: 引入外部模块
return: 返回一个函数的结果
self: 指向实例自身
super: 指向父类
nil: 表示空值
true / false: 布尔值
defer: 代码块退出之前执行的代码
guard: 提供一种提前退出的方法 二、部分关键字说明
1. guard
guard 语句是一个用于条件检查的控制流结构它与 if 语句相似但有一些关键区别。guard 语句被设计用来提前退出一个函数、方法、循环等如果条件不满足的话。与 if 语句不同的是guard 语句要求你必须有一个 else 子句在其中退出当前的作用域通常使用 return、break、continue 或者 throw。
guard 语句有助于提高代码的清晰度和安全性因为它要求你在开始执行实际工作之前先处理错误情况或者缺少必要条件的情况。
guard 语句的一般形式是
guard 条件 else {// 如果条件不满足执行这里的代码// 必须退出当前作用域例如return, break, continue, throw
}// 如果条件满足继续执行后面的代码guard 的一个常见用例是提前检查方法的参数或者前置条件
func someFunction(value: Int?) {guard let unwrappedValue value else {print(Value must not be nil)return}// 使用 unwrappedValue 作为非可选类型
}在上面的例子中如果 value 是 nilguard 语句的 else 快将会被执行并且函数会提前退出。如果 value 不是 nilunwrappedValue 可以在 guard 语句之后安全地使用因为它已经被解包了。
guard 语句的另一个关键特性是它创建的常量或变量在上面的例子中是 unwrappedValue也可以在 guard 外面的代码块中使用这为它在 Swift 编程中提供了方便的可读性和安全性。 2. class 和 struct
class 和 struct 都是构建代码的基础结构但它们有几个关键区别。下面将介绍他们之间的不同之处
struct结构体
值类型当一个结构体实例被赋予一个变量或常量或者被传递给一个函数时实际上传递的是该实例的一个副本。堆栈分配由于它们是值类型除非需要否则结构体通常分配在堆栈上这通常会比堆分配更有效率。不支持继承结构体不能继承另一个结构体或类的特性。默认逐成员的初始化器在没有自定义初始化器的情况下结构体提供一个默认的初始化器可以通过它的属性名称直接初始化。
class类
引用类型当你为一个类实例赋值给一个变量或常量或者传递到一个函数时都是传递的同一个实例的引用。堆分配类的实例通常是在堆上分配的这允许更复杂的引用计数和回收策略。支持继承类可以从其他类继承方法属性和其他特性。需要显式的初始化器如果类的属性没有默认值则必须提供一个初始化器。可以有析构器类可以有 deinit 方法它会在类的实例被释放时调用。可以有多个引用一个类的实例可以有多个引用指向它即多个变量或常量可以同时引用同一个实例。引用计数由于类是引用类型Swift使用引用计数来跟踪和管理内存。
下面是一个 struct 和 class 的例子
// 定义一个结构体
struct Point {var x: Intvar y: Int
}// 定义一个类
class Vehicle {var numberOfWheels: Intinit(numberOfWheels: Int) {self.numberOfWheels numberOfWheels}
}// 创建结构体实例
var p1 Point(x: 10, y: 20)
// p2将是p1的一个全新副本
var p2 p1
p2.x 30 // 只会修改p2的x属性不会影响p1// 创建类实例
var car Vehicle(numberOfWheels: 4)
// truck和car引用的是同一个Vehicle实例
var truck car
truck.numberOfWheels 18 // 会改变car中的numberOfWheels因为他们指向同一个引用在Swift中结构体用得非常广泛Apple建议在可能的情况下优先使用结构体因为它们更加高效。只有在需要利用引用类型的特征如继承或生命周期管理时才使用类。 使用场景
在Swift中根据具体的设计模式和所需特性会有不同的场景适合使用class或struct。下面是一些指导原则帮助决定何时使用哪一个。
使用场景
使用struct的场景
struct通常用于封装少量简单数据值并且满足以下条件时更适宜使用
你想要的是值类型的行为也就是说你需要的是一个复制的副本而不是同一个实例的引用。你不需要使用到继承。实例是相对短暂的或只是数据载体。包含的数据用于表示一个对象的状态或实质内容。数据量较小例如一个坐标点(x, y)三维向量(x, y, z)。
使用class的场景
当以下条件满足时使用class可能会更好
你需要一个引用类型来共享数据或状态。需要利用类特有的特性如继承析构器引用计数。当对象的生命周期需要控制譬如单例模式或在管理资源时如文件句柄网络连接。当你要建模的实体需要有一个明确的身份概念因而两个实体即使属性相同也不被视为相等。
原则和建议
Swift官方文档建议默认使用struct因为它们更快。大多数情况下你应该从struct开始并在需要时迁移到class。这种优先使用struct的策略有以下好处
值类型更易于推理因为它们不会被意外更改。避免了内存泄漏和多线程的问题。有助于遵循函数式编程范式函数式编程范式强调不可变性和函数的纯粹性。
上面的建议是一个起点最终的决定还要考虑具体的应用场景和代码设计。例如使用UIKit时需要创建UIView的子类这必须用class因为UIKit中的所有视图元素都是以类的形式存在的。而在处理JSON数据模型时经常使用struct因为它们通常包含简单的数据属性没有必要使用继承或复杂的对象引用。 3. mutating
允许值类型的方法修改其所属实例
关键字 mutating 用于标记那些能修改结构体struct或枚举enum实例状态的方法。由于结构体和枚举是值类型Value Type当它们的实例方法尝试修改实例内部的值时需要用 mutating 关键字进行标识。
这里有个例子来演示如何使用 mutating 关键字
struct Point {var x: Intvar y: Int// 使用 mutating 关键字来允许这个方法修改结构体内的值mutating func moveBy(x deltaX: Int, y deltaY: Int) {x deltaXy deltaY}
}var point Point(x: 0, y: 0)
point.moveBy(x: 5, y: 5)
print(point) // 输出: Point(x: 5, y: 5)在这个例子中moveBy(x:y:) 方法前面有 mutating 关键字这个意味着它可以修改 Point 结构体的实例的 x 和 y 属性。如果你移除 mutating 关键字编译器将会给出一个错误因为方法尝试改变了结构体的成员变量而结构体没有被明确允许可以这样做。
需要注意的是当你尝试在一个常量 (let) 结构体实例上调用一个 mutating 方法时Swift 会给出编译错误。因为常量结构体的成员不能被改变就算是在其 mutating 方法中也不可以。 4. protocol
protocol 是一种定义一组方法、属性或其他要求的方式这组要求可以由类、结构体或枚举遵循实现。协议类似于其他编程语言中的接口interfaces它们声明了代码需遵守的规范但它们本身并不提供这些要求的实现。遵循或实现协议的类型必须实现这些要求除非要求是可选的。
协议可以要求遵循它的类型具有特定的实例属性和实例方法类方法运算属性以及下标。
下面是 protocol 的一些基本用法 定义协议
protocol SomeProtocol {// 定义属性要求var mustBeSettable: Int { get set }var doesNotNeedToBeSettable: Int { get }// 定义方法要求func someMethod()// 定义可变方法要求mutating func mutate()// 定义初始化器要求init(someParameter: Int)
}遵循协议
struct SomeStruct: SomeProtocol {var mustBeSettable: Intvar doesNotNeedToBeSettable: Intfunc someMethod() {// 实现协议中的方法}mutating func mutate() {// 实现协议中的可变方法}init(someParameter: Int) {// 实现协议中的初始化器mustBeSettable someParameterdoesNotNeedToBeSettable someParameter}
}继承协议
协议可以继承允许你在新协议中添加你自己的要求或修改父协议的行为。
protocol AnotherProtocol: SomeProtocol {// 新的要求func anotherMethod()
}协议作为类型
协议本身可以作为一个类型在函数、方法或集合等中使用这提供了极大的灵活性。
class SomeClass {// 使用协议作为属性的类型var delegate: SomeProtocol?func doSomething() {// 在需要的时候使用 delegatedelegate?.someMethod()}
}协议组合
你可以将多个协议组合在一起要求一个类型必须同时遵循所有的协议。
protocol Named {var name: String { get }
}protocol Aged {var age: Int { get }
}struct Person: Named, Aged {var name: Stringvar age: Int
}func wishHappyBirthday(to celebrator: Named Aged) {print(Happy birthday, \(celebrator.name), youre \(celebrator.age)!)
}let birthdayPerson Person(name: John, age: 20)
wishHappyBirthday(to: birthdayPerson)在上面的例子中Person 结构体遵循了 Named 和 Aged 协议。
协议是 Swift 语言的核心特性之一通过使用协议你的代码会更加灵活、解耦并且易于维护和扩展。 5. extension
extension: 扩展现有类型
extension 是一种强大的语言特性允许你为现有的类、结构体、枚举或者协议类型添加新功能。通过扩展你可以在不访问原始源代码的情况下增加新的计算属性、实例方法、类方法、初始化器、下标以及特定于协议的实现等。
扩展可以在同一文件或者不同文件中添加这为组织和模块化代码提供了极大的灵活性和便利。
// 假设这是你无法修改的原始类
class SomeType {var property: String Some Value
}// 使用扩展为 SomeType 添加新功能
extension SomeType {// 新的计算实例属性var propertyDescription: String {return The property value is \(property)}// 新的实例方法func describeProperty() {print(propertyDescription)}// 新的初始化器convenience init(customValue: String) {self.init()self.property customValue}
}let someInstance SomeType()
someInstance.describeProperty() // 调用扩展中的方法let customInstance SomeType(customValue: Custom Value)
print(customInstance.propertyDescription) // 调用扩展中的计算属性扩展的一些关键特点包括 计算属性: 扩展可以为已有类型添加计算实例属性和计算类型属性但它们不能添加存储属性或者为已有属性添加观察者。 方法添加: 扩展可以为已有类型添加新的实例方法和类方法。 构造器添加: 扩展可以为已有的类添加新的便利初始化器但不能添加新的指定初始化器或析构器。指定初始化器和析构器必须总是由原始的类实现来提供。 下标添加: 扩展可以为已有类型添加新的下标。 嵌套类型: 扩展可以为已有的类、结构体和枚举添加新的嵌套类型。 协议遵从性: 可以通过扩展让一个已有类型遵循一个或多个协议。如果这样做扩展必须实现协议所要求的方法。
扩展还可以添加新的泛型方法和条件遵循这为泛型编程提供了额外的灵活性。
请注意尽管扩展可以为类型添加新的功能但它们不允许重写已有功能。此外扩展不能访问类型的私有或文件私有成员除非扩展和类型都位于同一个文件中。 6. weak和strong
weak 和 strong 是两种不同的引用类型用于在内存管理中处理对象之间的关系。在 Swift 的内存管理中引用计数Reference Counting是被用来跟踪和管理应用中对象的生命周期的。
Strong
默认情况下当一个对象被另一个对象引用时它是一个强引用strong reference。一个强引用会让被引用的对象保持在内存中只要至少有一个强引用对象就不会被销毁。这保证了你能安全地访问和使用这个对象。
class ExampleClass {var property: Stringinit(property: String) {self.property property}
}var example: ExampleClass? ExampleClass(property: Hello)
// example 持有一个 ExampleClass 实例的强引用只要 example 变量存在它指向的 ExampleClass 实例的引用计数至少为 1因此不会被 ARCAutomatic Reference Counting 自动引用计数回收。
Weak
如果两个对象相互引用可能会创建一个循环引用使得它们永远不会被销毁。为此Swift 提供了 weak 引用。一个弱引用不会增加对象的引用计数这意味着它不会阻止 ARC 销毁被引用的对象。当对象被销毁时所有对它的弱引用自动变为 nil。
weak 引用需要被声明为可选类型因为其指向的对象可以随时被销毁。
class Person {let name: Stringvar apartment: Apartment?init(name: String) {self.name name}
}class Apartment {let unit: Stringweak var tenant: Person?init(unit: String) {self.unit unit}
}var john: Person?
var unit4A: Apartment?john Person(name: John)
unit4A Apartment(unit: 4A)john!.apartment unit4A
unit4A!.tenant johnjohn nil
unit4A nil在上面的例子中Person 和 Apartment 相互引用但由于 Apartment 中的 tenant 属性是弱引用 weak当我们设置 john 和 unit4A 为 nil 时它可以阻止循环引用并允许这两个对象被 ARC 销毁。
Unowned
unowned 引用与 weak 引用类似它也不增加对象的引用计数因此不会阻止被引用的对象被销毁。然而与 weak 引用不同的是unowned 引用假定它始终指向一个对象它不会变成 nil。因此unowned 引用总是被定义为非可选类型。
尽量在你可以确定引用始终指向一个未销毁的对象时使用 unowned。
class Customer {let name: Stringvar card: CreditCard?init(name: String) {self.name name}
}class CreditCard {let number: UInt64unowned let customer: Customerinit(number: UInt64, customer: Customer) {self.number numberself.customer customer}
}var customer: Customer? Customer(name: Alice)
customer!.card CreditCard(number: 1234567890123456, customer: customer!)customer nil // Customer 可以安全地被销毁因为没有 CreditCard 持有它的强引用在上面的例子中尽管 CreditCard 用 unowned 对 Customer 进行引用Customer 实例仍然可以被销毁因为它的 card 属性不是一个强引用。
使用 weak 和 unowned 引用的选择取决于你的具体场景你要确保不会无意间造成循环引用和内存泄漏。一般来说weak 是适合不能确定引用是否总会指向一个对象而 unowned 是适合引用总是指向对象并且对象的生命周期内总会存在的情况。
