元组类型的字面量#

元组类型的字面量使用 (e1, e2, ..., eN) 表示，其中 e1 到 eN 是表达式，多个表达式之间使用逗号分隔

下面的例子中，分别定义了一个 (Int64, Float64) 类型的变量 x，以及一个 (Int64, Float64, String) 类型的变量 y，并且使用元组类型的字面量为它们定义了初值:

1
let x: (Int64, Float64) = (3, 3.141592)
2
let y: (Int64, Float64, String) = (3, 3.141592, "PI")

元组支持通过 t[index] 的方式访问某个具体位置的元素，其中 t 是一个元组，index 是下标，并且 index 只能是从 0 开始且小于元组元素个数的整数类型字面量，否则编译报错

下面的例子中，使用 pi[0] 和 pi[1] 可以分别访问二元组 pi 的第一个元素和第二个元素

1
main() {
2
    var pi = (3.14, "PI")
3
    println(pi[0])
4
    println(pi[1])
5
}

编译并执行上述代码，输出结果为:

1
3.140000
2
PI

在赋值表达式中，可使用元组进行多赋值，参见 赋值操作符 章节

元组的类型是(T1, T2, T3, ..., TN), 元组字面量也很简单: (expr1, expr2, expr3, ..., exprN)

元组, 实际就是多个元素组成的一个元素组

可以通过下标访问具体的元素, 但不能修改元素值

使用元组字面量创建元组变量实例, 可以不用声明元组类型, 可以由编译器推导

1
let person = ("humid1ch", 10, 50, 100)
2
print("${person[0]} ")
3
print("${person[1]} ")
4
print("${person[2]} ")
5
print("${person[3]} ")
6
println()

元组类型的类型参数#

可以为元组类型标记显式的类型参数名，下面例子中的 name 和 price 就是 类型参数名

1
func getFruitPrice (): (name: String, price: Int64) {
2
    return ("banana", 10)
3
}

对于一个元组类型，只允许统一写类型参数名，或者统一不写类型参数名，不允许交替存在，并且参数名本身不能作为变量使用或用于访问元组中元素

1
let a: (name: String, Int64) = ("banana", 5)              // Error
2
let b: (name: String, price: Int64) = ("banana", 5)       // OK
3
b.name                                                    // Error

元组类型在声明时, 可以像函数参数一样, 添加类型参数名, 比如: (name: String, age: Int64)

但类型参数名实际上只用作说明, 不能像变量名一样访问目标元素

且, 如果要声明类型参数名, 那么所有类型都要声明, 否则所有类型都不能声明类型参数名

Array#

可以使用 Array 类型来构造单一元素类型，有序序列的数据

仓颉使用 Array<T> 来表示 Array 类型

T 表示 Array 的元素类型，T 可以是任意类型

1
var a: Array<Int64> = [0, 0, 0, 0]            // 元素类型为 Int64 的数组
2
var b: Array<String> = ["a1", "a2", "a3"]     // 元素类型为 String 的数组

元素类型不相同的 Array 是不相同的类型，所以它们之间不可以互相赋值

因此以下例子是不合法的

1
b = a                                         // 类型不匹配

数组Array, 可以构造单一元素类型的有序序列

数组的字面量语法为: [elem1, elem2, elem3, ..., elemN], 字面量中所有elem类型需要为同一类型

Array的元素类型不同, 则数组类型也不同, Array数组类型只与元素类型有关

不同的数组类型变量之间禁止相互赋值

数组, 也是一个各编程语言中几乎都存在的概念

数组元素可以通过下标索引访问

可以轻松使用字面量来初始化一个 Array，只需要使用方括号将逗号分隔的值列表括起来即可

编译器会根据上下文自动推断 Array 字面量的类型

1
let a: Array<String> = []                 // 创建一个元素类型为 String 的 空Array数组
2
let b = [1, 2, 3, 3, 2, 1]                // 创建一个元素类型为 Int64 的 Array数组，包含元素 1、2、3、3、2、1

也可以使用构造函数的方式构造一个指定元素类型的 Array

其中，repeat 属于 Array 构造函数中的一个命名参数

需要注意的是，当通过 repeat 指定的初始值初始化 Array 时，该构造函数不会拷贝 repeat，如果 repeat 是一个引用类型，构造后数组的每一个元素都将指向相同的引用

1
let a = Array<Int64>()                    // 创建一个元素类型为 Int64 的 空Array数组
2
let b = Array<Int64>(3, repeat: 0)        // 创建一个元素类型为 Int64、长度为 3 的 Array数组，所有元素均初始化为 0
3
let c = Array<Int64>(3, {i => i + 1})     // 创建一个元素类型为 Int64、长度为 3 的 Array数组，所有元素都由初始化函数初始化

示例中 let c = Array<Int64>(3, {i => i + 1}) 使用了 lambda 表达式作为初始化函数来初始化数组中的每一个元素，即 {i => i + 1}

除了使用Array字面量直接创建Array实例

Array提供有构造函数, 最常用的就是这三个构造函数:

1. init()

   无参, 构造一个空的Array数组

   1
   let a = Array<Int64>()
   2
   println(a)
   

   执行结果为:

   1
   []
   

2. init(size: Int64, repeat!: T)

   第一个参数: size, 表示构造的Array数组的长度

   第二个参数: repeat!, 表示元素初始值, 如果是此参数传入引用类型, 则数组中所有元素指向同一引用

   1
   let b = Array<Int64>(3, repeat: 1)
   2
   println(b)
   

   执行结果为:

   1
   [1, 1, 1]
   

3. init(size: Int64, initElement: (Int64) -> T)

   第一个参数: size, 表示构造的Array数组的长度

   第二个参数: initElement, 各索引元素的初始化函数, 即 各位置会将索引作为参数, 传入此函数 返回值作为元素值

   1
   let c = Array<Int64>(3, {i => i + 1})
   2
   println(c)
   

   执行结果为:

   1
   [1, 2, 3]
   

Array还有其他构造函数, 具体之后再分析

修改Array#

Array 是一种长度不变的 Collection 类型，因此 Array 没有提供添加和删除元素的成员函数

但是 Array 允许对其中的元素进行修改，同样使用下标语法

1
main() {
2
    let arr = [0, 1, 2, 3, 4, 5]
3
    arr[0] = 3
4
    println("The first element is ${arr[0]}")
5
}

编译并执行上面的代码，会输出:

1
The first element is 3

Array 虽然是 struct 类型，但其内部持有的只是元素的引用，因此在作为表达式使用时不会拷贝副本，同一个 Array 实例的所有引用都会共享同样的元素数据

因此对 Array 元素的修改会影响到该实例的所有引用

1
let arr1 = [0, 1, 2]
2
let arr2 = arr1
3
arr2[0] = 3
4
// arr1 contains elements 3, 1, 2
5
// arr2 contains elements 3, 1, 2

仓颉中Array实际是struct类型的, 但内部持有元素的引用, 所以Array是引用类型

通过下标索引访问Array的元素时, 可以直接修改元素值