博客
关于我
强烈建议你试试无所不能的chatGPT,快点击我
Swift 泛型
阅读量:6464 次
发布时间:2019-06-23

本文共 4770 字,大约阅读时间需要 15 分钟。

前言

  • 在 Swift 语言中,泛型可以说是用的最广最强大的特性之一,因为在 Swift 语言本身的语言底层大量的使用了泛型。

  • 泛型使得同样的操作可以应用于不同的数据类型。

    • 泛型编程的实现是我们程序在另一种抽象层次上的提升。
    • 类是现实世界事物的抽象,而泛型则是现实世界行为的抽象。

1、节点泛型

  • Swift 中的泛型同其它语言相同,用一对尖括号 < > 来声明泛型,尖括号中通常使用 TUV 等这样的大写字母来表示 “节点” 类型。

  • 使用泛型作为参数的函数叫做泛型函数。

    • 泛型函数在声明时使用节点类型命名来替代实际的类型名,并在泛型函数名后面插入节点类型的声明。
    • 节点类型在定义时不表示任何具体类型,在函数被调用时会根据传入的实际类型来指定自身的类型。

      func 函数名
      (参数名1: T, 参数名2: T, ...) -> T { 函数体 ..... return 返回值}
  • 1)如果函数的列表中只有一个字母,如 T,虽然具体的类型不需要指定,但是函数中每个节点类型的参数(函数参数或返回值类型)必须是相同类型的。

    func show
    (para1: T, para2: T) { print("\(para1)" + " \(para2)")}
    // 在调用时两个参数必须是相同的show(para1: 1, para2: 2)                        // 1 2show(para1: "xiaoming", para2: "xiaobai")       // xiaoming xiaobai
  • 2)如果要定义多个不同类型的泛型,则需要在尖括号中加入多个节点 <T, U, V ...>

    func show
    (para1: T, para2: U) { print("\(para1)" + " \(para2)")}
    // 在调用时两个参数可以不同show(para1: "xiaoming", para2: 18) // xiaoming 18
  • 3)你还可以对节点进行一些限制,比如要求泛型遵守某些协议。

    // Swift 中数组的判等函数public func ==
    (lhs: [Element], rhs: [Element]) -> Bool {...}
    • Element 是使用节点声明的,它代表一个泛型,可以看到这里的泛型名是 Element,相比上面的 TUV 等要长的多。这是因为此处的 Element 不仅仅是一个占位符的作用,它还声明了这个泛型代表数组中的元素类型,具有具体的意义。
  • 4)有时候节点中的泛型需要有更多的限制,需要使用 where 子句来补充约束条件。

    • 在 Swift 3.0 之前。

      func anyCommonElements
      (lhs: T, _ rhs: U) -> Bool { ...}
    • 在 Swift 3.0 及之后 where 子句被移动到了参数列表的后面。

      func anyCommonElements
      (lhs: T, _ rhs: U) -> Bool where T.Generator.Element: Equatable, T.Generator.Element == U.Generator.Element{ ...}

2、泛型协议

  • 1)除了节点式声明泛型外,还有其它方式声明一个泛型,比如使用关键字 associatedtype(关联类型)(Swift 3.0 之前是 typealias 关键字)。

    protocol SomeProtocol {    associatedtype Element    func elementMethod1(element: Element)    func elementMethod2(element: Element)}
    • 这里虽然没有出现节点语法,但上面的协议确实是个不折不扣的泛型协议,Element 起到了占位符的作用,指示了某种类型。
    • 根据协议的规则,协议 SomeProtocol 的遵守者必须实现上面两个方法,Element 隐式的约束了两个方法的参数必须是相同类型的。
    • 不用刻意指定 Element 的具体类型,编译器会根据实现方法时传入的参数类型确定 Element 的具体类型。
    • 在实现的时候不能直接用 ElementElement 只能存在于具体实现之前。泛型协议依靠遵守协议中协议方法的的具体实现来明确泛型的类型。
    • 协议的遵守者如果遵守了多个协议,那么这些协议的关联类型名称不能重复,否则编译器会报错。

      struct TestStruct: SomeProtocol {    func elementMethod1(element: String) {        print("elementFromMethod1: \(element)")    }    func elementMethod2(element: String) {        print("elementFromMethod2: \(element)")    }}
      TestStruct().elementMethod1(element: "qwert")   // elementFromMethod1: qwertTestStruct().elementMethod2(element: "asdfg")   // elementFromMethod2: asdfg
  • 2)类似于 associatedtype 的还有 Self 关键字,代表了协议遵守者本身的的类型,适用于 “比较” 这类方法,其必须传入另一个相同类型的参数才有意义。

    protocol CanCompare {    func isBigger(other: Self) -> Bool}
    struct BoxInt: CanCompare {    var intValue: Int    func isBigger(other: BoxInt) -> Bool {        return self.intValue > other.intValue    }}
    BoxInt(intValue: 3).isBigger(other: BoxInt(intValue: 2))    // true

3、泛型对象

  • 关联类型和 Self 关键字都是在协议层面的泛型,此外还有对象层面的泛型,比如我们常用的数组就是对象层面的泛型定义的,效果相同。

  • 如果不使用协议,一个泛型对象风格的结构体定义如下。

    struct TestStruct
    { func elementMethod1(element: T) { print("elementFromMethod1: \(element)") } func elementMethod2(element: T) { print("elementFromMethod2: \(element)") }}
    • 泛型应该用在声明中,调用时版本中的泛型已经被 “特化” 成具体的泛型。泛型对象通过构造器初始化时明确明确泛型的类型,这些类型都是具体的。
    • 如果在实现时 “嵌套” 一个泛型,那么会导致泛型无法特化。比如数组本身是泛型的,在声明数组类型时传入了另一个泛型,那么你将无法初始化该数组。

      let test = TestStruct
      ()test.elementMethod1(1)

4、泛型方法

  • 方法中的泛型使用节点表示法,作用域只在本方法内。

    struct TestStruct {    func elementMethod1
    (element: T) { print("elementFromMethod1: \(element)") } func elementMethod2
    (element: T) { print("elementFromMethod2: \(element)") }}
    • 这样同一个实例的相同方法就可以接受不同的参数类型了。

      let test = TestStruct()test.elementMethod1(element: 1)test.elementMethod1(element: "abc")

5、协议中的 where 关键字

  • where 关键字可以与 for-in 循环配合实现筛选,where 同样可以用在协议扩展中,使得定义在协议扩展中的方法可以对某些遵守者 “隐身”,而对另一些遵守者 “可见”。

  • 协议的遵守者如果遵守了多个协议,那么这些协议的关联类型名称不能重复,否则编译器会报错。

    protocol SomeProtocol {    associatedtype OwnElement    func elementMethod1(element: OwnElement)    func elementMethod2(element: OwnElement)}
  • 1)where 关键字可以与 Self 关键字配合,在协议扩展中定义一个新方法,指定当协议的遵守者是集合类型时,必须打印出遵守者的元素个数。

    extension SomeProtocol where Self: Collection {    func showCount() {        print(self.count)    }}
    • where 的限制是强制的,他是一个编译器强制的开关。虽然在协议的扩展中并不能知晓会有哪些对象遵守了该协议,但是一旦使用了 where,那么就表明在扩展的作用域中 where 后面的语句默认实现了。
    • Array 类型已经遵守了 Collection 协议,所以如果让 Array 同时遵守 SomeProtocol,那么它就能获得 showCount 方法。

      extension Array: SomeProtocol {    func elementMethod1(element: String) {        print("elementFromMethod1: \(element)")    }    func elementMethod2(element: String) {        print("elementFromMethod2: \(element)")    }}
      [1, 2, 3].showCount()       // 3
  • 2)where 所指定的力度范围还可以继续缩小,可以使用 where 限定协议中的关联类型。

    extension SomeProtocol where OwnElement: SignedNumeric {    func showElement() {        print(OwnElement.self)    }}

转载地址:http://yghzo.baihongyu.com/

你可能感兴趣的文章
幸福框架:可扩展的、动态的、万能的 编号生成器
查看>>
黄聪:PHP 防护XSS,SQL,代码执行,文件包含等多种高危漏洞
查看>>
svn status 显示 ~xx
查看>>
常用HiveQL总结
查看>>
[转]使用Visual Studio Code开发Asp.Net Core WebApi学习笔记(三)-- Logger
查看>>
POJ 3311 Hie with the Pie(状压DP + Floyd)
查看>>
HDU 1402 A * B Problem Plus FFT
查看>>
[CareerCup] 17.3 Factorial Trailing Zeros 求阶乘末尾零的个数
查看>>
Security updates and resources
查看>>
深入理解JavaScript系列(25):设计模式之单例模式
查看>>
DNS为什么通常都会设置为14.114.114.114
查看>>
给定一个序列,判断该序列是否为二叉树查找树的后序遍历序列
查看>>
Sqoop架构(四)
查看>>
golang copy函数
查看>>
《你有多少问题要请示》精华集粹
查看>>
深度 | 机器学习敲门砖:任何人都能看懂的TensorFlow介绍【转】
查看>>
leveldb学习:DBimpl
查看>>
MySQL存储引擎--MYSIAM和INNODB引擎区别
查看>>
[Recompose] Stream Props to React Children with RxJS
查看>>
打印图片
查看>>