Swift 泛型

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

这有助于我们重用代码。

Swift 泛型函数

在 Swift 中，我们可以创建一个可以与任何类型的数据一起使用的函数。这样的函数称为泛型函数。

以下是我们如何在 Swift 中创建泛型函数的方法：

// create a generic function
func displayData<T>(data: T){
  ...
}

这里，

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

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

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

示例：Swift 泛型函数

  // create a generic function
func displayData<T>(data: T) {
  print("Generic Function:")
  print("Data Passed:", data)
}

// generic function working with String
displayData(data: "Swift")

// generic function working with Int
displayData(data: 5)

输出

Generic Function:
Data Passed: Swift
Generic Function:
Data Passed: 5

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

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

displayData(data: "Swift")

我们传递了一个字符串值，因此占位符参数 T 会自动替换为 String。

同样，当我们向泛型函数传递 Int 时：

displayData(data: 5)

占位符会被替换为 Int。

Swift 泛型类

与泛型函数类似，我们还可以创建一个可以与任何类型的数据一起使用的类。这样的类称为 **泛型类**。

让我们看一个例子，

// create a generic class
class Information<T> {

  // property of T type
  var data: T

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

  // method that return T type variable
  func getData() -> T {
    return self.data
  }
}

// initialize generic class with Int data
var intObj = Information<Int>(data: 6)
print("Generic Class returns:", intObj.getData())

// initialize generic class with String data
var strObj = Information<String>(data: "Swift")
print("Generic Class returns:", strObj.getData())

输出

Generic Class returns: 6
Generic Class returns: Swift

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

class Information<T> {...}

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

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

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

这里，

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

Swift 泛型中的类型约束

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

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

以下是我们创建类型约束的方法：

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

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

注意：Numeric 是数字值（如 Int 和 Double）的内置协议。

示例：类型约束

//create a generic function with type constraint
func addition<T: Numeric>(num1: T, num2: T) {

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

// pass Int value
addition(num1: 5, num2: 10)

// pass Double value
addition(num1: 5.5, num2: 10.8)

输出

Sum: 15
Sum: 16.3

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

<T: Numeric>

这里，泛型函数是用类型约束创建的。这意味着 addition() 只能处理遵循 Numeric 协议的数据类型（Int、Double 等）。

Swift 泛型的优点

1. 代码可重用性

借助 Swift 中的泛型，我们可以编写适用于不同数据类型的代码。例如：

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

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

2. 用于集合

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

// creating a integer type array
var list1: Array<Int> = []

// creating a string type array
var list2: Array<String> = []

这里，list1 是一个包含 Int 值的数组，list2 是一个包含 String 值的数组。

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