Swift（09）- 元组

Posted 2022-11-06 崔小花o

概述

元组是Swift编程语言中唯一的一种复合类型。它可以将指定有限个数的任何类型依次整理为一个对象。一个元组类型的形式为：(type1, type2, type3, … , typen)。元组中的每一种类型都可以是任意的结构体、枚举或类类型，甚至也可以是一个元组以及空元组。元组中的每个元素我们也称之为一个分量（component）。我们下面先举两个简单的例子：

enum MyEnum 
    case one, two, three

 
class MyClass 
    var member = 0

 
// 声明一个元组常量tuple，其类型为：
// (Int, MyEnum, MyClass)
let tuple: (Int, MyEnum, MyClass) = (10, .one, MyClass())
 
// 声明了元组常量tuple2，其类型为：
// (Int, (Int, Double, Bool), Int)
// 其第二个元素也是一个元组
let tuple2 = (10, (20, 0.5, true), 0)

我们这里要注意的是，如果我们要表示一个元组，那么圆括号中必须至少要有2个元素，否则圆括号将被视作为圆括号操作符，而不是一个元组字面量。下面我们看一个例子：

ar a = (100)
 
// 这里打印：a = 100
print("a = \\(a)")
 
// 这里打印出：
// The type is: Int
print("a type is: \\(type(of: a))")
 
// x为Int类型
let x: (Int)
 
// y为Double类型
let y: (Double)
 
x = a
y = 10.5
 
let b = (100, 200)
 
// 这里打印出：b = (100, 200)
print("b = \\(b)")
 
// 这里打印出：
// b type is: (Int, Int)
print("b type is: \\(type(of: b))")
 
// 我们最后来验证一下对象a不是一个元组：
// 这里会出现编译错误：
// 'Int'类型的值不具有成员'0'
a.0 += b.0 + b.1

上述代码很清晰地描绘出圆括号表达式与元组表达式的区别。如果一个圆括号中没有任何元素，那么我们把它称作为一个空元组。

访问元组中的元素

如果我们要访问一个数组中的元素，可以对元组对象使用成员访问操作符(member-access operator) .，后面跟元素的索引位置（从0开始计数）。请看以下代码:

// 声明一个元组常量tuple，其类型为：
// (Int, Double, Bool)
let tuple = (10, 0.5, false)
 
// 访问tuple的第1个元素，
// 这里常量a的值为10
let a = tuple.0
 
// 访问tuple的第2个元素，
// 这里常量b的值为0.5
let b = tuple.1
 
// 访问tuple的第3个元素，
// 这里常量c的值为false
let c = tuple.2

此外，我们还能给元组指定标签，使得我们可以通过访问标签名来访问元组的相应元素。请见下面代码：

// 声明一个元组常量tuple，
// 其类型为：(int: Int, double: Double, bool: Bool)，
// 它每个元素含有相应标签
let tuple = (int: 10, double: 0.5, bool: false)
 
// 访问tuple的第一个元素
let a = tuple.int
 
// 访问tuple的第二个元素
let b = tuple.double
 
// 访问tuple的第三个元素
let c = tuple.bool

各位要注意的是，一旦一个元组的某个元素带上标签，那么该元组类型相应的位置也必须加上标签。此外，一个元组中不需要给所有元素都加上标签，可以加一部分，而其余的元素可以不指定标签。对于指定标签的元素，我们既可以使用标签来访它，也可以使用整数索引。我们可以看以下代码：

// 声明一个元组常量tuple，
// 其类型为：(int: Int, Double, bool: Bool, String)，
// 注意，它第二个与最后一个元素类型是没有标签的。
let tuple = (int: 10, 0.5, bool: false, "hello")
 
// 访问tuple的第一个元素
let a = tuple.int
 
// 访问tuple的第二个元素
let b = tuple.1
 
// 访问tuple的第三个元素
let c = tuple.bool
 
// 访问tuple的第四个元素
let s = tuple.3

我们看到元组的声明以及对其元素的访问之后一定会有这么一种印象——它就如同一个轻便型的匿名结构体。我们不需要对一个元组指定类型名，而直接给出类型声明，甚至直接给出元组对象字面量，把指定类型的对象一一放入即可，因此元组往往用于一个函数返回多个不同类型的对象的场合。

元组分解

我们之前已经看到，我们能很容易地定义一个元组对象。而同时，我们可以非常容易地萃取一个元组中的相应元素，这也被称为元组分解（decompose）。
我们在做元组分解时，将几个变量或常量以元组定义的方式进行声明，然后 = 操作符右边元组对象中的相应元素就能赋值给 = 左边的相应变量或常量了。我们可以看以下代码：

// 声明一个元组常量tuple
let tuple = (10, 20.5, true)
 
// 这里同时声明了三个常量：
// i、d、b。
// 然后tuple中的第一个元素对i初始化；
// tuple中的第二个元素对d初始化；
// tuple中的第三个元素对b初始化
let (i, d, b) = tuple
 
// 正如之前提到的，
// 如果我们不想萃取元组中某一元素的值，
// 我们可以用下划线进行忽略。
// 这里同时声明了变量x和y
var (x, _, y) = (5.5, "hello", 8.5)
 
x += d  // x的值为26
y -= d  // y的值为-12

我们这里要注意的是，像上述代码中的 let (i, d, b) 并不是在声明一个元组，而是同时声明三个常量，用于萃取一个元组中的值。元组也可看作为一个对象，比如上述代码中的 tuple 才是名副其实的元组对象。
通过元组分解这一语法特性，我们还能用元组字面量来直接交换两个对象的值，看以下代码：

// 定义了a和b两个Int类型的对象
var a = 1, b = 2
 
// 这里通过元组字面量(b, a)将
// a与b两个对象的值进行了交换，
// 其中这里的(a, b)不是元组字面量，
// 而是用于元组分解的元组元素萃取形式
(a, b) = (b, a)
 
// 输出：a = 2, b = 1
print("a = \\(a), b = \\(b)")

实际上像上述代码中 = 操作符右边的 (b, a)并不是直接对所定义的b和a的直接引用，而是将它们的值拷贝到该元组字面量对象中，由于 Int 类型属于结构体类型，而结构体类型属于值类型，赋值时以拷贝的方式进行。而 = 操作符左边的(a, b)用于对元组元素的萃取，它们则直接表示上面所定义的a和b。而像(a, b) = (b, a)这条语句相当于：

let tmp = (b, a)
(a, b) = tmp

元组的比较

两个相同元素类型的元组，如果每个元素都遵循了 Equatable 协议，那么这两个元组对象可以用 == 操作符以及 != 操作符来判别两者是否相等。如果两个元组对象中的每个元素的值都相等，那么这两个元组对象是相等的，否则它们是不等的。
两个相同元素类型的元组，如果每个元素都遵循了 Comparable 协议，那么这两个元组可以用 > 、< 、 >= 以及 <= 来比较大小。在比较两个元组的时候，从这两个元组的第一个元素开始进行比较，如果能比较出结果，那么就立即返回比较结果，否则再依次比较下去。下面我们举一些例子来说明：

let t1 = (1, 2, 3)
let t2 = (1, 2, 3)
 
// 判断元组t1与t2是否相等，
// 结果为true
print("t1 == t2? \\(t1 == t2)")
 
let t3 = (2, 3, 4, 5)
let t4 = (2, 1, 7, 9)
 
// 这里比较元组t3与t4是否为小于关系，
// 结果为false，
// 因为t3的第2个元素大于t4的第2个元素
print("t3 < t4? \\(t3 < t4)")
 
// 这个比较将直接编译报错，
// 因为这两个不是相同类型的元组
var b = t1 < t3
 
// 这句也会引发编译报错， 因为布尔类型不遵循Comparable协议，所以不能进行比较，尽管这里的Int与Double可进行比较
b = (true, 1, 2.0) > (false, 2, -1.0)

空元祖

所谓空元组就是一个不包含任何元素的元组，即 () 。Swift编程语言中对空元组有一个非常特殊的定义——既可以将它用来作为对象或函数的类型进行声明，也可以将它作为右值。当作为对象或函数的类型声明时，它表示无，即相当于C语言中的 void。当作为类型使用时，我们往往使用Void来显式标出。在Swift编程语言中，Void 其实就是用空元组来定义的。当空元组作为右值时，它表示一个空表达式，并且类型为 Void。这里大家要注意的是，如果空元组作为右值使用，那么就不能写 Void，而必须直接用 ()。因为 Void是以类型的方式定义的，而不是以值的方式。
空表达式（void）与空值表达式（nil ）是有本质区别的。前者表示不具有任何类型，除了通配符（_）以及表示 Void 的对象之外，不能赋值给其它任何类型的对象。而空值 nil则可赋值给任一Optional对象，表示其当前引用为空。我们下面来举一些例子进行说明：

// 声明一个Void类型的常量v
let v: Void
 
// 用空元组对v初始化
v = ()
 
// 将v赋值给缺省对象说明符，
// 这条语句是一条空语句，
// 编译器会直接将它忽略
_ = v
 
var a = 10
 
// 这里需要对result显式标明Void类型，
// 否则会有编译警告
let result: Void = a += 100
 
// 空元组值也可以被打印出来，
// 输出：result = (), a = 110
print("result = \\(result), a = \\(a)")
 
// 这里先提前说明一下，
// 空元组也能赋值给Any类型的对象
let obj: Any = result
 
// 我们甚至还可以用is来判断Void对象的类型
let isVoid = obj is Void
// 输出：isVoid? true
print("isVoid? \\(isVoid)")

我们可以看到，在Swift中可以将对象显式声明为 Void 类型，这一点比起其他类C语言都要灵活。这看似没什么实际作用，但却给Swift语法体系带来了完备性。我们可以看到，() 中如果包含了2个或更多个类型，那么它就是一个元组，所以在数学上我们可以将元组看作为一个向量类型；而如果在 ()中只包含一个类型，那么它就是一个普通的标量类型；而如果在 () 中什么都没有呢？那么它就是“虚无”的存在。只不过“虚无”在Swift编程语言中可以以一种特殊的对象身份出现。