畅链科技文档

简体中文

English

简体中文

English

外观

脚本使用手册 - BNF 语法 ​

语法风格总览 ​

脚本支持两种等价的语法风格，可按需选择。

新语法（推荐，{ } 块） ​

  • 每条语句行必须以 w: 开头（包括控制流的 { } 行和块内子语句）
  • 文本输出行不以 w: 开头（含 {{ }} 插值的行）
  • 支持 w:// 或 w:rem 行注释
  • 语句结尾无需分号
  • 控制流关键字：
    • if
    • else if
    • else
    • switch
    • case
    • default
    • for
    • while
    • try
    • catch
    • finally
    • throw
    • break
    • continue
    • export
    • expr
    • rem
  • 数据：
    • 整数
    • 浮点
    • 字符串
    • 布尔（true / false）
    • null
    • 数组
    • 字典（含匿名 / 多维）
  • 变量：
    • 定义 :=
    • 赋值 =
    • 引用 $var / ${var}
  • 文本行与语句行可混写，插值：{{ 表达式 }}
text
The value of x is {{ x }}, 2 + 3 is {{ 2 + 3 }}.

旧语法（兼容，w:end 块） ​

  • 行式指令，每条以 w: 开头，块用 w:if ... w:end 闭合
  • 关键字：
    • w:set
    • w:if
    • w:elif
    • w:else
    • w:end
    • w:while
    • w:for
    • w:break
    • w:switch
    • w:case
    • w:default
    • w:export
    • w:expr
  • 文本行与语句行可混写，插值 {{ var }}
text
The value of x is {{ x }}.

BNF 语法 ​

说明：BNF 中使用 ::= 表示"定义为"，| 表示"或"，{ } 表示可重复零次或多次，[ ] 表示可选，< > 包裹非终结符。

词法定义（Lexical Definitions） ​

常量 ​

  • <string_quote> 表示字符串的引号界定符。
::= "
  • <string_constant> 表示字符串字面量，用双引号包围。
::= <string_quote> 字符串字面量 <string_quote>
  • <number_constant> 表示数字字面量，支持整数和浮点数。
::= 整数 / 浮点字面量（123、123.456）
  • <boolean_constant> 表示布尔字面量，只有 true / false 两个值。
::= true | false
  • <null_constant> 表示空值字面量。
::= null
  • <constant> 表示常量，可以是字符串、数字、布尔值或空值。
::= <string_constant> | <number_constant> | <boolean_constant> | <null_constant>

运算符 ​

  • <define_op> 表示定义运算符，用于定义新变量。若变量已存在则报错。
::= ":="
  • <assign_op> 表示赋值运算符，用于给变量赋值。若变量不存在则在全局作用域定义。
::= "="
  • <operator> 表示支持的运算符集合，涵盖算术、位、逻辑、赋值复合、三目等。
::= "++" | "--" | "+" | "-" | "*" | "/" | "%" | "&&" | "||" | "~" | "!"
 | "&" | "|" | "^" | "<<" | ">>" | ">>>"
 | "+=" | "-=" | "*=" | "/=" | "%=" | "&=" | "|=" | "^=" | "<<=" | ">>=" | ">>>="
 | "?:" | <define_op> | <assign_op>

标识符与引用 ​

  • <variable> 表示变量名，由字母和数字组成的标识符。
::= <identifier_body>
  • <reference> 表示变量引用，支持三种形式：裸引用、$var、${var}。
::= <variable> | "$" <variable> | "${" <variable> "}"

函数调用 ​

  • <function_expression> 表示函数调用表达式。
::= 函数名 "(" <expression> { "," <expression> }* ")"

集合字面量 ​

  • <array> 表示数组字面量，支持元素列表与范围表达式两种形式。
::= "[" <expression> { "," <expression> }* "]"   // [a, b, c]
 | "[" <expression> "~" <expression> "]"         // [1 ~ 10]
 | "[]"                                          // 空数组
  • <dictionary> 表示字典字面量，支持键值对、匿名值列表与多维嵌套。
::= "{" <dictionary_entry> { "," <dictionary_entry> }* "}"    // {"k": v, ...}
 | "{" <expression> { "," <expression> }* "}"                 // 匿名字典 {a, b, c}
 | "{}"                                                       // 空字典
  • <dictionary_entry> 表示字典中的键值对。
::= <expression> ":" <expression>     // key : value
  • <collection> 表示集合，可以是数组或字典。
::= <array> | <dictionary>

表达式 ​

  • <definition> 表示变量定义语句，使用 := 定义新变量。
::= <variable> <define_op> <expression>   // var := expr
  • <assignment_expr> 表示变量赋值语句，使用 = 给变量赋值。
::= <variable> <assign_op> <expression>   // var = expr
  • <expression> 表示表达式，可以是常量、变量、引用、函数调用、集合、定义、赋值，或由运算符连接的复合表达式。
::= <constant>
 | <variable>
 | <reference>
 | <function_expression>
 | <collection>
 | <definition>
 | <assignment_expr>
 | <expression> <operator> <expression>
  • <condition> 表示条件表达式，用括号包围。
::= "(" <expression> ")"     // (expr)
  • <interpolation> 表示文本行中的插值表达式，将表达式的值嵌入文本输出。两种语法共用。
::= "{{" <expression> "}}"
  • <text_line> 表示文本输出行，可包含插值。两种语法共用。
::= { <any_character> | <interpolation> }* <new_line>

基础记号 ​

<identifier_start> ::= A-Z | a-z
<identifier_part>  ::= A-Z | a-z | 0-9 | "_"
<identifier_body>  ::= <identifier_start> { <identifier_part> }*
<left_paren>       ::= "("
<right_paren>      ::= ")"
<comma>            ::= ","
<semicolon>        ::= ";"
<new_line>         ::= "\n" | "\r\n"
<any_character>    ::= 除换行符外的任意字符

新语法语句规则（{ } 块） ​

以 w: 起始，使用 { } 包裹子语句。

顶层结构 ​

<new_script>   ::= { "w:" <new_block> }*
<new_block>    ::= "{" { <new_statement> | <text_line> }* "}"
<new_statement>::= <definition>                       // var := expr
                 | <assignment_expr>                  // var = expr
                 | <if_statement_new>
                 | <switch_statement_new>
                 | <for_statement_new>
                 | <while_statement_new>
                 | <try_statement_new>
                 | <break_stmt_new>                   // break
                 | <continue_stmt_new>               // continue
                 | <throw_stmt_new>                   // throw expr
                 | <export_statement_new>
                 | <expression_statement>            // 独立表达式（如 ++i）
                 | <comment_line>                     // // 注释

注释与表达式语句 ​

<comment_line>        ::= "//" <any_character>* <new_line>     // 行注释
                        | "rem" <any_character>* <new_line>     // rem 注释
<expression_statement> ::= <expression>                          // 独立表达式（如 ++i）

IF / ELSE IF / ELSE ​

<if_statement_new> ::= "if" <condition> <new_block>
                     | "if" <condition> <new_block> "else" <new_block>
                     | "if" <condition> <new_block>
                       { "else" "if" <condition> <new_block> }*
                       [ "else" <new_block> ]

SWITCH / CASE / DEFAULT ​

<switch_statement_new> ::= "switch" <condition> "{"
                            { <case_clause_new> }*
                            [ <default_clause_new> ]
                          "}"
<case_clause_new>      ::= "case" <expression> ":" <new_block>
<default_clause_new>   ::= "default" ":" <new_block>

FOR ​

<for_statement_new> ::= "for" "(" <for_iterator_new> ")" <new_block>    // for (item : coll)
                      | "for" "(" <for_classic_new>  ")" <new_block>    // for (init; cond; upd)
                      | "for" "(" ")" <new_block>                        // for (;;)
<for_iterator_new>  ::= <variable> ":" <collection>
<for_classic_new>   ::= [ <assignment_expr> ] ";"            // 初始化仅支持 = 赋值，不支持 := 定义
                         [ <expression> ] ";"
                         [ <expression> | <assignment_expr> ]

WHILE ​

<while_statement_new> ::= "while" <condition> <new_block>

TRY / CATCH / THROW ​

<try_statement_new> ::= "try" <new_block>
                      | "try" "(" <resource_list> ")" <new_block>       // 自动释放资源
                      | "try" <new_block> "catch" <new_block>          // 捕获并忽略异常
                      | "try" <new_block> "catch" "(" <variable> ")" <new_block>
                      | "try" <new_block> "finally" <new_block>        // finally 块
                      | "try" <new_block> "catch" <new_block> "finally" <new_block>
                      | "try" <new_block> "catch" "(" <variable> ")" <new_block> "finally" <new_block>
<resource_list>      ::= <resource_definition> { ";" <resource_definition> }*
<resource_definition>::= <variable> "=" <function_expression>
<throw_stmt_new>     ::= "throw" <expression>

跳转语句 ​

<break_stmt_new>    ::= "break"
<continue_stmt_new> ::= "continue"

EXPORT ​

<export_statement_new> ::= "export" "("
                             [ <scope_keyword> <comma> ]
                             <export_argument_list>
                           ")"
<scope_keyword>        ::= "GLOBAL"                  // 等同于 GLOBAL_WORKFLOW，变量名前加 operation id 作为前缀
                         | "GLOBAL_SCRIPT"           // 当前脚本内共享
                         | "GLOBAL_OPERATION"         // 当前脚本 + OPERATION 共享
                         | "GLOBAL_WORKFLOW"          // 当前流程内共享
                         | "GLOBAL_DAEMON"            // 所有流程间共享
<export_argument_list> ::= <variable> "AS" <argument_alias>
                           { <comma> <variable> "AS" <argument_alias> }*
<argument_alias>       ::= <identifier_body>

旧语法语句规则（w:end 块） ​

行式指令，每条以 w: 开头，块以 w:end 闭合。

顶层结构 ​

<old_script>    ::= { <old_statement_line> | <text_line> }*
<content_block> ::= { <old_statement_line> | <text_line> }*

SET / EXPR ​

<old_set>   ::= "w:set" <left_paren> <old_set_body> <right_paren> <new_line>
<old_set_body> ::= <variable> <define_op> <expression>     // w:set (x := expr)
                  | <variable> <assign_op> <expression>    // w:set (x = expr)
<old_expr>  ::= "w:expr" <left_paren> <expression> <right_paren> <new_line>

IF / ELIF / ELSE ​

<old_if>   ::= "w:if" <left_paren> <expression> <right_paren> <new_line>
<old_elif> ::= "w:elif" <left_paren> <expression> <right_paren> <new_line>
<old_else> ::= "w:else" <new_line>
<old_end>  ::= "w:end" <new_line>

// 完整 if 结构
<old_if_statement> ::= <old_if> <content_block> <old_end>
                    | <old_if> <content_block> <old_else> <content_block> <old_end>
                    | <old_if> <content_block>
                      { <old_elif> <content_block> }*
                      [ <old_else> <content_block> ]
                      <old_end>

SWITCH / CASE / DEFAULT ​

<old_switch>  ::= "w:switch" <left_paren> <expression> <right_paren> <new_line>
<old_case>    ::= "w:case" [ <left_paren> ] <expression> [ <right_paren> ] ":" <new_line>
<old_default> ::= "w:default" ":" <new_line>

<old_switch_statement> ::= <old_switch>
                           { <old_case> <content_block> }*
                           [ <old_default> <content_block> ]
                           <old_end>

FOR ​

<old_for>    ::= "w:for" <left_paren> <old_for_body> <right_paren> <new_line>
<old_for_body> ::= <variable> ":" <collection>                                    // w:for (item : $items)
                  | <old_for_classic>                                             // w:for (i=0; i<10; ++i)
<old_for_classic> ::= <old_set> <semicolon> <expression> <semicolon> <expression>
<old_for_statement> ::= <old_for> <content_block> <old_end>

WHILE ​

<old_while>          ::= "w:while" <left_paren> <expression> <right_paren> <new_line>
<old_while_statement> ::= <old_while> <content_block> <old_end>

BREAK ​

<old_break> ::= "w:break" <new_line>

EXPORT ​

<old_export> ::= "w:export" <left_paren> [ <scope_keyword> <comma> ]
                 <export_argument_list> <right_paren> <new_line>

语句行汇总 ​

<old_statement_line> ::= <old_set>
                       | <old_expr>
                       | <old_if_statement>
                       | <old_switch_statement>
                       | <old_for_statement>
                       | <old_while_statement>
                       | <old_break>
                       | <old_export>

语法示例 ​

基本数据定义与赋值 ​

Go
w:
w:  // 基本数据定义与赋值
w:  {
w:      // 定义整数
w:      int1 := 1
w:      int2 := 0 + "123"
w:      int3 := (99 + 1) - 2 * 3 / 4 % 5
w:
w:      // 定义浮点数
w:      double1 := 1.0
w:      double2 := 0.0 + "123"
w:      
w:      // 定义字符串
w:      string1 := "abc"
w:      string2 := "abc" + "efg"
w:
w:      // 定义布尔值
w:      boolean1 := true
w:      boolean2 := false
w:
w:      // 定义空值
w:      null1 := null
w:
w:      // 如果变量存在，赋值
w:      // 如果变量不存在，定义
w:      value = 1 + 1
w:      value = true ? 1 : "AAA"
w:  }

数组定义、赋值、访问、遍历 ​

Go
w:
w:  // 数组定义，赋值，访问，遍历
w:  {
w:      // 定义数组（空数组）
w:      arr1 = []
w:
w:      // 定义数组（初始化数组）
w:      arr2 = [
w:        "AAA",
w:        "BBB",
w:        "CC" + "C",
w:        123,
w:      ]
w:
w:      // 定义数组（范围数组）
w:      arr3 = [1 ~ 20]
w:
w:      // 定义数组（多维数组）
w:      arr4 = [
w:        [11, 12, 13],
w:        [21, 22, 23],
w:      ]
w:
w:      // 赋值数组（无需定义）
w:      arr5[0]   = "A"
w:      arr5[1]   = "B"
w:      arr5[100] = arr5[0]
w:
w:      // 获取数组长度
w:      len = LENGTH(arr5)
w:
w:      // 访问数组元素
w:      item = arr5[0]
w:      item = GET(arr5, 0)
w:
w:      // 遍历数组元素
w:      for (item : arr5) {
w:          // item
w:      }
w:  }

字典定义、赋值、访问、遍历 ​

Go
w:
w:  // 字典定义，赋值，访问，遍历
w:  {
w:      // 定义字典（空字典）
w:      dic1 = {}
w:
w:      // 定义字典（初始化字典）
w:      dic2 = {
w:        "Key 1"   : "AAA",
w:        "Key 2"   : "BBB",
w:        "Key 3"   : "CC" + "C",
w:        "Key" + 4 : 123,
w:      }
w:
w:      // 定义字典（初始化匿名字典）
w:      dic3 = {
w:          "AAA",
w:          "BBB",
w:          "CC" + "C",
w:          123,
w:      }
w:
w:      // 定义字典（初始化匿名多维字典）
w:      dic4 = {
w:          {11, 12, 13},
w:          {21, 22, 23},
w:      }
w:
w:      // 定义字典（初始化多维字典）
w:      dic5 = {
w:          "key5_1" : {
w:              "key5_1_1" : 11,
w:              "key5_1_2" : 12,
w:              "key5_1_3" : 13,
w:          },
w:          "key5_2" : {
w:              "key5_2_1" : 21,
w:              "key5_2_2" : 22,
w:              "key5_2_3" : 23,
w:          },
w:      }
w:
w:      // 赋值字典（无需定义）
w:      dic6["key1"] = "AAA"
w:      dic6["key2"] = "BBB"
w:      dic6["key" + 3] = dic6["key1"]
w:
w:      // 获取字典长度
w:      len = LENGTH(dic6)
w:
w:      // 访问字典元素
w:      item = dic6["key" + 3]
w:
w:      // 遍历字典元素
w:      for (key : dic6) {
w:          // dic6[key]
w:      }
w:  }

IF 语句 ​

Go
w:
w:  // 简单的 `IF` 语句
w:  {
w:      x = 5
w:      if (x < 10) {
w:         The value of x is {{ x }}.
w:      }
w:  }
w:
w:  // 带有 `ELSE` 的 `IF` 语句
w:  {
w:      var1 = 100
w:      if (var1 < 10) {
w:         var1 = 1
w:      } else {
w:         var1 = 3
w:      }
w:  }
w:
w:  // 带有 ` ELSE IF` 和 `ELSE` 的 `IF` 语句
w:  {
w:      var1 = 100
w:      if (var1 < 10) {
w:         var1 = 1
w:      } else if (var1 < 20) {
w:         var1 = 2
w:      } else {
w:         var1 = 3
w:      }
w:  }

SWITCH 语句 ​

Go
w:
w:  // SWITCH 语法
w:  {
w:      mode = "A"
w:      action = null
w:      switch (mode) {
w:          case "A": { action = "A" }
w:          case "B": { action = "B" }
w:          case "C": { action = "C" }
w:          case "D": { action = "D" }
w:          default:  { action = "E" }
w:      }
w:  }

FOR 语句 ​

Go
w:
w:  // FOR 语法
w:  {
w:      // 迭代集合
w:      for (item : [1, 2, 3]) {
w:          if (item == 2) {
w:              break
w:          }
w:      }
w:
w:      // 迭代范围
w:      for (item : [1 ~ 3]) {
w:          if (item == 2) {
w:              break
w:          }
w:      }
w:
w:      // 无限循环
w:      for (;;) {
w:          if (<REACH_END>) {
w:              break
w:          }
w:      }
w:
w:      // 经典三段式
w:      arr = [1, 2, 3]
w:      for (i = 0; i < LENGTH(arr); ++i) {
w:          if (arr[i] == 2) {
w:              continue
w:          }
w:      }
w:
w:      // 遍历字典
w:      dic = {1, 2, 3}
w:      for (key : dic) {
w:          if (dic[key] == 2) {
w:              break
w:          }
w:      }
w:  }

WHILE 语句 ​

Go
w:
w:  // WHILE 语法
w:  {
w:      arr = [1, 2, 3]
w:      i = LENGTH(arr) - 1
w:      while (i >= 0) {
w:          if (arr[i] == 3) {
w:              continue
w:          }
w:      }
w:
w:      while (true) {
w:          if (<REACH_END>) {
w:              break
w:          }
w:      }
w:  }

TRY / CATCH / THROW 语句 ​

Go
w:
w:  // TRY 语法
w:  {
w:      // 不捕获异常
w:      try {
w:          // 调用会抛异常的逻辑
w:          // function()
w:      }
w:
w:      // 自动释放资源
w:      try (rs1 = RS_OPEN(db_urls, "SELECT name as name1 FROM Account WHERE Id = ?", ["<ACCOUNT_ID>"]);
w:           rs2 = RS_OPEN(db_urls, "SELECT color as color1 FROM Product WHERE Id = ?", ["<PRODUCT_ID>"]);) {
w:          while (RS_FETCH(rs1)) {
w:              // 通过变量 _name1 访问Account表中的name列数据
w:          }
w:
w:          while (RS_FETCH(rs2)) {
w:              // 通过变量 _color1 访问Product表中的color列数据
w:          }
w:      }
w:
w:      // 捕获异常并且忽略异常
w:      try {
w:          // 调用会抛异常的逻辑
w:          // function()
w:      } catch {
w:          // 捕获并且忽略异常
w:      }
w:
w:      // 捕获异常并且访问异常
w:      try {
w:          // 调用会抛异常的逻辑
w:          // function()
w:      } catch (error1) {
w:          // 捕获并且访问异常
w:          // error1
w:      }
w:
w:      // 捕获异常并且重新抛异常
w:      try {
w:          // 调用会抛异常的逻辑
w:          // function()
w:      } catch (error2) {
w:          // 捕获并且重新抛异常
w:          throw "Caught error: " + error2
w:      }

w:      // catch + finally 组合
w:      try {
w:          // function()
w:      } catch (err) {
w:          // 处理异常
w:      } finally {
w:          // 无论是否异常都会执行
w:      }
w:  }

EXPORT 语句 ​

Go
w:
w:  // EXPORT 语法
w:  {
w:      // 不指定作用域，等同于 GLOBAL_OPERATION
w:      export(                  var1 AS E_VAR_1, var2 AS E_VAR_2)
w:
w:      // 在当前整个脚本里共享
w:      export(GLOBAL_SCRIPT,    var1 AS E_VAR_1, var2 AS E_VAR_2)
w:
w:      // 在当前整个脚本和 OPERATION 里共享
w:      export(GLOBAL_OPERATION, var1 AS E_VAR_1, var2 AS E_VAR_2)
w:
w:      // 在当前整个流程里的脚本和 OPERATION 共享
w:      export(GLOBAL_WORKFLOW,  var1 AS E_VAR_1, var2 AS E_VAR_2)
w:
w:      // 在所有流程里的脚本和 OPERATION 共享
w:      export(GLOBAL_DAEMON,    var1 AS E_VAR_1, var2 AS E_VAR_2)
w:  }

导出作用域说明 ​

作用域关键字共享范围
（省略）等同于 GLOBAL_OPERATION
GLOBAL等同于 GLOBAL_WORKFLOW，变量名前加 operation id 作为前缀
GLOBAL_SCRIPT在当前整个脚本里共享
GLOBAL_OPERATION在当前整个脚本和 OPERATION 里共享
GLOBAL_WORKFLOW在当前整个流程里的脚本和 OPERATION 共享
GLOBAL_DAEMON在所有流程里的脚本和 OPERATION 共享

旧语法示例 ​

SET / EXPR 语句 ​

定义语法（:=） ​

Go
w:set (value := "true" ? 99.99 : "abc")
w:set (value := "abc" + "efg")
w:set (value := (99+1)-2*3/4%5)
w:set (value := XPATH($xml_doc, "/xpath"))
w:set (value := XPATH($xml_doc, "/xpath") + "_suffix")

赋值语法（=，若变量不存在则在全局作用域定义） ​

Go
w:set (value = "true" ? 99.99 : null)
w:set (value = "abc" + "efg")
w:set (value = (99+1)-2*3/4%5)
w:set (value = XPATH($xml_doc, "/xpath"))
w:set (value = XPATH($xml_doc, "/xpath") + "_suffix")

EXPR 语句 ​

Go
w:expr (XPATH($xml_doc, "/xpath"))
w:expr (iterator++)

集合语法 ​

Go
w:set (arr_1    = [1, 2, 3])
w:set (arr_1[0] = 10)
w:set (arr_1[2] = 20)

w:set (arr_2    = [1 ~ 3])
w:set (arr_2[0] = 10)
w:set (arr_2[2] = 20)

w:set (arr_3 = [])
w:set (arr_3[9] = arr_2[0] + 10)
w:set (arr_3[5] = arr_2[1] + 20)
w:expr(arr_3[2] = arr_2[2] + 30)

w:set (arr_4[0+0] = arr_2[0] + 10)
w:set (arr_4[1+0] = arr_2[1] + 20)
w:expr(arr_4[1+1] = arr_2[2] + 30)

IF / ELIF / ELSE 语句 ​

Go
w:if ($str_val == "abc")
    {{ $str_val }}
w:elif ($str_val != "abcdef")
    {{ $str_val }}
w:else
    {{ $str_val }}
w:end

SWITCH / CASE / DEFAULT 语句 ​

Go
w:switch ($num_version)
  w:case (0.0 + 1) :
    {{$num_version}}
  w:case $num*2 :
    {{$num_version}}
  w:case 3.0 :
    {{$num_version}}
  w:default:
    {{$num_version}}
w:end

FOR 语句 ​

Go
w:for (item : $items)
  {{ $_index }} {{ $item }}
w:end

w:for (item : [2, 5, 6])
  {{ $_index }} {{ $item }}
w:end

w:for (item : [2 ~ 5])
  {{ $_index }} {{ $item }}
w:end

w:for (item : ["abc", "efg", "hij"])
  {{ $_index }} {{ $item }}
w:end

w:for (var1 = 0; var1 < 100; ++var1)
  {{ $_index }} {{ $var1 }}
w:end

WHILE 语句 ​

Go
w:set (iterator := 1)
w:while (iterator < 10)
  w:if ($iterator > 5)
    w:break
  w:end

  {{ iterator }}
  {{ $iterator }}
  {{ ${iterator} }}

  w:expr (iterator++)
w:end

设置文件日志中的业务编号和业务类型 ​

Go
w:set    (Business_Category  = "")
w:set    (Business_Number    = "850-")
w:export (GLOBAL_WORKFLOW,  Business_Category AS E_BUSINESS_CATEGORY, Business_Number AS E_BUSINESS_NUMBER)

其中 E_BUSINESS_CATEGORY 是业务类型，E_BUSINESS_NUMBER 是业务编号。

函数 ​

脚本内置若干函数，均以 函数名(参数...) 形式调用，可用于任意表达式中。函数名不区分大小写（建议统一使用大写）。

函数的完整说明（功能、适用场景、参数列表、返回值、使用示例、注意事项）请参阅 《脚本使用手册 - 函数》（script_function.md），本文档不再重复。以下仅为分类索引：

分类包含函数
集合操作LENGTH、GET、COLLECTION_ADD、COLLECTION_CONTAINS
XML 处理XML_OPEN、XML_FETCH、XML_ENCODE、XML_DECODE、XPATH、NODE_TO_XML、XML_CLOSE、XML_TO_JSON、OUT_XML_NODE
XML VTD 处理XML_OPEN_VTD、XPATH_VTD、XPATH_VTD_MOVE、XML_CLOSE_VTD
JSON 处理JSON_OPEN、JSON_FETCH、JSON_ENCODE、JSON_DECODE、JSON_PATH、JSON_IS_ARRAY、NODE_TO_JSON、JSON_CLOSE、JSON_TO_XML、JSON_CHECK
CSV 处理CSV_OPEN、CSV_NEXT、CSV_READ、CSV_CLOSE
数据库操作DB_LOAD、DB_CONN、DB_STMT、DB_QUERY、DB_CLOSE
结果集处理RS_OPEN、RS_NEXT、RS_FETCH、RS_GET、RS_CLOSE
Excel 处理EXCEL_OPEN、EXCEL_READ、EXCEL_NUM_OF_ROWS、EXCEL_CLOSE
日期时间NOW、TIME_FORMAT、DATE、DATE_DIFF、DATE_FORMAT、DATETIME、DATETIME_DIFF、DATETIME_FORMAT、DATETIME_OFFSET
字符串处理STRING_FORMAT、STRING_LENGTH、STRING_INDEX_OF、STRING_LAST_INDEX_OF、STRING_SPLIT、STRING_SPLIT_WORD、STRING_SUBSTRING、STRING_TOUPPER、STRING_TOLOWER、STRING_MATCH、STRING_REPLACE、STRING_TRIM、STRING_TRIM_START、STRING_TRIM_END、STRING_STRIP、STRING_DEFAULT、STRING_START_WITH、STRING_END_WITH、STRING_REMOVE_SYMBOL
文件操作FILE_GETNAME、FILE_GETEXT、FILE_GETPATH、FILE_GETFOLDER、FILE_MKDIR、FILE_READ、FILE_COPY、FILE_EXISTS、FILE_MOVE、FILE_RENAME、FILE_SCAN_DIR
编码生成GEN_SSCC、GEN_LABEL、GEN_ID
数学计算MATH_CEIL、MATH_FLOOR、MATH_ROUND、MATH_RANDOM、FLOAT_FORMAT
随机数RANDOM_NUMBER
加密解密ENCRYPT_AES、DECRYPT_AES
工具NULL、SNOWFLAKE、LOG、DEBUG、DEFINE、AS_VALUE、CONVERT、COLUMN_INDEX、VALID_TYPE
线程控制 / 锁SLEEP、LOCK、UNLOCK
Odoo 集成XMLPRC_AUTHENTICATION、XMLPRC_EXECUTE_KW

已废弃函数：NODE_FETCH_CHILDREN_AS_VARIABLES（请改用 XML_FETCH）、RS_FETCH_ROW_AS_VARIABLES（请改用 RS_FETCH）。