Nim教程【十】

openarray类型

注意：openarray类型只能用于参数

固定大小的数组虽然性能不错，但过于呆板，使用取来不是很方便

对于一个方法来说，传入参数如果是一个数组，最好是不要限制数组的长度

也就是说，方法应该能够处理不同大小的数组

openarray类型就是为了满足这样的要求而设计的

openarray类型的变量索引总是从0开始

len、low、high等操作同样试用于openarray类型

原则上，任何一个数组都可以被传递到一个openarray参数中，索引的类型并不重要

但是一定要注意：不能给openarray类型的参数传递多维数组

可变数量的参数

一个可变数量的参数就是一个openarray参数

他可以让开发者传递多个同一类型的参数给一个方法

编译器自动将这些参数转换为一个openarray数组

proc myWriteln(f: File, a: varargs[string]) =
  for s in items(a):
    write(f, s)
  write(f, "\n")
 
myWriteln(stdout, "abc", "def", "xyz")
# is transformed by the compiler to:
myWriteln(stdout, ["abc", "def", "xyz"])

需要注意的是：这种类型的参数必须是方法签名的最后一个参数

另外，你可以通过下面这种方式来动态转换传入的参数的类型

proc myWriteln(f: File, a: varargs[string, `$`]) =
  for s in items(a):
    write(f, s)
  write(f, "\n")
 
myWriteln(stdout, 123, "abc", 4.0)
# is transformed by the compiler to:
myWriteln(stdout, [$123, $"def", $4.0])

在这个例子中，$应用于任何参数，

（注意：$应用于字符串时，是一个nop操作）

（译者注：这个语言特性非常像C#里的param关键字）

slice类型

slice类型和subranges类型很相似

但这两个类型的使用场景不尽相同

在实际的业务控制代码中slice类型并不是很常用

但在很多集合类型的操作中，slice起到定义操作数的作用

请看下面的代码：

var
  a = "Nim is a progamming language"
  b = "Slices are useless."
 
echo a[7..12] # --> 'a prog'
b[11.. -2] = "useful"
echo b # --> 'Slices are useful.'

在上面的例子中，slice类型被用于修改一个字符串的一部分

在上面的例子中，-2是一个负数索引（倒数第二个字符）

理论上slice可以容纳任何类型的数据

但是如果slice用于方法的签名中，则必须明确slice容纳的数据类型

Tuple元组类型

Tuple元组类型定义了一系列的有序的属性

可以使用方括号来定义元组，

使用小括号来构造元组，

构造器中属性的顺序必须和元组定义的属性的顺序一致

如果两个元组在定义的时候，使用了相同的属性而且属性的顺序也是一致的

那么这两个元组就是相同的

可以使用t.field来访问一个元组的某个属性

也可以使用t[i]来访问一个元组的第几个属性

来看下面的代码：

type
  Person = tuple[name: string, age: int] # type representing a person:
                                         # a person consists of a name
                                         # and an age
var
  person: Person
person = (name: "Peter", age: 30)
# the same, but less readable:
person = ("Peter", 30)
 
echo(person.name) # "Peter"
echo(person.age)  # 30
 
echo(person[0]) # "Peter"
echo(person[1]) # 30
 
# You don't need to declare tuples in a separate type section.
var building: tuple[street: string, number: int]
building = ("Rue del Percebe", 13)
echo(building.street)
 
# The following line does not compile, they are different tuples!
#person = building
# --> Error: type mismatch: got (tuple[street: string, number: int])
#     but expected 'Person'
 
# The following works because the field names and types are the same.
var teacher: tuple[name: string, age: int] = ("Mark", 42)
person = teacher

从上面的代码中，大家可以看出

在使用tuple类型的时候，不一定要新创建一个类型出来

上面的代码中的building变量就直接使用了tuple类型，而不像person一样先创建了一个Person类型

只有在元组属性赋值期间元组才可以被拆箱（这里不知道翻译的对不对,原文：Tuples can be unpacked during variable assignment (and only then!).）

os模块的内置splitFile方法，可以返回三个值，一个是路径，一个是文件名，一个是文件扩展名

这个时候就可以应用这个特性

import os
 
let
  path = "usr/local/nimc.html"
  (dir, name, ext) = splitFile(path)
  baddir, badname, badext = splitFile(path)
echo dir      # outputs `usr/local`
echo name     # outputs `nimc`
echo ext      # outputs `.html`
# All the following output the same line:
# `(dir: usr/local, name: nimc, ext: .html)`
echo baddir
echo badname
echo badext

上面的代码第一次输出和第二次输出是一样的

只有使用var或者let操作符时，才可以应用元组解包的特性

下面的代码编译不会通过的

import os
 
var
  path = "usr/local/nimc.html"
  dir, name, ext = ""
 
(dir, name, ext) = splitFile(path)
# --> Error: '(dir, name, ext)' cannot be assigned to

今天就写到这里吧，喜欢的请帮忙点个推荐

谢谢大家