6 UB语言参考

6.3.1 数据类型

变量是编程语言中最基础的功能，变量中可以存放数字、字符串等值，并且可以在运行的过程中，随时改变变量中的值。UB语言中的变量是动态类型的，即变量的值和类型都可以在运行过程中动态改变。这符合一般脚本型语言如Python、JavaScript的习惯。变量的类型分为以下几种：整数型、浮点数型、布尔型、字符串型、函数型、复合型和空值型。

整数型的值可以以十进制或者十六进制的方式表示，其中十六进制需加前缀 &H 或 &h。

浮点数的值可以用常规方式或者科学计数法方式表示。如 0.01 或者 1E-2 或者 1e-2 均代表同一个浮点数。

布尔型的值仅有 True 或者 False，两者皆不区分大小写。

字符串型的值用一对单引号（'）或一对双引号（"）所包围，字符串中可以用 \t 代表制表符，用 \n 代表换行，用 \' 代表单引号，用 \" 代表双引号，用 \\ 代表反斜杠本身（这种表示方式称为“转义”）。字符串中间可以直接换行，无需增加任何其他符号，换行符也会作为字符串的一部分。

也可以用前后各三个单引号（'''）来表示一个字符串，这种字符串被称为长字符串。在长字符串中，可以直接写回车符、单引号和双引号，无需用 \n，\' 或者 \" 进行转义。

函数型的值只能是已经定义好的函数，在后文详述。

复合型的值包括数组、字典等，在下一节详细阐述。

空值型的值总是 Null，不区分大小写。

例如：

a = 1           // a是整数型变量
a = &HFF        // a还是整数型变量
a = True        // a是布尔型变量。作为动态类型语言，a的类型可以随时变化 
a = FALSE       // a是布尔型变量，注意True和False都不区分大小写
a = 'UiBot'     // a是字符串型变量
a = "UiBot
RPA"            // a是字符串型变量，字符串中可以换行
a = null        // a是空值型变量，可以写为Null、NULL或null（不区分大小写）

6.3.2 变量和常量

变量的定义方式是：

Dim 变量名

定义变量名的同时，可以给变量赋值一个初始值：

Dim 变量名=值

想要定义多个变量的话，可以这样定义：

Dim 变量名1 = 值1, 变量名2
Dim 变量名1 = 值1, 变量名2 = 值2

常量的定义方式和变量类似，只是把Dim改为Const，并且必须在定义时就指定值：

Const 常量名=值, 常量名=值

常量和变量的唯一区别是，常量只能在定义时指定一次值，后面不允许再修改。

例如：

Dim a               // 定义名为a的变量，暂不赋值
Dim b = 1           // 定义名为b的变量，并赋值为1 
Dim c, d = True     // 定义名为c和d的两个变量，为d赋值True
Const e = 'UiBot'   // 定义名为e的常量，为其赋值为字符串’UiBot’
Const f             // 错误：常量必须有初始赋值

对于有命名的变量、常量、函数等，其名字统称为标识符，标识符需要遵循一定规则定义。

标识符可以用英文字母、下划线（_），任意UTF-8编码中包含的除英语以外其他语言的字符（当然，也包括汉字）来表示，除了第一个字符外，后面还可以使用0-9的数字。当使用英文字母时，变量名不区分大小写。

UB语言推荐变量经过定义再使用（除了For语句中的循环变量、Try语句中的异常变量、函数参数等）。变量在函数范围内定义时，属于局部变量，在函数退出时即清空。在函数范围之外任何位置定义时，属于流程块级变量，在一个流程块的运行过程中都不会清空。流程块级变量可以定义在函数范围外任何位置，不影响其使用，甚至可以在使用变量之后定义。

如果变量未经定义而直接使用，UiBot也不会报错，但会有一个警告提示。这个警告能避免您在输入变量名时产生手误，比如把变量名 cat 误输入成为了 cart，通过警告信息，您就会发现 cart 是未经定义的，并进一步查出是因为手误所致。

6.3.3 复合类型

除了常用的整数型、字符串型等简单数据类型之外，UiBot还支持两种复合类型：数组、字典。两者在定义时和简单数据类型变量的定义并无区别。

数组类型变量的表示方法为：使用小写方括号包围起来，使用逗号来分隔每个元素，和 VBScript 中的数组定义类似。范例：

Dim 数组变量 = [值1, 值2, 值3, 值4]

同一个数组中的多个元素的值可以是任意类型，例如：元素的值是整数，就构成一个整数数组；同一个数组中的多个元素也可以是不同类型，例如：第一个元素是整数，第二个元素是字符串等；甚至，一个数组中的元素也可以是另外一个数组，这样就构成了一般意义上的多维数组。范例：

Dim 数组变量 = [值 1, 值 2, [值 11, 值 22], 值 4]

字典类型变量的表示方法为：使用大括号来包围起来，名字和其对应的值为一对，用逗号分隔。范例：

{ 名字1:值1, 名字2:值2, 名字3:值3 }

其中 名字 只能是字符串，值 可以是任意类型的表达式。如果您熟悉 JavaScript 或者 JSON，会发现这种初始化方法和 JSON 的表示形式高度相似。

数组和字典类型变量的使用方法为：无论是数组还是字典，要引用其中的元素，均采用方括号作为索引。范例：

变量名[索引1]

使用这种方法引用数组或者字典中的元素，既可以作为左值也可以作为右值，也就是说，既可以读取该变量的值，也可以为该变量的内容赋值，甚至可以在其中增加新的值。范例：

Dim 变量 = [486, 557, 256]                      // 变量可以用中文命名，初值是一个数组
a = 变量[1]                                     // 此时a被赋值为557
变量 = {"key1":486, "key2":557, "key3":256}     // 变量的类型改为一个字典
a = 变量["key1"]                                // 此时a被赋值为486

注意：在引用数组或字典中的元素时，数组的索引只能是整数类型，用0作为起始索引；字典的索引只能是字符串类型。如果未能正确的使用，会在运行时报错。

数组或者字典的引用是可以嵌套的，如果要引用数组中的数组（即多维数组），或者字典中的数组，可以继续在后面写新的方括号。范例：

变量 = {"key1":486, "key2":557, "key3":256}     // 变量的类型为一个字典
变量["key4"] = [235, 668]                       // 往字典中增加一个新值，该值是一个数组
//此时，字典中的内容为 {"key1":486, "key2":557, "key3":256, "key4":[235, 668]}
a = 变量["key4"][0]                             // 此时a被赋值为235

6.5.1 条件分支语句

即一般编程语言中最常用的If…Else语句，主要用于对某一个或者多个条件进行判断，从而执行不同流程。在UB语言中，有以下几种形式：

If 条件
    语句块1
End If

If 条件
    语句块1
Else
    语句块2
End If

If 条件1
    语句块1
ElseIf 条件2
    语句块2
Else
    语句块3
End If

当条件满足时，会执行条件之后的语句块，否则，语句块不会执行。Else后面的语句块则会在前面所有条件都不满足的时候，才会执行。

例如：

// Time.Hour() 可以取得当前时间中的小时数
// TracePrint() 可以把指定的内容输出到UiBot的输出栏中

If Time.Hour() > 18             // 取得当前时间中的小时数
    TracePrint("下班时间")      // 如果大于18，则执行这里的语句
Else
    TracePrint("上班时间")      // 如果不满足前面的条件，则执行这里的语句
End If

6.5.2 选择分支语句

根据一定的条件，选择多个分支中的一个。先计算Select Case后面的表达式，然后判断是否有某个Case分支和这个表达式的值是一致的。如果没有一致的Case分支，则执行Case Else（如果有）后面的语句块。

Select Case 表达式
    Case 表达式1, 表达式2
        语句块1
    Case 表达式3, 表达式4
        语句块2
    Case Else
        语句块3
End Select

例如：

Select Case Time.Month()            // 取得当前时间中的月份
    Case 1,3,5,7,8,10,12            // 如果是1、3、5、7、8、10、12月
        DayOfMonth = 31             // 当月有31天
    Case 4,6,9,11                   // 如果是4、6、9、11月
        DayOfMonth = 30             // 当月有30天
    Case Else                       // 如果是其他（也就是2月）
        DayOfMonth = 28             // 当月有28天（不考虑闰年的情况）
End Select
TracePrint(DayOfMonth)

6.5.3 条件循环语句

在UB语言中，使用Do…Loop语句来实现条件循环，即满足一定条件时，循环执行某一语句块。Do…Loop语句有以下五种不同的形式，用法较为灵活：

1. 前置条件成立则循环：先判断条件，条件成立则循环执行语句块，否则自动退出循环。

Do While 条件
    语句块
Loop

2. 前置条件不成立则循环：和前一条相反，条件成立则退出循环，否则循环执行语句块。

Do Until 条件
    语句块
Loop

3. 后置条件成立则循环：先执行语句块，再判断条件，条件成立则继续循环执行语句块，否则自动退出循环。

Do
    语句块
Loop While 条件

4. 后置条件不成立则循环：先执行语句块，再判断条件，条件成立则自动退出循环，否则继续循环执行语句块。

Do 
    语句块
Loop Until 条件

5. 无限循环：该循环语句本身不进行任何条件的判断，需要在语句块中自行做判断，如果语句块中没有跳出循环的语句，则会无限的执行该循环

Do
    语句块
Loop

例如：

Do Until Time.Hour() > 18              // 判断当前时间中的小时数，只要不大于18就循环
    TracePrint("还没有到下班时间")      // 每次循环，都会执行这里的语句
    Delay(1000)                        // 每判断一次，休息一秒钟
Loop
TracePrint("下班时间到啦")              // 如果大于18，则跳出循环，执行这里的语句

6.5.4 计次循环语句

计次循环语句主要用于执行一定次数的循环，其基本形式为：

For 循环变量 = 起始值 To 结束值 Step 步长
    语句块
Next

在计次循环语句中，起始值、结束值、步长都只允许是整数型或者浮点数型；步长可以省略，默认值为1。变量从起始值开始，每循环一次自动增加步长，直到大于结束值，循环才会结束。

在计次循环语句中，循环变量可以不用Dim语句定义，直接使用，但在循环结束后就不能再使用了。

例如：

Dim count = 0               // 定义变量count
For i=1 To 100              // 每次循环，变量i都会加1。这里变量i不需要定义
    count = count + i
Next
TracePrint(count)           // 这里会显示1+2+3+…+100的结果，即5050

6.5.5 遍历循环语句

遍历循环语句可以用于处理数组、字典中的每一个元素。遍历循环语句有以下两种形式：

For Each 循环变量 In 数组或字典
    语句块
Next

在这种形式的循环语句中，会自动遍历数组、字典中的每一个值，并将其置入循环变量中，直到遍历完成为止。

或者：

For Each 循环变量1, 循环变量2 In 数组或字典
    语句块
Next

在这种形式的循环语句中，会自动遍历数组、字典中的每一个索引和值，并将其分别置入循环变量1、循环变量2中，直到遍历完成为止。

和计次循环语句类似，在遍历循环语句中，循环变量可以不用Dim语句定义，直接使用，但在循环结束后就不能再使用了。

例如：

Dim days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] // 定义数组型变量days
Dim count = 0   
For Each i In days             // 每次循环，变量i的值分别为days中的每个值 
    count = count + i          // 把数组中的每个值依次加起来
Next
TracePrint(count)              // 这里会显示一年中每个月的天数的累加和，即365

6.5.6 跳出语句

在UB语言中，支持以下形式的循环跳出语句：

Break

只能出现在条件循环、计次循环或遍历循环等循环语句的内部语句块中，其含义是立即跳出当前循环。

Continue

只能出现在条件循环、计次循环或遍历循环等循环语句的内部语句块中，其含义是立即结束当前循环，并开始下一次循环。

例如：

Dim days = { '一月':31, '二月':28, '三月':31, 
             '四月':30, '五月':31, '六月':30, 
             '七月':31, '八月':31, '九月':30, 
             '十月':31, '十一月':30, '十二月':31 }  // 定义字典型变量days

For Each i,j In days            // 每次循环，变量i, j分别为days中每个名字和值
    If j Mod 2 = 0              // 如果j是偶数
           Continue             // 结束本次循环，开始下一次循环
    End If
    TracePrint(i)               // 把days中的名字（其值不是偶数）显示出来
Next

另外，在流程块中的任何地方，只需要书写

Exit

不需要任何参数，即可在执行到此行的时候，自动结束整个流程（不是当前流程块）的执行。

6.7.1 多模块

UB语言支持多模块，可以在UB语言中，调用另一个用UB语言编写的流程块。虽然UB语言并未规定扩展名，但如果要调用另一个UB语言的流程块，则两个流程块需要有相同的扩展名。

我们把被调用的流程块称为“模块”，则去掉扩展名以后，剩下的文件名就是模块的名字。比如某个流程块的文件名为UBTest.task，则其模块名为UBTest。

在UB语言中，采用以下方式导入一个模块：

Import 模块名

注意这里的模块名的书写规则和变量名一致，不需要采用双引号，也不需要加扩展名。如Import UBTest。UiBot在编译和运行时会自动按照当前流程块文件的扩展名，为其补充扩展名，并在当前目录下查找。在Windows中，由于文件名不区分大小写，所以Import语句后面的模块名也可以不区分大小写。在其他操作系统中，需要注意模块名的大小写要和文件一致。

每个导入的模块，都会被放置在一个与模块名同名的“命名空间”中，可以通过下面这种方式来调用导入模块中的函数：

命名空间.函数名

即在命名空间和函数名之间加一个点号（.）进行分隔。

导入一个模块之后，既可以调用模块中定义的函数，又可以直接以模块名作为函数名，直接运行这个流程块中的所有命令。例如，有一个流程块 ABC.task。在其他流程块中Import之后，直接采用下面的格式即可直接调用ABC.task（相当于运行了ABC.task这个流程块）：

ABC()

假设流程块 ABC.task中定义了一个函数，名为test，则可以采用下面的格式调用这个函数

ABC.test()

6.7.2 异常

作为动态类型语言，有很多错误在编译时难以检查，只能在运行时报错。而且，由于UiBot不强调运行速度，而更强调运行的稳定性，也会在运行时加入比较多的检查。当出错的时候，比较合适的报错手段是抛出异常。 比如，对于界面元素自动化中的“有目标命令”，在运行的时候，如果到了超时时间都不能找到目标，就会自动抛出一个异常。

除了自动抛出的异常之外，在流程块中，还可以采用Throw语句抛出一个异常：

Throw 字符串

在抛出异常时，可以把异常相关信息以字符串的形式一起抛出，也可以省略这个字符串。

如果在流程块中没有对异常进行处理，当出现异常时，整个流程都会终止执行，并且把异常相关信息显示出来。如下图所示：

如果不希望流程在发生异常的时候终止，可以采用以下语句对异常进行处理：

Try
    语句块
Catch 变量名
    语句块
Else
    语句块
End Try

如果在Try后面的语句块中发生了异常，会跳到Catch后面的语句块中执行。如果在Try语句块中没有发生异常，且定义了Else语句块（当然，也可以省略Else语句块），则会跳到Else语句块中执行。

Catch语句后面的变量名可以省略。如果不省略，可以不用Dim语句提前定义，当发生异常时，这个变量的值是一个字典，其中包含“File”、“Line”和“Message”三个字段，分别代表发生异常的文件名、发生异常的行号、异常包含的信息。

对于界面元素自动化来说，有的时候可能会因为界面卡顿等引起失败，实际上再试一次可能又正常了。因此，在Try语句后面，还可以加一个“重试次数”。如下所示：

Try N
    语句块1
Catch 变量名
    语句块2
Else
    语句块3
End Try

这里的N可以是变量、表达式或常量，但通常应为整数类型。其含义是：

在Try和Catch之间的语句（如上例中的“语句块1”），如果发生了异常，会自动回到Try的地方去重试，当重试N次之后，如果仍然有异常，才会跳到Catch后面的语句（如上例中的“语句块2”）去执行。 当在N次尝试中，只要有1次成功了，就不会再继续后面的尝试（比如第1次异常，第2次没有异常，就不会再试第3次了），而是跳到Else后面的语句（如上例中的“语句块3”）去执行。