以下内容来自 尚硅谷，写这一系列的文章，主要是为了方便后续自己的查看，不用带着个PDF找来找去的，太麻烦！

第 5 章 FLUX中的数据类型

5.1 10 个基本数据类型

5.1.1 Boolean （布尔型）

5.1.1.1 将数据类型转换为boolean

1、使用bool( )函数可以将下述的 4 个基本数据类型转换为boolean：

类型	说明
string（字符串）	字符串必须是 “true” 或 “false”
float（浮点数）	值必须是 0 .0（false）或 1 .0（true）
int（整数）	值必须是 0 （false）或 1 （true）
uint（无符号整数）	值必须是 0 （false）或 1 （true）

示例：

bool(v: "true")
// Returns true
bool(v: 0.0)
// Returns false

bool(v: 0)// Returns false (^)
bool(v: uint(v: 1))
// Returns true

5.1.2 bytes （字节）

1、注意是bytes（复数）不是byte，bytes类型表示一个由字节组成的序列。

5.1.2.1 定义bytes

1、FLUX没有提供关于bytes的语法。可以使用bytes函数将字符串转为bytes。

注意：只有字符串类型可以转换为bytes。

bytes(v:"hello")
// Returns [104 101 108 108 111]

5.1.2.2 将表示十六进制的字符串转为bytes

1、引入"contrib/bonitoo-io/hex"包
2、使用hex.bytes() 将表示十六进制的字符串转为bytes

import "contrib/bonitoo-io/hex"
hex.bytes(v: "FF5733")
// Returns [255 87 51] (bytes)

5.1.2.3 使用display( )函数获取bytes的字符串形式

1、使用display( )返回字节的字符串表示形式。bytes的字符串表示是 0 x开头的十六进制
表示。示例:

import "sampledata"
sampledata.string()
|> map(fn: (r) => ({r with _value: display(v: bytes(v:
r._value))}))

5.1.3 Duration持续时间

1、持续时间提供了纳秒级精度的时间长度。

5.1.3.1 持续时间的语法

缩写	说明
ns	纳秒
us	微秒
ms	毫秒
s	秒
m	分钟
h	小时
d	天
w	周
mo	日历月
y	日历年

1、示例：

1ns // 1 纳秒
1us // 1 微妙
1ms // 1 毫秒
1s // 1 秒
1m // 1 分钟
1h // 1 小时
1d // 1 天
1w // 1 星期
1mo // 1 日历月
1y // 1 日历年

3d12h4m25s // 3天 12 小时 4 分钟又 25 秒

2、注意！持续时间的声明不要包含先导 0比如：

01m // 解析为整数 0 和 1 分钟的持续时间
02h05m //解析为整数 0 、 2 小时的持续时间，整数 0 和 5 分钟的持续时间。而不是 2小时又 5 分钟

5.1.3.2 将其他数据类型解释为持续时间

1、使用duration( )函数可以将以下基本数据类型转换为持续时间

2、字符串：将表示持续时间字符串的函数转换为持续时间。

3、int：将整数先解释为纳秒再转换为持续时间

4、unit：将整数先解释为纳秒再转换为持续时间。

duration(v: "1h30m")
// Returns 1h30m
duration(v: 1000000)
// Returns 1ms
duration(v: uint(v: 3000000000))
// Returns 3s

注意！你可以在FLUX语言中使用duration类型的变量与时间做运算，但是你不能在table中创建duration类型的列。

5.1.3.3 duration的算术运算

1、要对duration进行加法、减法、乘法或除法操作，需要按下面的步骤来。

• 使用int( )或unit()将持续时间转换为int数值
• 使用算术运算符进行运算
• 把运算的结果再转换回Duration类型

2、示例：

duration(v: int(v: 6h4m) + int(v: 22h32s))
// 返回 1d4h4m32s

duration(v: int(v: 22h32s) - int(v: 6h4m))
// 返回 15h56m32s

duration(v: int(v: 32m10s) * 10)
// 返回 5h21m40s

duration(v: int(v: 24h) / 2)
// 返回 12h

注意！声明持续时间的时候不要包含前导 0 ，前面的零会被FLUX识别为整数

5.1.3.4 时间和持续时间相加运算

1、导入date包

2、使用date.add( )函数将持续时间和时间相加

3、示例：

import "date"

date.add(d: 1w, to: 2021 - 01 - 01T00:00:00Z)
// 2021- 01 - 01 加上一周
// Returns 2021- 01 - 08T00:00:00.000000000Z

5.1.3.5 时间和持续时间相减运算

1、导入date包

2、使用date.add( )函数从时间中减去持续时间

3、示例：

import "date"
date.sub(d: 1w, from: 2021- 01 - 01T00:00:00Z)
// 2021- 01 - 01 减去一周
// Returns 2020- 12 - 25T00:00:00.000000000Z

5.1.4 Regular expression 正则表达式

5.1.4.1 定义一个正则表达式

1、 FLUX语言是GO语言实现的，因此使用GO的正则表达式语法。正则表达式需要声明在正斜杠之间 / /

5.1.4.2 使用正则表达式进行逻辑判断

1、使用正则表达式进行逻辑判断，需要使用 =~ 和 != 操作符。=~ 的意思是左值（字符串）能够被右值匹配，!~表示左值（字符串）不能被右值匹配。

"abc" =~ /\w/
// Returns true
"z09se89" =~ /^[a-z0-9]{7}$/
// Returns true
"foo" !~ /^f/
// Returns false
"FOO" =~ /(?i)foo/
// Returns true

5.1.4.3 将字符串转为正则表达式

1、引入regexp包
2、使用regexp.compile( ) 函数可以将字符串转为正则表达式

import "regexp"

regexp.compile(v: "^// Returns ^- [a-z0--9]{7} (regexp type) [a-z0-9]{7}") (^)

5.1.4.4 将匹配的子字符串全部替换

1、引入regexp包

2、使用regexp.replaceAllString( )函数，并提供下列参数：

• r：正则表达式
• v：要搜索的字符串
• t： 一旦匹配，就替换为该字符串

3、示例：

import "regexp"
regexp.replaceAllString(r: /a(x*)b/, v: "-ab-axxb-", t: "T")
// Returns "-T-T-"

5.1.4.5 得到字符串中第一个匹配成功的结果

1、导入regexp包

2、使用 regexp.findString( )来返回正则表达式匹配中的第一个字符串，需要传递以下参数：

• r：正则表达式
• v：要进行匹配的字符串

3、示例：

import "regexp"
regexp.findString(r:"abc|bcd",v:"xxabcwwed")

// Returns "abc"

5.1.5 String 字符串

5.1.5.1 定义一个字符串

1、字符串类型表示一个字符序列。字符串是不可改变的，一旦创建就无法修改。

2、字符串是一个由双引号括起来的字符序列，在FLUX中，还支持你用\x作为前缀的十六进制编码来声明字符串。

3、示例：

"abc"
"string with double " quote"
"string with backslash \"
"日本語"
"\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e"

5.1.5.2 将其他基本数据类型转换为字符串

1、使用srting( )函数可以将下述基本类型转换为字符串：

• boolean 布尔值
• bytes 字节序列
• duration 持续时间
• float 浮点数
• uint 无符号整数
• time 时间

string(v: 42)
// 返回 "42"

5.1.5.3 将正则表达式转换为字符串

1、因为正则表达式也是一个基本数据类型，所以正则表达式也可以转换为字符串，但是需要借助额外的包。

• 引入regexp包
• 使用regexp.compile( )

5.1.6 Time 时间点

5.1.6.1 定义一个时间点

1、一个time类型的变量其实是一个纳秒精度的时间点。

2、示例：

时间点必须使用RFC3339的时间格式进行声明

YYYY-MM-DD
YYYY-MM-DDT00:00:00Z
YYYY-MM-DDT00:00:00.000Z

5.1.6.2 date包

1、date包里的函数主要是用来从Time类型的值里提取年月日秒等信息的。比如date.hour：

import "date"
x = 2020-01-01T19:22:31Z
date.hour(t:x)
//Returns 19

5.1.7 Float 浮点数

5.1.7.1 定义一个浮点数

1、FLUX中的浮点数是 64 位的浮点数。

2、一个浮点数包含整数位，小数点，和小数位。

3、示例：

0.0
123.4
-123.456

5.1.7.2 科学计数法

1、FLUX没有直接提供科学计数法语法，但是你可以使用字符换写出一个科学计数法表示的浮点数，再使用float( )函数将该字符串转换为浮点数。

2、示例：

1.23456e+78
// Error: error @1:8-1:9: undefined identifier e
float(v: "1.23456e+78")
// Returns 1.23456e+78 (float)

5.1.7.3 无限

1、FLUX也没有提供关于无限的语法，定义无限要使用字符串与float( )函数结合的方式。

2、示例：

+Inf
// Error: error @1:2-1:5: undefined identifier Inf
float(v: "+Inf")
// Returns +Inf (float)

5.1.7.4 Not a Number 非数字

1、FLUX语言不支持直接从语法上声明NAN，但是你可以使用字符串与float( )函数的方法声明一个NaN的float类型变量。

2、示例：

NaN

// Error: error @1:2-1:5: undefined identifier NaN

float(v: "NaN")// Returns NaN (float) (^)

5.1.7.5 将其他基本类型转换为float

1、使用float函数可以将基本数据类型转换为float类型的值。

类型	说明
string	必须得是一个符合数字格式的字符串或者科学计数法。
bool	true转换为 1 .0，false转换为 0 .0
int	（整数）
uint	（无符号整数）

2、示例：

float(v: "1.23")
// 1.23
float(v: true)
// Returns 1.0
float(v: 123)
// Returns 123.0

5.1.7.6 对浮点数进行逻辑判断

1、使用FLUX表达式来比较浮点数。逻辑表达式两侧必须是同一种类型。

2、示例：

12345600.0 == float(v: "1.23456e+07")// Returns true

1.2 > -2.1
// Returns true

5.1.8 Integer 整数

5.1.8.1 定义一个整数

1、一个integer的变量是一个 64 位有符号的整数。

2、类型名称：int

• 最小值：- 9223372036854775808
• 最大值： 9223372036854775807

3、一个整数的声明就是普通的整数写法，前面可以加 - 表示负数。- 0 和 0 是等效的。

4、示例：

0
2
1254
- 1254

5.1.8.2 将数据类型转换为整数

1、使用int( )函数可以将下述的基本类型转换为整数：

类型	说明
string	字符串必须符合整数格式，由数字[ 0 - 9]组成
bool	true返回 1 ， 0 返回false
duration	返回持续时间的纳秒数
time	返回时间点对应的Unix时间戳纳秒数
float	返回小数点前的整数部分，也就是截断
unit	返回等效于无符号整数的整数，如果超出范围，就会发生整数环绕

int(v: "123")// 123

int(v: true)
// Returns 1
int(v: 1d3h24m)
// Returns 98640000000000

int(v: 2021// Returns 1609459200000000000- 01 - 01T00:00:00Z) (^)
int(v: 12.54)
// Returns 12

2、你可以在将浮点数转换为整数之前进行舍入操作。当你将浮点数转换为整数时，会进行截断操作。如果你想进行四舍五入，可以使用math包中的round( )函数。

5.1.8.3 将表示十六进制数字的字符串转换为整数

将表示十六进制数字的字符串转换为整数，需要。

• 引入contrib/bonito-io/hex包
• 使用hex.int( )函数将表示十六进制数字的字符串转换为整数

import "contrib/bonitoo-io/hex"
hex.int(v: "e240")
// Returns 123456

5.1.9 UIntegers 无符号整数

1、FLUX语言里不能直接声明无符号整数，但这却是一个 InfluxDB中具备的类型。在FLUX语言中，我们需要使用uint函数来讲字符串、整数或者其他数据类型转换成无符号整数。

2、示例：

uint(v: "123")
// 123

uint(v: true)
// Returns 1
uint(v: 1d3h24m)
// Returns 98640000000000
uint(v: 2021- 01 - 01T00:00:00Z)
// Returns 1609459200000000000
uint(v: 12.54)
// Returns 12
uint(v: -54321)
// Returns 18446744073709497295

5.1.10 Null 空值

5.1.10.1 定义一个Null值

1、FLUX语言并不能在语法上直接支持声明一个Null，但是我们可以通过debug.null这个函数来声明一个指定类型的空值。

2、示例：

import "internal/debug"
// Return a null string
debug.null(type: "string")
// Return a null integer
debug.null(type: "int")

// Return a null booleandebug.null(type: "bool")

5.1.10.2 定义一个null

1、截至目前，还无法在FLUX语言中手动地声明一个NULL值。

注意！空字符串不是null值

5.1.10.3 判断值是否为null

1、你可以使用exists（存在）这个关键字来判断目标值是不是非空，如果是空值我们会得到一个false，如果不是空值我们会得到一个true。

2、示例：

import "array"
import "internal/debug"
x = debug.null(type: "string")
y = exists x
// Returns false

5.1.11 正则表达式类型

1、正则表达式在FLUX中作为一种数据类型，而且在语法上提供直接的支持，可以在谓词表达式中使用正则表达式。

2、 示例：

regex = /^foo/
"foo" =~ regex
// Returns true
"bar" =~ regex
// Returns false

5.1.12 display函数

1、使用display( )函数可以将任何类型的值输出为相应的字符串类型。

2、示例：

x = bytes(v: "foo")
display(v: x)
// Returns "0x666f6f"

5.2 FLUX类型不代表InfluxDB类型

1、需要注意，FLUX语言里有些基本数据类型比如持续时间(Duration)和正则表达式是不能放在表流里面充当字段类型的。简单来说，Duration类型和正则表达式类型都是FLUX语言特有的。有些类型是为了让 FLUX在编写代码时更加方便，让它能够拥有更多的特性，但这并不代表这些类型能够存储到InfluxDB中。

5.3 4 个复合类型

5.3.1 Record（记录）

5.3.1.1 定义一个Record

1、一个记录是一堆键值对的集合，其中键必须是字符串，值可以是任意类型，在键上没有空白字符的前提下，键上的双引号可以省略。在语法上，record需要使用{}声明，键值对之间使用英文逗号（,）分开。另外，一个Record的内容可以为空，也就是里面没有键值对。

2、示例：

{foo: "bar", baz: 123.4, quz: -2}
{"Company Name": "ACME", "Street Address": "123 Main St.", id:1123445}

5.3.1.2 从record中取值

1、点表示法 取值 ，如果key中没有空白字符，那么你可以使用 .key 的方式从record中取值。

示例：

c = {name: "John Doe", address: "123 Main St.", id: 1123445}
c.name
/ / Returns John Doe
c.id
// Returns 1123445

2 、 中括号方式取值，可以使用[" "]的方式取值，当key中有空白字符的时候，也只能用这种方式来取值。

c = {"Company Name": "ACME", "Street Address": "123 Main St.", id:
1123445}
c["Company Name"]
// Returns ACME
c["id"]
// Returns 1123445

5.3.1.3 嵌套与链式取值

1、Record类型可以进行嵌套引用。从嵌套的Record中引用值的时候可以采用链式调用的方式。链式调用时，点表示法和中括号还可以混用。

5.3.1.4 record的key是静态的

1、record类型变量中的key是静态的，一旦声明，其中的key就被定死了。一旦你访问这个record中一个没有的key，就会直接抛出异常。正常的话应该返回null。

o = {foo: "bar", baz: 123.4}
o.key
// Error: type error: record is missing label haha
// 错误：类型错误：record找不到haha 这个标签

5.3.1.5 操作records

1、拓展一个record使用 with 操作符可以拓展一个record，当原始的record中有这个key时，原先record的值会被覆盖；如果原先的record中没有制定的key，那么会将旧record中的所有元素和with中指定的元素复制到一个新的record中。

2、示例： 覆盖原先的值，并添加一个key为pet，value为"Spot"的元素。

c = {name: "John Doe", id: 1123445}
{c with name: "Xiao Ming", pet: "Spot"}
// Returns {id: 1123445, name: Xiao Ming, pet: Spot}

5.3.1.6 列出一个record中所有的keys

1、导入experimental（实验的）包。

2、使用expertimental.objectyKeys(o:c)方法来拿到一个record的所有key。

3、示例：

import "experimental"
c = {name: "John Doe", id: 1123445}
experimental.objectKeys(o: c)
// Returns [name, id]

5.3.1.7 比较两个record是否相等

1、可以使用双等号= =来判断两个record是否相等。如果两个 record的每个key，每个key对应的value和类型都相同，那么两个record就相等。

2、示例：

{id: 1, msg: "hello"} == {id: 1, msg: "goodbye"}
// Re turns false
{foo: 12300.0, bar: 34500.0} == {bar: float(v: "3.45e+04"), foo:
float(v: "1.23e+04")}
// Returns true

5.3.1.8 将record转为字符串

1、使用display( )函数可以将record转为字符串。

2、示例：

x = {a: 1, b: 2, c: 3}
display(v: x)
// Returns "{a: 1, b: 2, c: 3}"

5.3.1.9 嵌套Record的意义

1、注意，嵌套的Record无法放到FLUX语言返回的表流中，这个时候会发生类型错误，它会说Record类型不能充当某一列的类型。那FLUX为什么还支持对Record进行嵌套使用呢？其实这是为了一些网络通讯的功能来服务，在FLUX语言中我们有一个http库。借助这个函数库，我们可以向外发送 http post请求，而这种时候我们就有可能要发送嵌套的json。细心的同学可能发现，我们的 record在语法层面上和 json语法是统一的，而且FLUX语言提供了一个json函数库，借助这个库中的encode函数，我们可以轻易地将一个record转为json字符串然后发送出去。

5.3.2 Array（数组）

5.3.2.1 定义一个Array

1、数据是一个由相同类型的值构成的有序序列。 在语法上，数组是用方括号[ ]起来的一堆同类型元素，元素之间用英文逗号( , )分隔，并且类型必须相同。

2、示例：

["1st", "2nd", "3rd"]
[1.23, 4.56, 7.89]
[10, 25, -15]

5.3.2.2 从Array中取值

1、可以使用中括号 [ ] 加索引的方式从数组中取值，数组索引从 0 开始。

2、示例：

arr = ["one", "two", "three"]

arr[0]
// Returns one
arr[2]
// Returns two

5.3.2.3 遍历一个数组

5.3.2.4 检查一个数组中是否包含某元素

1、示例

2、使用contains( )函数可以检查一个数组中是否包含某个元素。

names = ["John", "Jane", "Joe", "Sam"]
contains(value: "Joe", set: names)
// Returns true

5.3.3 Dictionary（字典）

5.3.3.1 定义一个字典

1、字典和记录很像，但是key-value上的要求有所不同。一个字典是一堆键值对的集合，其中所有键的类型必须相同，且所有值的的类型必须相同。在语法上，dictionary需要使用方括号[ ]声明，键的后面跟冒号（:）键值对之间需要使用英文逗号（ , ）分隔。

2、示例：

[0: "Sun", 1: "Mon", 2: "Tue"]
["red": "#FF0000", "green": "#00FF00", "blue": "#0000FF"]
[1.0: {stable: 12, latest: 12}, 1.1: {stable: 3, latest: 15}]

5.3.3.2 引用字典中的值

1、导入dict包

2、使用dict.get( )并提供下述参数:

• dict：要取值的字典
• key：要用到的key
• default：默认值，如果对应的key不存在就返回该值

3、示例

import "dict"
positions =
[
"Manager": "Jane Doe",
"Asst. Manager": "Jack Smith",
"Clerk": "John Doe",
]
dict.get(dict: positions, key: "Manager", default: "Unknown
position")
// Returns Jane Doe
dict.get(dict: positions, key: "Teller", default: "Unknown
position")
// Returns Unknown position

5.3.3.3 从列表创建字典

1、导入dict包

2、使用dict.fromList( )函数从一个由records组成的数组中创建字典。其中，数组中的每个record必须是{key:xxx,value:xxx}形式

3、示例：

import "dict"
list = [{key: "k1", value: "v1"}, {key: "k2", value: "v2"}]
dict.fromList(pairs: list)
// Returns [k1: v1, k2: v2]

5.3.3.4 向字典中插入键值对

1、导入dict包

2、使用dict.insert( )函数添加一个新的键值对，如果key早就存在，那么就会覆盖这个key对应的value。

3、示例：

import "dict"
exampleDict = ["k1": "v1", "k2": "v2"]
dict.insert(dict: exampleDict, key: "k3", value: "v3")// Returns [k1: v1, k2: v2, k3: v3]

5.3.3.5 从字典中移除键值对

1、引入dict包

2、使用dict.remove方法从字典中删除一个键值对

3、示例：

import "dict"
exampleDict = ["k1": "v1", "k2": "v2"]
dict.remove(dict: exampleDict, key: "k2")
// Returns [k1: v1]

5.3.4 function（函数）

5.3.4.1 声明一个函数

1、一个函数是使用一组参数来执行操作的代码块。函数可以是命名的，也可以是匿名的。

2、在小括号( )中声明参数，并使用箭头=>将参数传递到代码块中。

3、 示例：

square = (n) => n * n
square(n:3)
// Returns 9

FLUX不支持位置参数。调用函数时，必须显示指定参数名称。

5.3.4.2 为函数提供默认值

1、我们可以为某些函数指定默认值，如果为函数指定了默认值，也就意味着在调用这个函数时，有默认值的函数时非必须的。

2、示例：

chengfa = (a,b=100) => a* b
chengfa(a:3)
// Returns 300

5.4 函数包

1、Flux的标准库使用包组织起来的。包将Flux的众多函数分门别类，默认情况下加载universe包，这个包中的函数可以不用import直接使用。其他包的函数需要在你的Flux脚本中先用import语法导入一下。

2、示例：

import "array"
import "math"
import "influxdata/influxdb/sample"

3、但是，截至目前，虽然你可以自定义函数，但是你无法自定义包。如果希望将自己的
自定义函数封装在一个包里以供复用，那就必须从源码上进行修改。