跳到主要内容

Swift中的泛型

提示
  1. Swift 泛型函数和类：泛型允许创建可与多种数据类型一起使用的单一函数和类，例如 displayData<T>(data: T) 函数和 Information<T> 类。
  2. 泛型中的类型约束：可以通过类型约束限制泛型接受特定类型的数据，如 <T: Numeric> 仅允许数字类型。
  3. 泛型的优势：泛型增加了代码的可重用性，减少了重复代码，并在集合类型（如数组和字典）中广泛使用。

Swift 泛型允许我们创建单一的函数和类（或其他类型），这些函数和类可以与不同的数据类型一起使用。

这有助于我们重用代码。

Swift 泛型函数​

在 Swift 中，我们可以创建一个可用于任何数据类型的函数。这种函数被称为泛型函数。

以下是在 Swift 中创建泛型函数的方式：

// 创建一个泛型函数
func displayData<T>(data: T){
  ...
}

这里，

  • 我们创建了一个名为 displayData() 的泛型函数。
  • 尖括号 <> 中使用的 T 被称为类型参数。

根据传递给函数的值的类型，T 会被该数据类型（Int、String 等）替换。

注意：我们可以为类型参数提供任何名称：<S>、<Element> 等。但通常，我们使用 T。

示例：Swift 泛型函数​

  // 创建一个泛型函数
func displayData<T>(data: T) {
  print("泛型函数：")
  print("传递的数据：", data)
}

// 泛型函数处理 String
displayData(data: "Swift")

// 泛型函数处理 Int
displayData(data: 5)

输出

泛型函数：
传递的数据：Swift
泛型函数：
传递的数据：5

在上面的例子中，我们创建了一个名为 displayData() 的泛型函数，其类型参数为 <T>。

现在，当我们调用泛型函数

displayData(data: "Swift")

我们传递了一个字符串值，所以占位符参数 T 自动被 String 替换。

类似地，当我们将 Int 传递给泛型函数时

displayData(data: 5)

占位符被替换为 Int。

Swift 泛型类​

与泛型函数类似，我们也可以创建一个可以用于任何数据类型的类。这样的类被称为泛型类。

让我们看一个例子，

// 创建一个泛型类
class Information<T> {

  // T 类型的属性
  var data: T

  init (data: T) {
    self.data = data
  }

  // 返回 T 类型变量的方法
  func getData() -> T {
    return self.data
  }
}

// 使用 Int 数据初始化泛型类
var intObj = Information<Int>(data: 6)
print("泛型类返回：", intObj.getData())

// 使用 String 数据初始化泛型类
var strObj = Information<String>(data: "Swift")
print("泛型类返回：", strObj.getData())

输出 在上面的例子中，我们创建了一个名为 Information 的泛型类。这个类可以用来处理任何类型的数据。

class Information<T> {...}

我们创建了两个 Information 的对象：

var intObj = Information<Int>(data: 6)

var strObj = Information<String>(data: "Swift")

这里，

  1. intObj - 类型参数 T 被替换为 Int。现在，Information 类处理整数数据。
  2. strObj - 类型参数 T 被替换为 String。现在，Information 类处理字符串数据。

Swift 泛型中的类型约束​

通常，类型参数可以接受任何数据类型（Int、String、Double 等）。

然而，如果我们只想对某些特定类型（例如只接受数字类型的数据）使用泛型，那么我们可以使用类型约束。

以下是如何创建类型约束的方法：

func addition<T: Numeric>(num1: T, num2: T) {
  ...
}

这里，<T: Numeric> 向类型参数添加了约束。它定义了 T 需要遵守 Numeric 协议。

注意：Numeric 是内置的协议，适用于像 Int 和 Double 这样的数值类型。

示例：类型约束​

// 创建一个带有类型约束的泛型函数
func addition<T: Numeric>(num1: T, num2: T) {

  print("Sum:", num1 + num2)
}

// 传递 Int 值
addition(num1: 5, num2: 10)

// 传递 Double 值
addition(num1: 5.5, num2: 10.8)

输出

Sum: 15
Sum: 16.3

在上面的例子中，我们创建了一个名为 addition() 的泛型函数。注意表达式，

<T: Numeric>

这里，泛型函数是带有类型约束的。这意味着 addition() 只能与遵守 Numeric 协议的数据类型（如 Int、Double 等）一起工作。

注意：如果我们尝试传递其他类型，比如 String，我们将得到一个错误：argument type 'String' does not conform to the expected type 'Numeric'。

Swift 泛型的优势​

1. 代码可重用性​

借助 Swift 中的泛型，我们可以编写可以与不同类型的数据一起工作的代码。例如，

func genericFunction<T>(data: T) {...}

这里，我们创建了一个泛型函数。这个函数可以用来对整数数据、字符串数据等执行操作。

2. 用于集合​

Swift 数组使用了泛型的概念。例如，

// 创建一个整型数组
var list1: Array<Int> = []

// 创建一个字符串类型数组
var list2: Array<String> = []

这里，list1 数组存储 Int 值，list2 数组存储 String 值。

与数组类似，Swift 中的字典也是泛型的。

最后于 更新