区块链技术博客
www.b2bchain.cn

Swift 泛型详解求职学习资料

本文介绍了Swift 泛型详解求职学习资料,有助于帮助完成毕业设计以及求职,是一篇很好的资料。

对技术面试,学习经验等有一些体会,在此分享。

泛型是为Swift编程灵活性的一种语法,在函数、枚举、结构体、类中都得到充分的应用,它的引入可以起到占位符的作用,当类型暂时不确定的,只有等到调用函数时才能确定具体类型的时候可以引入泛型。
例如:Swift的Array和Dictionary类型都是泛型集。

var strs = [String]() var nums = [Int]() var dics = [String: String]()

一、泛型函数

函数参数或返回值类型用泛型表示

// 泛型函数定义式 func 函数名<泛型1,泛型2,…>(形参列表)->返回值类型 {     // 函数体... }

示例

/// 泛型函数 /// - Returns: 泛型函数返回类型 func swapObjects<T>(_ object1: inout T, _ object2: inout T) -> Void {     let temp = object1     object1 = object2     object2 = temp }  func testSwapObjects() {     var a = "hello"     var b = "world"     print("swap before is (a) (b)")     swapObjects(&a, &b)     print("swap after is (a) (b)") }  输出 swap before is hello world swap after is world hello

二、泛型类型

在定义类型时使用泛型,类型名后面加上<泛型1,泛型2,…>,然后在类型里面直接使用泛型即可

下面实现如何写一个泛型集类型–Stack(栈)。
栈是一系列值域的集合,和Array(数组)类似,但栈是一个比 Swift 的Array类型更多限制的集合。一个数组可以允许其里面任何位置的插入/删除操作,而栈,只允许在集合的末端添加新的项,如push一个新值进栈,同样的只能从末端移除项,如同pop一个值出栈,即先进后出原则,。

这里展示了如何写一个泛型版本的栈:

/// 泛型类型 /// 在swift中, struct 和 enum 是值类型,默认情况下,实例方法是不可以修改值类型的属性,使用mutating修饰后可修改属性的值 /// class 是引用类型,默认情况下就可以修改属性值,不需要使用mutating修饰  struct Stack<T> {     var items = [T]()     mutating func push(_ item: T) {         items.append(item)     }      mutating func pop() -> T {         return items.removeLast()     } }  /// 扩展一个泛型类型 /// 添加了一个名为top的只读计算属性,它将会返回当前栈顶端的元素而不会将其从栈中移除。 extension Stack {     var top: T? {         return items.last     } }  func testStackT() {     var stringStack = Stack<String>()     print("栈顶元素是: (String(describing: stringStack.top))")     stringStack.push("ObjectC")     stringStack.push("Swift")     stringStack.push("Java")     stringStack.push("Python")     print(stringStack.items)     _ = stringStack.pop()     print(stringStack.items)     print("栈顶元素是: (String(describing: stringStack.top))") }  输出 栈顶元素是: nil ["ObjectC", "Swift", "Java", "Python"] ["ObjectC", "Swift", "Java"] 栈顶元素是: Optional("Java")

三、泛型约束

继承约束,泛型类型必须是某个类的子类类型
协议约束,泛型类型必须遵循某些协议
条件约束,泛型类型必须满足某种条件

继承约束使用格式
func 函数名<泛型: 继承父类>(参数列表) -> 返回值 {
// 函数体,泛型类型是某个类的子类类型
}

继承约束使用示例

class Person {     func work() {         print("Person work")     } }  class Teacher: Person {     override func work() {         print("Teacher work")     } }  class Doctor: Person {     override func work() {         print("Doctor work")     } }  func testWhoWork<T: Person>(p: T) {     p.work() }  testWhoWork(p: Teacher()) testWhoWork(p: Doctor())  输出 Teacher work Doctor work

四、泛型协议

协议约束使用格式
func 函数名<泛型: 协议>(参数列表) -> 返回值 {
// 函数体,泛型类型遵循某些协议
}

协议约束使用范例
Swift标准库中定义了一个Equatable协议,该协议要求任何遵循的类型实现等式符(==)和不等符(!=)对任何两个该类型进行比较。所有的Swift标准类型自动支持Equatable协议。

协议约束示例

/// 定义泛型函数,为泛型添加协议约束,泛型类型必须遵循Equatable协议 func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {     var index = 0     for value in array {         if value == valueToFind {             return index         } else {             index += 1         }     }     return nil }  func testFindIndex() {     let stringIndex = findIndex(array: ["Mike", "John", "Kevin"], valueToFind: "Kevin")     if let index = stringIndex {         print("Kevin 的索引值是:(index)")     } else {         print("Kevin 不存在")     } }  输出 Kevin 的索引值是:2

条件约束使用格式
func 函数名<泛型1, 泛型2>(参数列表)where 条件 -> 返回值 {
// 函数体,泛型类型满足某些条件
}

Equatable协议实际上不是普通的协议,而是泛型协议,假设泛型类型必须遵循一个协议,此时就必须在协议中引入一个关联类型来解决。

如下示例:

//定义一个结构体类型,实现Stackable协议 struct MyStack<T>: Stackable {     var items = [T]()     mutating func push(_ item: T) {         items.append(item)     }      mutating func pop() -> T {         return items.removeLast()     } }  // 定义另外一个结构体类型,同样实现Stackable协议,实际上里面的实现和Stack一样 struct OtherStack<T>: Stackable {     var items = [T]()     mutating func push(_ item:T) {         items.append(item)     }     mutating func pop() -> T {         return items.removeLast()     } }  func pushItemOneToTwo<C1: Stackable, C2: Stackable>( stackOne: inout C1, stackTwo: inout C2) where C1.ItemType == C2.ItemType {     // 因为C1和C2都遵循了Stackable协议,才有ItemType属性可以调用     let item = stackOne.pop()     stackTwo.push(item) }   func testMyStack() {     var stackOne = MyStack<String>()     stackOne.push("hello")     stackOne.push("swift")     stackOne.push("world")     let t = stackOne.pop()     print("t = (t)")      var stackTwo = OtherStack<String>()     stackTwo.push("where")      pushItemOneToTwo(stackOne: &stackOne, stackTwo: &stackTwo)     print("stackOne = (stackOne.items), stackTwo = (stackTwo.items)") }  输出 t = world stackOne = ["hello"], stackTwo = ["where", "swift"]

泛型是为Swift编程灵活性的一种语法,在函数、枚举、结构体、类中都得到充分的应用,它的引入可以起到占位符的作用,当类型暂时不确定的,只有等到调用函数时才能确定具体类型的时候可以引入泛型。
例如:Swift的Array和Dictionary类型都是泛型集。

var strs = [String]() var nums = [Int]() var dics = [String: String]()

一、泛型函数

函数参数或返回值类型用泛型表示

// 泛型函数定义式 func 函数名<泛型1,泛型2,…>(形参列表)->返回值类型 {     // 函数体... }

示例

/// 泛型函数 /// - Returns: 泛型函数返回类型 func swapObjects<T>(_ object1: inout T, _ object2: inout T) -> Void {     let temp = object1     object1 = object2     object2 = temp }  func testSwapObjects() {     var a = "hello"     var b = "world"     print("swap before is (a) (b)")     swapObjects(&a, &b)     print("swap after is (a) (b)") }  输出 swap before is hello world swap after is world hello

二、泛型类型

在定义类型时使用泛型,类型名后面加上<泛型1,泛型2,…>,然后在类型里面直接使用泛型即可

下面实现如何写一个泛型集类型–Stack(栈)。
栈是一系列值域的集合,和Array(数组)类似,但栈是一个比 Swift 的Array类型更多限制的集合。一个数组可以允许其里面任何位置的插入/删除操作,而栈,只允许在集合的末端添加新的项,如push一个新值进栈,同样的只能从末端移除项,如同pop一个值出栈,即先进后出原则,。

这里展示了如何写一个泛型版本的栈:

/// 泛型类型 /// 在swift中, struct 和 enum 是值类型,默认情况下,实例方法是不可以修改值类型的属性,使用mutating修饰后可修改属性的值 /// class 是引用类型,默认情况下就可以修改属性值,不需要使用mutating修饰  struct Stack<T> {     var items = [T]()     mutating func push(_ item: T) {         items.append(item)     }      mutating func pop() -> T {         return items.removeLast()     } }  /// 扩展一个泛型类型 /// 添加了一个名为top的只读计算属性,它将会返回当前栈顶端的元素而不会将其从栈中移除。 extension Stack {     var top: T? {         return items.last     } }  func testStackT() {     var stringStack = Stack<String>()     print("栈顶元素是: (String(describing: stringStack.top))")     stringStack.push("ObjectC")     stringStack.push("Swift")     stringStack.push("Java")     stringStack.push("Python")     print(stringStack.items)     _ = stringStack.pop()     print(stringStack.items)     print("栈顶元素是: (String(describing: stringStack.top))") }  输出 栈顶元素是: nil ["ObjectC", "Swift", "Java", "Python"] ["ObjectC", "Swift", "Java"] 栈顶元素是: Optional("Java")

三、泛型约束

继承约束,泛型类型必须是某个类的子类类型
协议约束,泛型类型必须遵循某些协议
条件约束,泛型类型必须满足某种条件

继承约束使用格式
func 函数名<泛型: 继承父类>(参数列表) -> 返回值 {
// 函数体,泛型类型是某个类的子类类型
}

继承约束使用示例

class Person {     func work() {         print("Person work")     } }  class Teacher: Person {     override func work() {         print("Teacher work")     } }  class Doctor: Person {     override func work() {         print("Doctor work")     } }  func testWhoWork<T: Person>(p: T) {     p.work() }  testWhoWork(p: Teacher()) testWhoWork(p: Doctor())  输出 Teacher work Doctor work

四、泛型协议

协议约束使用格式
func 函数名<泛型: 协议>(参数列表) -> 返回值 {
// 函数体,泛型类型遵循某些协议
}

协议约束使用范例
Swift标准库中定义了一个Equatable协议,该协议要求任何遵循的类型实现等式符(==)和不等符(!=)对任何两个该类型进行比较。所有的Swift标准类型自动支持Equatable协议。

协议约束示例

/// 定义泛型函数,为泛型添加协议约束,泛型类型必须遵循Equatable协议 func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {     var index = 0     for value in array {         if value == valueToFind {             return index         } else {             index += 1         }     }     return nil }  func testFindIndex() {     let stringIndex = findIndex(array: ["Mike", "John", "Kevin"], valueToFind: "Kevin")     if let index = stringIndex {         print("Kevin 的索引值是:(index)")     } else {         print("Kevin 不存在")     } }  输出 Kevin 的索引值是:2

条件约束使用格式
func 函数名<泛型1, 泛型2>(参数列表)where 条件 -> 返回值 {
// 函数体,泛型类型满足某些条件
}

Equatable协议实际上不是普通的协议,而是泛型协议,假设泛型类型必须遵循一个协议,此时就必须在协议中引入一个关联类型来解决。

如下示例:

//定义一个结构体类型,实现Stackable协议 struct MyStack<T>: Stackable {     var items = [T]()     mutating func push(_ item: T) {         items.append(item)     }      mutating func pop() -> T {         return items.removeLast()     } }  // 定义另外一个结构体类型,同样实现Stackable协议,实际上里面的实现和Stack一样 struct OtherStack<T>: Stackable {     var items = [T]()     mutating func push(_ item:T) {         items.append(item)     }     mutating func pop() -> T {         return items.removeLast()     } }  func pushItemOneToTwo<C1: Stackable, C2: Stackable>( stackOne: inout C1, stackTwo: inout C2) where C1.ItemType == C2.ItemType {     // 因为C1和C2都遵循了Stackable协议,才有ItemType属性可以调用     let item = stackOne.pop()     stackTwo.push(item) }   func testMyStack() {     var stackOne = MyStack<String>()     stackOne.push("hello")     stackOne.push("swift")     stackOne.push("world")     let t = stackOne.pop()     print("t = (t)")      var stackTwo = OtherStack<String>()     stackTwo.push("where")      pushItemOneToTwo(stackOne: &stackOne, stackTwo: &stackTwo)     print("stackOne = (stackOne.items), stackTwo = (stackTwo.items)") }  输出 t = world stackOne = ["hello"], stackTwo = ["where", "swift"]

泛型是为Swift编程灵活性的一种语法,在函数、枚举、结构体、类中都得到充分的应用,它的引入可以起到占位符的作用,当类型暂时不确定的,只有等到调用函数时才能确定具体类型的时候可以引入泛型。
例如:Swift的Array和Dictionary类型都是泛型集。

var strs = [String]() var nums = [Int]() var dics = [String: String]()

一、泛型函数

函数参数或返回值类型用泛型表示

// 泛型函数定义式 func 函数名<泛型1,泛型2,…>(形参列表)->返回值类型 {     // 函数体... }

示例

/// 泛型函数 /// - Returns: 泛型函数返回类型 func swapObjects<T>(_ object1: inout T, _ object2: inout T) -> Void {     let temp = object1     object1 = object2     object2 = temp }  func testSwapObjects() {     var a = "hello"     var b = "world"     print("swap before is (a) (b)")     swapObjects(&a, &b)     print("swap after is (a) (b)") }  输出 swap before is hello world swap after is world hello

二、泛型类型

在定义类型时使用泛型,类型名后面加上<泛型1,泛型2,…>,然后在类型里面直接使用泛型即可

下面实现如何写一个泛型集类型–Stack(栈)。
栈是一系列值域的集合,和Array(数组)类似,但栈是一个比 Swift 的Array类型更多限制的集合。一个数组可以允许其里面任何位置的插入/删除操作,而栈,只允许在集合的末端添加新的项,如push一个新值进栈,同样的只能从末端移除项,如同pop一个值出栈,即先进后出原则,。

这里展示了如何写一个泛型版本的栈:

/// 泛型类型 /// 在swift中, struct 和 enum 是值类型,默认情况下,实例方法是不可以修改值类型的属性,使用mutating修饰后可修改属性的值 /// class 是引用类型,默认情况下就可以修改属性值,不需要使用mutating修饰  struct Stack<T> {     var items = [T]()     mutating func push(_ item: T) {         items.append(item)     }      mutating func pop() -> T {         return items.removeLast()     } }  /// 扩展一个泛型类型 /// 添加了一个名为top的只读计算属性,它将会返回当前栈顶端的元素而不会将其从栈中移除。 extension Stack {     var top: T? {         return items.last     } }  func testStackT() {     var stringStack = Stack<String>()     print("栈顶元素是: (String(describing: stringStack.top))")     stringStack.push("ObjectC")     stringStack.push("Swift")     stringStack.push("Java")     stringStack.push("Python")     print(stringStack.items)     _ = stringStack.pop()     print(stringStack.items)     print("栈顶元素是: (String(describing: stringStack.top))") }  输出 栈顶元素是: nil ["ObjectC", "Swift", "Java", "Python"] ["ObjectC", "Swift", "Java"] 栈顶元素是: Optional("Java")

三、泛型约束

继承约束,泛型类型必须是某个类的子类类型
协议约束,泛型类型必须遵循某些协议
条件约束,泛型类型必须满足某种条件

继承约束使用格式
func 函数名<泛型: 继承父类>(参数列表) -> 返回值 {
// 函数体,泛型类型是某个类的子类类型
}

继承约束使用示例

class Person {     func work() {         print("Person work")     } }  class Teacher: Person {     override func work() {         print("Teacher work")     } }  class Doctor: Person {     override func work() {         print("Doctor work")     } }  func testWhoWork<T: Person>(p: T) {     p.work() }  testWhoWork(p: Teacher()) testWhoWork(p: Doctor())  输出 Teacher work Doctor work

四、泛型协议

协议约束使用格式
func 函数名<泛型: 协议>(参数列表) -> 返回值 {
// 函数体,泛型类型遵循某些协议
}

协议约束使用范例
Swift标准库中定义了一个Equatable协议,该协议要求任何遵循的类型实现等式符(==)和不等符(!=)对任何两个该类型进行比较。所有的Swift标准类型自动支持Equatable协议。

协议约束示例

/// 定义泛型函数,为泛型添加协议约束,泛型类型必须遵循Equatable协议 func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {     var index = 0     for value in array {         if value == valueToFind {             return index         } else {             index += 1         }     }     return nil }  func testFindIndex() {     let stringIndex = findIndex(array: ["Mike", "John", "Kevin"], valueToFind: "Kevin")     if let index = stringIndex {         print("Kevin 的索引值是:(index)")     } else {         print("Kevin 不存在")     } }  输出 Kevin 的索引值是:2

条件约束使用格式
func 函数名<泛型1, 泛型2>(参数列表)where 条件 -> 返回值 {
// 函数体,泛型类型满足某些条件
}

Equatable协议实际上不是普通的协议,而是泛型协议,假设泛型类型必须遵循一个协议,此时就必须在协议中引入一个关联类型来解决。

如下示例:

//定义一个结构体类型,实现Stackable协议 struct MyStack<T>: Stackable {     var items = [T]()     mutating func push(_ item: T) {         items.append(item)     }      mutating func pop() -> T {         return items.removeLast()     } }  // 定义另外一个结构体类型,同样实现Stackable协议,实际上里面的实现和Stack一样 struct OtherStack<T>: Stackable {     var items = [T]()     mutating func push(_ item:T) {         items.append(item)     }     mutating func pop() -> T {         return items.removeLast()     } }  func pushItemOneToTwo<C1: Stackable, C2: Stackable>( stackOne: inout C1, stackTwo: inout C2) where C1.ItemType == C2.ItemType {     // 因为C1和C2都遵循了Stackable协议,才有ItemType属性可以调用     let item = stackOne.pop()     stackTwo.push(item) }   func testMyStack() {     var stackOne = MyStack<String>()     stackOne.push("hello")     stackOne.push("swift")     stackOne.push("world")     let t = stackOne.pop()     print("t = (t)")      var stackTwo = OtherStack<String>()     stackTwo.push("where")      pushItemOneToTwo(stackOne: &stackOne, stackTwo: &stackTwo)     print("stackOne = (stackOne.items), stackTwo = (stackTwo.items)") }  输出 t = world stackOne = ["hello"], stackTwo = ["where", "swift"]

部分转自互联网,侵权删除联系

赞(0) 打赏
部分文章转自网络,侵权联系删除b2bchain区块链学习技术社区 » Swift 泛型详解求职学习资料
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

b2b链

联系我们联系我们