前言

有时候我们需要将一种数据类型转换为另外一种数据类型，但是有时候可以正确的数据类型转换，有时候可能虽然能够转换，但是会丢失一些信息，前面我们介绍过不同的数据类型的所占的空间不同。

数据类型表

一. 基本数据类型

1. 基本数据类型

这里我们给出常用的数据类型，可以仔细看一下下表的type、type symbol、type char和type num。

数据类型简表

2. 数据类型查看

我们可以通过type函数来查看一个数据是什么类型，通常返回的是数据类型的type num值。如果数据类型是原子的，则返回的值前会加一个“-”号。

q)type 2
-7h
q)type 1 2 3
7h
q)type 98.6
-9h
q)type 1.1 2.0 3
9h
q)type `a
-11h
q)type `a`b`c
11h
q)type "a"
-10h
q)type "abc"
10h
q)type "abc""c"
-10h
q)type (4h; 4i; 4j) /普通列表的数据num为0h
0h
q)type (1 2 3; 4 5 6)
0h
q)type (`a`b`c!1 2 3) /字典的数据num为99h
99h
q)type ([k:`a`b`c] v:1 2 3) /keyed table也是99h
99h
q)type ([] c1:`a`b`c; c2:1 2 3) /一般table为98h
98h

3. 变量的数据类型

变量的数据类型由所给赋的值的类型所决定

q)a:42 /给变量a赋值42
q)type a /a的数据类型num值为-7h
-7h
q)a:"abc" /给变量a赋值string变量“abc”
q)type a /a的数据类型num值为10h
10h
q)a:`s /给变量a赋值string变量`s
q)type a /a的数据类型num值为-11h
-11h
q)get `. /通过get函数获取变量的值，我们发现变量返回类似于一个字典
a| s
q)b:"abc"
q)type b
10h
q)c:`s
q)type c
-11h
q)get `. /通过get函数+`.符号可以获取内存中所有变量名称与对应的值
a| `s
b| "abc"
c| `s
q)value `. /通过value函数+`.符号可以获取内存中所有变量名称与对应的值
a| `s
b| "abc"
c| `s
q)a:42
q)get `.
a| 42
b| "abc"
c| `s
q)f:{[p1] 6*p1} 
q)get `. /我们可以看到函数f与变量一样存储在内存中
a| 42
b| "abc"
c| `s
f| {[p1] 6*p1}

二. 数据类型转换

1. 类型转换

类型转换是将一种类型转换为另一种兼容类型。由于q是动态类型的，因此使用二元运算符“$”操作符在运行时进行转换。操作符的右边是要转换的数据类型，左右是要转换的数据，我们可以通过三种形式作为右边的数据转换目标，分别是：type num、type char和type symbol。

q)7h$4i /通过type num值进行数据类型转换
4
q)"j"$4i /通过type char值进行数据类型转换
4
q)`long$4i /通过type symbol值进行数据类型转换
4

2. 转换为宽数据类型

不同的数据类型在内存中所占的大小是不同的，由窄size数据类型转换为宽size数据类型一般不会造成信息丢失。

q)7h$4i /int 转换为long，
4
q)9h$4 /long转换为float
4f
q)“j”$4i /int 转换为long
4
q)“f”$4 /long转换为float
4f
q)`long$4i /int 转换为long
4
q)`float$4 /long转换为float
4f

3. 转换为窄数据类型

不同的数据类型在内存中所占的大小是不同的，由宽size数据类型转换为窄size数据类型会造成信息丢失。

q)`long$12.345 /由float转换为long造成信息丢失
12
q)`short$123456789 /由long转换为short造成信息丢失
32767h

4. 跨数据类型转换

q)`char$42 /ASCII码42代表的符号是*号
"*"
q)`long$"\n" /符号\n代表的ASCII是10
10

5. 时间数据类型独特的处理方式

我们知道KDB作为时序数据库，时间数据类型因此是一种非常重要的数据类型，因此时间数据类型也有着独特的处理方式。

q)`date$0 /由于q语言的时间是从2000年1月1日作为时间原点，因此0转换为date类型就是2000.01.01
2000.01.01
q)`int$2001.01.01 /2000.01.01到2001.01.01之间有366天，因此将时间类型转换为int类型，结果为这一年的天数
366i
q)`long$12:00:00.0000000000 /将时间类型的时间转换为long类型，则有43200000000000毫秒
43200000000000
q)`timespan$0 /将0转换为时间类型，则代表凌晨0点0分0秒
0D00:00:00.000000000
q)`date$2015.01.02D10:20:30.123456789 /从时间类型中提取年月日
2015.01.02
q)`year$2015.01.02 /从时间类型中提取年
2015i
q)`month$2015.01.02 /从时间类型中提取年月
2015.01m
q)`mm$2015.01.02 /从时间类型中提取月
1i
q)`mm$2015.02.02
2i
q)`dd$2015.01.02 /从时间类型中提取日
2i
q)`hh$10:20:30.123456789 /从时间类型中提取小时
10i
q)`minute$10:20:30.123456789 /从时间类型中提取时分
10:20
q)`uu$10:20:30.123456789 /从时间类型中提取分
20i
q)`second$10:20:30.123456789 /从时间类型中提取时分秒
10:20:30
q)`ss$10:20:30.123456789 /从时间类型中提取秒
30i

6. 原子类型转换

对于Q语言中的原子数据，我们可以对原子类型进行多个数据同时转换。

q)"i"$10 20 30
10 20 30i
q)`float$(42j; 42i; 42j)
42 42 42f
q)`short`int`long$42
42h
42i
42
q)"ijf"$98.6
99i
99
98.6
q)"ijf"$10 20 30
10i
20
30f

三. 文本数据类型转换

1. 转换为字符串数据类型

Q语言的字符串数据其实是一个简单的char类型的列表。一般编程语言都有将字符串转换为其他类型的操作。可以使用string关键字将其他类型数据转换为char类型。

q)string 42
"42" /这里的42不再是42这个值，而是以这个列表包含4和2两个元素
q)string 4 /由于4做一个单原子，这里转换为string类型后会将4转换为enlist类型的4
,"4"
q)string 42i
"42"
q)a:2.0
q)string a
,"2"
q)f:{x*x}
q)string f
"{x*x}"
q)string 1 2 3
,"1"
,"2"
,"3"
q)string "string" /Q语言中字符串是一个char类型的列表，因此这里会将字符串看做是一个列表
,"s"
,"t"
,"r"
,"i"
,"n"
,"g"
q)string (1 2 3; 10 20 30)
,"1" ,"2" ,"3"
"10" "20" "30"
q)string `Life`the`Universe`and`Everything /将symbol类型转换为字符串类型
"Life"
"the"
"Universe"
"and"
"Everything"

2. string——>symbol

q)`$"abc" /作为字符串类型，这里”abc”相当于是一个列表中的三个元素
`abc /作为symbol类型，这里的abc是一个元素
q)a:"abc"
q)a[0]
"a"
q)a[1]
"b"
q)b:`abc`def
q)b[0]
`abc
q)`$"Hello World"
`Hello World
q)`$"Zaphod \"Z\""
`Zaphod "Z"
q)`$("Life";"the";"Universe";"and";"Everything")
`Life`the`Universe`and`Everything

四. 枚举

1. 什么是枚举

其他编程语言中，枚举类型是一种将一系列名称与相应的整数值组相关联的方法。枚举类型有多种用途。

• 1）使用描述性名称而不是任意数字。例如，“红色”，“绿色”，“蓝色”而不是0,1和2。
• 2）进行类型检查以确保仅提供允许的值。例如，从列表中选择颜色名称而不是记住其编号不易出错。
• 3）它提供了命名空间，意思是同一名称可以在不同的域中重复使用而不用担心混淆。例如，color.blue和note.blue。

2. 数据标准化

从广义上讲，数据规范化旨在消除重复，仅保留最低要求的数据。例如，证券交易所股票代码。逐字存储这些字符串的长列表存在两个问题。

• 可变长度的值使存储管理复杂化并使检索效率低下；
• 重复值可能导致重复数据。当值发生变化时，很难保持同步。

我们可以通过下面的例子来看数据标准化的好处。

q)u:`huawei`apple`samsung`oppo /一个包含四家公司名称的symbol列表
q)v:1000000?u /从u中随机选取1000000个数据出来，每次从四家公司中随机选取一个组成一个新的列表v
q)v
`samsung`huawei`samsung`huawei`apple`oppo`samsung`huawei`huawei`huawei`samsung`samsung`apple`huaw..
q)k:u?v /将v列表中的每一个元素对应的u中的索引号赋值给k
q)k /我们可以通过k的每一个元素的值看出正好是v中每个元素在u中的索引号
2 0 2 0 1 3 2 0 0 0 2 2 1 0 0 3 0 1 3 0 1 3 0 3 0 2 1 0 0 2 0 2 2 0 1 3 2 3 2 2 1 2 0 0 3 0 3 3 0..
q)u[k]
`samsung`huawei`samsung`huawei`apple`oppo`samsung`huawei`huawei`huawei`samsung`samsung`apple`huaw..

通过上面的例子我们就可以将1000000个数据标准化为一个数值的列表，这样我们有时候处理起来就会更加的方便。

3. 利用symbol数据类型进行枚举

我们利用v，这里需要注意的是v中的所有数据都应该在u中有对应的值，否则就不是枚举，也会报错。

q)v
`samsung`huawei`samsung`huawei`apple`oppo`samsung`huawei`huawei`huawei`samsung`samsung`apple`huaw..
q)u
`huawei`apple`samsung`oppo
q)`u$v
`u$`samsung`huawei`samsung`huawei`apple`oppo`samsung`huawei`huawei`huawei`samsung`samsung`apple`h..
q)em:`u$v
q)`int$em
2 0 2 0 1 3 2 0 0 0 2 2 1 0 0 3 0 1 3 0 1 3 0 3 0 2 1 0 0 2 0 2 2 0 1 3 2 3 2 2 1 2 0 0 3 0 3 3 0..
q)em:`u$`xiaomi /xiaomi这个数据并没有在u中有对应的元素，因此枚举时就报错
'cast

4. 枚举的使用

q)u:`huawei`apple`samsung`oppo
q)v:1000000?u
q)v
`oppo`oppo`huawei`apple`apple`huawei`samsung`samsung`apple`apple`apple`samsung`huawei`samsung`app..
q)em:`u$v /创建枚举类型的em变量
q)v[3] /查询列表v中的第四个数据
`apple
q)em[3]  /查询枚举变量em中的第四个数据，返回结果与v的都是apple
`u$`apple
q)v=`oppo /查看v中所有那些元素值是oppo
1100000000000000000110000010000011011000000001001100000111000100011001011000000110100011000000000..
q)em=`oppo  /查看em中所有那些元素值是oppo
1100000000000000000110000010000011011000000001001100000111000100011001011000000110100011000000000..
q)where v=`apple  /查看v中所有那些元素值是apple，并返回索引号
3 4 8 9 10 14 22 23 27 28 29 34 38 39 40 42 59 62 67 68 70 73 83 84 85 88 90 92 96 98 99 102 103 ..
q)where em=`apple /查看em中所有那些元素值是apple，并返回索引号
3 4 8 9 10 14 22 23 27 28 29 34 38 39 40 42 59 62 67 68 70 73 83 84 85 88 90 92 96 98 99 102 103 ..
q)v=em /从表面上看v和em似乎是相等的
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111..
q)v~em /但是只是值相等，数据类型并不相同
0b
q)type v /列表v的数据类型num为11h
11h
q)type em /枚举类型em的数据类型num为20h
20h

5. 更新枚举的列表

现在假设apple公司改名了，叫appleone，我们这时候只需要更新u中的数据就可以了。

q)u[1]:`appleone /apple公司的名称还成了appleone
q)u
`huawei`appleone`samsung`oppo
q)v /我们发现v中的数据apple并没有改变appleone
`oppo`oppo`huawei`apple`apple`huawei`samsung`samsung`apple`apple`apple`samsung`huawei`samsung`app..
q)em /但是枚举em中的apple改成了appleone了
`u$`oppo`oppo`huawei`appleone`appleone`huawei`samsung`samsung`appleone`appleone`appleone`samsung`..

现在假设我们出现了一个新的公司叫xiaomi的，我们需要先给u中添加xiaomi，然后才能给em中添加xiaomi这个元素。

q)u
`huawei`appleone`samsung`oppo
q)u,:`xiaomi /给u中添加xiaomi
q)u
`huawei`appleone`samsung`oppo`xiaomi
q)em,:`xiaomi /这个时候我们就可以给em中添加xiaomi了
q)last em /利用last函数返回em中的最后一个元素
`u$`xiaomi
q)v,:`meizu /我们在没有给u中添加meizu的情况下可以随时给v中添加新的元素
q)em,:`meizu /我们在没有给u中添加meizu的情况下给em中添加新的元素，则返回`cast错误
'cast

6. 创建动态枚举

由于很多时候我们不清楚未来的情况，因此我们可以创建动态的枚举类型。

q)company:() /创建一个空列表作为原数据
q)`company$`g /这个时候我们利用元数据列表company创建枚举类型，由于列表中没有`g这个元素，因此报错
'type
q)`company?`huawei  /这个时候我们可以通过？操作符代替$操作符来创建枚举类型，同时这时也会自动将huawei添加到原数据当中。
`company$`Huawei  /返回一个枚举的类型
q)company /这时我们查看原数据中，发现已经添加了huawei这个元素
,`huawei
q)`company?`apple`IBM /同理我们也可以同时添加多个元素来创建枚举类型
`company$`apple`IBM
q)company
`huawei`apple`IBM
q)`company?`huawei`xiaomi /我们添加一个存在的和不存在元素
`company$`huawei`xiaomi
q)company /在原数据中不会重复添加相同元素的
`huawei`apple`IBM`xiaomi
q)em:`company?`huawei`xiaomi
q)em
`company$`huawei`xiaomi