仓颉编程语言入门 -- Array数组详解

仓颉编程语言入门 – Array数组详解

一. 如何创建Array数组

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

1.仓颉使用 Array 来表示 Array 类型。T 表示 Array 的元素类型，T 可以是任意类型 , 类似于泛型的概念

var arr:Array<String> = ["你好" , "仓颉"]
var arr1 : Array<Int> = [ 1 , 5 , 8]

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

arr = ar1

3.如果相同类型赋值后会被取代

var arr1 : Array<Int> = [ 1 , 5 , 8]
var arr2 : Array<Int> = [1,9,6,45,4]
arr1 = arr2
println(arr1) // [1, 9, 6, 45, 4]

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

编译器会根据上下文自动推断 Array 字面量的类型。也就是说在定义数组中我们可以直接省略类型 , 类似与Python的定义方法

var arr4 = ["你好"]

但是并不支持存入不同类型的数据 , 会发生编译时期错误

var arr4 = ["你好",1,true]
// The types 'Bool', 'Int64' and 'Struct-String' do not have the smallest common supertype

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

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

1. 使用构造创建一个空数组 , 类型为Int64

   let a = Array<Int64>() // Created an empty Array whose element type is Int64
   

2. 使用另一个数组初始化b

   let b = Array<Int64>(a) // Use another Array to initialize b
   

3. 创建一个指定长度为3 , 默认值为0 的数组

   let c = Array<Int64>(3, item: 0)
   

4. 创建一个长度为3 , 元素由函数初始化的数组

   let d = Array<Int64>(3, {i => i + 1}) 
   

二. 如何获取数组对象

当我们需要对 Array 的所有元素进行访问时，可以使用 for-in 循环遍历 Array 的所有元素。

1. Array 是按元素插入顺序排列的，因此对 Array 遍历的顺序总是恒定的。

   main() {
       let arr = [0, 1, 2]
       for (i in arr) {
           println("The element is ${i}")
       }
   }
   

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

   The element is 0
   The element is 1
   The element is 2
   

2. 当我们需要知道某个 Array 包含的元素个数时，可以使用 size 属性获得对应信息。

   main() {
       let arr = [0, 1, 2]
       let len = arr.size
       println("The size of array is ${len}")
   }
   

   输出

   The size of array is 3
   

3. 当我们想访问单个指定位置的元素时，可以使用下标语法访问（下标的类型必须是 Int64）。非空 Array 的第一个元素总是从位置 0 开始的。我们可以从 0 开始访问 Array 的任意一个元素，直到最后一个位置（Array 的 size - 1）。索引值不能使用负数或者大于等于 size，当编译器能检查出索引值非法时，会在编译时报错，否则会在运行时抛异常。

   main() {
       let arr = [0, 1, 2]
       let a = arr[0] // a == 0
       let b = arr[1] // b == 1
       let c = arr[-1] // array size is '3', but access index is '-1', which would overflow
   }
   

4. 如果我们想获取某一段 Array 的元素，可以在下标中传入 Range 类型的值，就可以一次性取得 Range 对应范围的一段 Array。

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

5. 当 Range 字面量在下标语法中使用时，我们可以省略 start 或 end。

   当省略 start 时，Range 会从 0 开始；当省略 end 时，Range 的 end 会延续到最后一位。

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

三. 如何修改Array数组

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

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

main(): Int64 {

    var arr = [1,3,5]
    println(arr) // [1, 3, 5]
    arr[1] = 10
    println(arr) //[1, 10, 5]

    return 0
}

ps : Array 是引用类型，因此 Array 在作为表达式使用时不会拷贝副本，同一个 Array 实例的所有引用都会共享同样的数据。

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

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

​ 也就是说 , 当数组作为表达式穿给其他数组的时候 , 其他数组和原数组是共享数据的 , 实质上就是把原数组的地址值传递给了新数组 , 这样的话就会导致新数组的值被修改 , 原数组同样改 变

四. VArray类型

仓颉编程语言引入了值类型数组 VArray<T, $N>，其中T表示该值类型数组的元素类型，$N 是一个固定的语法，通过 $ 加上一个 Int64 类型的数值字面量表示这个值类型数组的长度。需要注意的是，VArray<T, $N> 不能省略 <T, $N>，且使用类型别名时，不允许拆分 VArray 关键字与其泛型参数。

type varr1 = VArray<Int64, $3> // Ok
type varr2 = VArray // Error

VArray 可以由一个数组的字面量来进行初始化，左值 a 必须标识出 VArray 的实例化类型：

var a: VArray<Int64, $3> = [1, 2, 3]

同时，它拥有两个构造函数：

// VArray<T, $N>(initElement: (Int64) -> T)
let b = VArray<Int64, $5>({ i => i}) // [0, 1, 2, 3, 4]
// VArray<T, $N>(item!: T)
let c = VArray<Int64, $5>(item: 0) // [0, 0, 0, 0, 0]

除此之外，VArray<T, $N> 类型提供了两个成员方法：

• 用于下标访问和修改的 [] 操作符方法：

  var a: VArray<Int64, $3> = [1, 2, 3]
  let i = a[1] // i is 2
  a[2] = 4 // a is [1, 2, 4]
  

  下标访问的下标类型必须为 Int64。

• 用于获取 VArray 长度的 size 成员：

  var a: VArray<Int64, $3> = [1, 2, 3]
  let s = a.size // s is 3
  

  size 属性的类型为 Int64。