2.2. 值和数据类型

Daslang 是一种强大的静态类型语言。所有变量都有一个类型。 Daslang 的基本 POD（普通旧数据）数据类型是:

int, uint, float, bool, double, int64, uint64
int2, int3, int4, uint2, uint3, uint4, float2, float3, float4,
range, urange, range64, urange64

所有 POD 都用机器寄存器/字表示。所有 POD 都按值传递给函数。

Daslang 的存储类型包括:

int8, uint8, int16, uint16 - 8/16 位有符号和无符号整数

它们不能操作，但可以用作结构体、类等中的存储类型。

Daslang 的其他类型的是:

string, das_string, struct, pointers, references, block, lambda, function pointer,
array, table, tuple, variant, iterator, bitfield

默认情况下，所有 Daslang 的类型都使用清零内存进行初始化。

2.2.1. Integer

整数表示 32 位（无）符号数字:

let a = 123    // decimal, integer
let u = 123u   // decimal, unsigned integer
let h = 0x0012 // hexadecimal, unsigned integer
let o = 075    // octal, unsigned integer

let a = int2(123, 124)    // two integers type
let u = uint2(123u, 124u) // two unsigned integer type

2.2.2. Float

float 表示 32 位浮点数:

let a = 1.0
let b = 0.234
let a = float2(1.0, 2.0)

2.2.3. Bool

布尔值是一种双值（Boolean）数据类型。它的文本是 true 和 false 。bool 值表示条件的有效性（指示条件是 true 还是 false）:

let a = true
let b = false

所有条件语句（if， elif， while）仅适用于 bool 类型。

2.2.4. String

字符串是不可变的字符序列。为了修改字符串，必须创建一个新字符串。

Daslang 的字符串类似于 C 或 C++ 中的字符串。它们由引号(")分隔，并且可以包含转义序列 (\t, \a, \b, \n, \r, \v, \f, \\, \", \', \0, \x<hh>, \u<hhhh> 和 \U<hhhhhhhh>):

let a = "I'm a string\n"
let a = "I'm also
    a multi-line
         string\n"

字符串类型可以被认为是 “指向实际字符串的指针”，就像 C 中的 ‘const char *’ 一样。因此，它们将通过值传递给函数（但该值只是对内存中不可变字符串的引用）。

das_string 是一个可变字符串，其内容可以更改。它只是一个内置的处理类型，即绑定到 Daslang 的 std：：string。因此，它作为参考传递。

2.2.5. 表

表是作为一组键/值对实现的关联容器:

var tab: table<string; int>
tab["10"] = 10
tab["20"] = 20
tab["some"] = 10
tab["some"] = 20 // 替换 'some' 键的值

(参阅 Tables).

2.2.6. 数组

数组是简单的对象序列。有静态数组（固定大小）和动态数组（容器，大小是动态的）。索引始终从 0 开始:

var a = fixed_array(1, 2, 3, 4) // 数组的固定大小为 4，内容为 [1， 2， 3， 4]
var b: array<string>            // 空动态数组
push(b,"some")                  // 现在是 包含“some” 的 1 个元素的数组

(参阅 Arrays).

2.2.7. 结构

结构是其他类型的数据（包括结构）的记录，类似于 C。所有结构（以及其他非 POD 类型，字符串除外）都通过引用传递。

(参阅 Structs).

2.2.8. 类

类类似于结构，但它们还允许使用内置方法和 rtti。

(参阅 Classes).

2.2.9. Variant

Variant 是一种类似于结构体的特殊匿名数据类型，但一次只存在一个字段。可以查询或分配给变体类型以及活动字段值。

(参阅 Variants).

2.2.10. 元组

元组是其他类型（包括结构体）数据的匿名记录，类似于 C++ std：：tuples。所有元组（以及其他非 POD 类型，字符串除外）都通过引用传递。

(参阅 Tuples).

2.2.11. 枚举

枚举将特定整数值绑定到名称，类似于 C++ 枚举类。

(参阅 Enumerations).

2.2.12. 位域

位域是一种匿名数据类型，类似于枚举。每个字段显式表示一个位，并且存储类型始终为 uint。对单个位的查询可用于变体，以及二进制逻辑作。

(参阅 Bitfields).

2.2.13. 函数

函数与大多数其他语言中的函数相似:

def twice(a: int): int {
    return a + a
}

但是，有一些泛型（模板化）函数，这些函数将在函数调用期间通过类型推断“实例化”:

def twice(a) {
    return a + a
}

let f = twice(1.0) // 2.0 float
let i = twice(1)   // 2 int

(参阅 Functions).

2.2.14. 引用

引用是“引用”（指向）其他一些数据的类型:

def twice(var a: int&) {
    a = a + a
}
var a = 1
twice(a) // a value is now 2

所有结构体始终作为引用传递给函数参数。

2.2.15. 指针

指针是 ‘引用’ （指向）其他一些数据的类型，但可以是 null （不指向任何内容）。为了使用实际值，需要使用 dereference 或 safe navigation 运算符来取消引用它。如果向它传递 null 指针，则取消引用将 panic。可以使用 new 运算符或使用 C++ 环境创建指针。

def twice(var a: int&) {
    a = a + a
}
def twicePointer(var a: int?) {
    twice(*a)
}

struct Foo {
    x: int
}

def getX(foo: Foo?) { // 如果 foo 为 null，则返回 foo.x 或 -1
   return foo?.x ?? -1
}

2.2.16. 迭代器

迭代器是一个可以遍历的序列，并且可以检索关联的数据。它们与 C++ 迭代器有一些相似之处。

(参阅 Iterators).