例如，在 Orchestration Pipeline 代码编辑器中使用这些 DataStage 函数来定义用户变量或构建高级条件。
表达式构建器函数的语法
在自变量的语法中，方括号指示自变量是可选的。
参数可以接受任何类型的数据。 可以输入类型为 string ， int ， float ， null 和其他类型的自变量。 例如，函数 IsNull(input (any)) 接受以下参数类型，但不排除以下类型:
ds.IsNull(1)
ds.IsNull("try null")
ds.IsNull(1.78)
ds.IsNull(null)
表达式构建器将以下类别用于编码函数:
转换函数
将一种数据元素格式转换为另一种数据元素格式。
Ascii
将字符串中的字符值从 EBCDIC 转换为 ASCII 格式。
语法
ds.Ascii(input (string))
返回: EDBCDI 字符串转换为生成的格式字符串的 ASCII 字符串。
示例
以下代码返回 "65 66 67":
ds.Ascii("193 194 195")
Char
根据其数字代码值返回一个 ASCII 字符。
语法
ds.Char(code (uint8))
返回: 格式为 char 的相应字符。
示例
以下示例将 ASCII 码 65 输出为字符 A。
ds.Char(65)
校验和
返回字符串的循环冗余代码值。
语法
ds.Checksum(input (string))
返回: 作为循环冗余码的格式字符串的校验和值。
示例
以下代码返回 57158:
ds.Checksum("This is any arbitrary string value")
CRC32
使用 CRC32 函数返回 16 位循环冗余代码。
语法
ds.CRC32(input (string))
返回: 格式为十进制的结果。
示例
以下代码返回 57158:
ds.CRC32("This is any arbitrary string value")
DateToString
返回日期的字符串表示。 日期的缺省格式字符串为 "%yyyy%mm%dd" ，因此，例如，日期 2009-08-25 存储为十进制数 20090825。 但是，您可以选择指定格式字符串，以设置如何将日期存储为十进制数。 格式字符串必须指定仅包含数字的格式。 例如，您不能指定格式字符串，如“%yyyy-%mm-%dd”，因为无法在压缩十进制值中存储连字符 (-)。 以下标记对于与十进制值之间的转换有效：
%yyyy (four-digit year)
%yy (two-digit year)
%NNNNyy (two-digit year with cutoff)
%mm (two-digit month)
%dd (two-digit day of month)
%ddd (three-digit day of year)
字面值数字 0 到 9 都有效。
语法
ds.DateToString(date (date), [format (string)])
返回：string 格式的日期。
示例
如果 mylink.mydate 包含日期 18th ，那么以下代码将返回字符串 "2009-08-18":
ds.DateToString(mylink.mydate)
以下示例将列 mylink.mydate 中包含的日期输出为格式为 dd:mm:yyyy的字符串。 如果 mylink.mydate 包含日期 18th ，那么以下代码将返回字符串 "18:08:2009":
ds.DateToString(mylink.mydate, "%dd:%mm:%yyyy")
DateToDecimal
将给定的日期返回为压缩十进制值。 日期的缺省格式字符串为 "%yyyy%mm%dd" ，因此，例如，日期 2009-08-25 存储为十进制数 20090825。 但是，您可以选择指定格式字符串，以设置如何将日期存储为十进制数。 格式字符串必须指定仅包含数字的格式。 例如，您不能指定格式字符串，如“%yyyy-%mm-%dd”，因为无法在压缩十进制值中存储连字符 (-)。 以下标记对于与十进制值之间的转换有效：
%yyyy (four-digit year)
%yy (two-digit year)
%NNNNyy (two-digit year with cutoff)
%mm (two-digit month)
%dd (two-digit day of month)
%ddd (three-digit day of year)
字面值数字 0 到 9 都有效。
语法
ds.DateToDecimal(basedate (date), [format (string)])
返回：decimal 格式的日期
示例
如果 mylink.basedate 包含日期 2012-08-18，那么以下函数将该日期存储为十进制数 18082012：
ds.DateToDecimal(mylink.basedate, "%dd%mm%yyyy")
如果 mylink.basedate 包含日期 2012-08-18 ，那么以下函数会将日期存储为十进制数 20120818:
ds.DateToDecimal(mylink.basedate)
DecimalToDate
将给定的压缩十进制数返回为日期。 在将十进制数转换为日期时，会忽略其符号和小数位数。 缺省格式字符串为“%yyyy%mm%dd”，因此，例如日期 2009-08-25 将存储为数字 20090825。 但是，您可以选择指定格式字符串，以设置如何将日期存储为十进制数。 格式字符串必须仅指定包含数字的格式。 例如，您不能指定格式字符串，如“%yyyy-%mm-%dd”，因为无法在压缩十进制值中存储连字符 (-)。 以下标记对于与十进制值之间的转换有效：
%yyyy (four-digit year)
%yy (two-digit year)
%NNNNyy (two-digit year with cutoff)
%mm (two-digit month)
%dd (two-digit day of month)
%ddd (three-digit day of year)
字面值数字 0 到 9 都有效。
语法
ds.DecimalToDate(basedec (decimal), [format (string)])
返回：date 格式的十进制数。
示例
如果 mylink.mydecdata 包含值 18082012，那么以下函数将返回日期 2012-08-18：
ds.DecimalToDate(mylink.basedate, "%dd%mm%yyyy")
如果 mylink.mydecdata 包含值 -201208.18，那么以下函数将返回日期 2012-08-18：
ds.DecimalToDate(mylink.basedate)
DecimalToDecimal
以十进制表示法返回给定的十进制数。 参数 rtype 指定取整类型，并设置为以下某个值（可选）：
ceil：向正无穷方向对源字段取整。 例如，1.4-> 2，-1.6-> --1。
floor：向负无穷方向对源字段取整。 例如，1.6-> 1，-1.4-> --2。
round_inf：通过向正无穷方向对正数值取整并向负无穷方向对负数值取整，向最接近的可表示值对源字段进行取整或截断。 例如，1.4-> 1，1.5-> 2，-1-1.4-> --1，-1.5->-22。
trunc_zero：不论符号如何，丢弃位于目标数据支持的最右侧小数位右侧的任何小数位。 例如，如果目标是整数，那么将截断所有小数位。 如果目标是另一个小数位较小的小数位，那么它会舍入或截断为目标小数位的小数位大小。 例如，1.6-> 1，-1.6-> --1。
语法
ds.DecimalToDecimal(decimal (decimal), [rtype (string)])
返回：十进制数结果。
示例
如果 mylink.mydec 包含十进制数 2.5345，那么以下函数将返回十进制数 2.54:
ds.DecimalToDecimal(mylink.mydec,"ceil")
如果 mylink.mydec 包含十进制数 2.5345，那么以下函数将返回十进制数 2.53。
ds.DecimalToDecimal(mylink.mydec,"floor")
如果 mylink.mydec 包含十进制数 2.5345，那么以下函数将返回十进制数 2.53。
ds.DecimalToDecimal(mylink.mydec,"trunc_zero")
如果 mylink.mydec 包含十进制数 2.5345，那么以下函数将返回十进制数 2.53。
ds.DecimalToDecimal(mylink.mydec,"round_inf")
DecimalToDFloat
返回 dfloat 格式的给定十进制数。 可选参数 fix_zero 指定将所有零十进制值视为有效 (缺省情况下，将包含所有零的十进制数字视为无效)。
语法
ds.DecimalToDFloat(decimal (decimal), ["fix_zero"])
返回：dfloat 格式的十进制数。
示例
如果 mylink.mydec 包含十进制数 00000004.00，那么以下函数将返回 dfloat number 4。
ds.DecimalToDFloat(mylink.mydec,"fix_zero")
如果 mylink.mydec 包含十进制数 00012344.00，那么以下函数将返回 dfloat 数字 12344。
ds.DecimalToDFloat(mylink.mydec,"fix_zero")
如果 mylink.mydec 包含十进制数 00012344.120，那么以下函数将返回 dfloat number 12344.12。
ds.DecimalToDFloat(mylink.mydec,"fix_zero")
如果 mylink.mydec 包含十进制数字 00012344.120，那么以下函数将返回 dfloat 数字 12344.12。
ds.DecimalToDFloat(mylink.mydec)
如果 mylink.mydec 包含十进制数 00012344.000，那么以下函数将返回 dfloat 数字 12344。
ds.DecimalToDFloat(mylink.mydec)
DecimalToString
将给定的十进制数返回为字符串。 自变量 fix_zero (可选) 指定将所有零十进制值视为有效 (缺省情况下，将包含所有零的十进制数字视为无效)。 这涵盖了压缩十进制表示法的符号位全部为 0 且全部为内容数字的情况。 除非 fix_zero 为 true，否则此强制转换将被视为无效。
语法
ds.DecimalToString(decimal (decimal), ["fix_zero"])
返回：string 格式的十进制数。
示例
如果 mylink.mydec 包含十进制数 00000004.00，那么以下函数将返回字符串 "4":
ds.DecimalToString(mylink.mydec,"suppress_zero")
如果 mylink.mydec 包含十进制数 00000004.00，那么以下函数将返回字符串 "0000000000000000000000000004.0000000000":
ds.DecimalToString(mylink.mydec,"fix_zero")
如果 mylink.mydec 包含十进制数 00000004.00，那么以下函数将返回字符串 "4":
ds.DecimalToString(mylink.mydec)
DecimalToTime
将给定的压缩十进制数返回为时间。 您可以指定格式字符串来指定如何以十进制数形式存储时间（可选）。 缺省格式字符串为 "%hh%nn%ss" ，因此，例如，时间 14:03:22 存储为十进制数 140322。 格式字符串必须指定仅包含数字的格式。 例如，您不能指定格式字符串，如“%hh:%nn:%ss”，因为无法在压缩十进制值中存储冒号字符 (:)。 以下标记对于与十进制值之间的转换有效：
%hh (two-digit hours that use 24-hour clock)
%nn (two-digit minutes)
%ss (two-digit seconds)
%ss.N (two-digit seconds, plus the number of fractional digits allowed. The number of fractional digits is from 1 - 6 inclusive).
字面值数字 0 到 9 都有效。
如果指定的格式包含微秒（例如，%ss.4），那么将在十进制值中推断小数点的位置。 小数点的位置不必与指定的小数位 (例如，小数位 = 4) 一致。
语法
ds.DecimalToTime(decimal (decimal), [format (string)])
返回: 时间格式的十进制。
示例
如果 mylink.mytimedec 包含十进制值 200658 ，那么以下函数将返回时间 20:06:58:
ds.DecimalToTime(mylink.mytimedec)
如果列 mylink.mytimedec 包含十进制值 580620 ，那么以下函数将返回时间 20:06:58:
ds.DecimalToTime(mylink.mytimedec, "%ss%nn%hh")
DecimalToTimestamp
将给定的压缩十进制数返回为时间戳记。 您可以指定格式字符串来指定如何以十进制数形式存储时间戳记（可选）。 缺省格式字符串为 "%hh%nn%ss" ，因此，例如，时间戳记 2009-08-25 14:03:22 存储为十进制数 20090825140322。 格式字符串必须指定仅包含数字的格式。 例如，您不能指定格式字符串，如“%yyyy/%mm/%dd%hh:%nn:%ss”，因为无法在压缩十进制值中存储斜杠字符 (/) 和冒号字符 (:)。 以下标记对于与十进制值之间的转换有效：
%yyyy (four-digit year)
%yy (two-digit year)
%NNNNyy (two-digit year with cutoff)
%mm (two-digit month)
%dd (two-digit day of month)
%ddd (three-digit day of year)
%hh (two-digit hours that use 24-hour clock)
%nn (two-digit minutes)
%ss (two-digit seconds)
%ss.N (two-digit seconds, plus the number of fractional digits allowed. The number of fractional digits is from 1 - 6 inclusive).
字面值数字 0 到 9 都有效。
如果指定的格式包含微秒（例如，%ss.4），那么将在十进制值中推断小数点的位置。 小数点的位置不必与指定的小数位 (例如，小数位 = 4) 一致。
语法
ds.DecimalToTimestamp(decimal (decimal), [format (string)])
返回: 时间戳记格式的十进制。
示例
如果 mylink.mytimestampdec 包含值 19580818200658 ，那么以下函数将返回时间戳记 1958-08-18 20:06:58:
ds.DecimalToTimestamp(mylink.mytimestampdec)
如果 link.mytimestampdec 包含十进制值 200658220818 ，那么以下函数将返回时间戳记 2022-08-18 20:06:58:
ds.DecimalToTimestamp(mylink.mytimestampdec, "%hh%nn%ss%yy%mm%dd")
DFloatToDecimal
以十进制表示形式返回给定的 dfloat。 参数 rtype 指定取整类型，并设置为以下某个值（可选）：
ceil：向正无穷方向对源字段取整。 例如，1.4-> 2，-1.6-> --1。
floor：向负无穷方向对源字段取整。 例如，1.6-> 1，-1.4-> --2。
round_inf：通过向正无穷方向对正数值取整并向负无穷方向对负数值取整，向最接近的可表示值对源字段进行取整或截断。 例如，1.4-> 1，1.5-> 2，-1-1.4-> --1，-1.5->-22。
trunc_zero：不论符号如何，丢弃位于目标数据支持的最右侧小数位右侧的任何小数位。 例如，如果目标是整数，那么将截断所有小数位。 如果目标是另一个小数位较小的小数位，那么它会舍入或截断为目标小数位的小数位大小。 例如，1.6-> 1，-1.6-> --1。
语法
ds.DFloatToDecimal(number (dfloat), [rtype (string)])
返回：dfloat 格式的十进制数。
示例
如果 mylink.myfloat 包含 dfloat 数字 2.534，那么以下函数将返回十进制数字 2.54:
ds.DFloatToDecimal(mylink.mydec,"ceil")
如果 mylink.myfloat 包含 dfloat 数字 2.534，那么以下函数将返回十进制数字 2.53:
ds.DFloatToDecimal(mylink.mydec,"floor")
如果 mylink.myfloat 包含 dfloat 数字 2.534，那么以下函数将返回十进制数字 2.53:
ds.DFloatToDecimal(mylink.mydec,"trunc_zero")
如果 mylink.myfloat 包含 dfloat 数字 2.534，那么以下函数将返回十进制数字 2.53:
ds.DFloatToDecimal(mylink.mydec,"round_inf")
DfloatToStringNoExp
通过使用指定的标度，以不带指数的字符串表示法返回给定的 dfloat。
语法
ds.DfloatToStringNoExp(number (dfloat), scale (string))
返回：string 格式的 dfloat 数。
示例
如果 mylink.myfloat 包含 dfloat 数字 2.534，那么以下函数将返回字符串 "2.5":
ds.DfloatToStringNoExp(mylink.myfloat, "2")
德特克斯
将十进制整数转换为十六进制。
语法
ds.Dtx(number (int32), size(int8))
返回: 格式字符串的结果。
示例
以下代码返回"002F":
ds.Dtx(47,4)
EBCDIC
将表达式的每个字符从其 ASCII 表示值转换为其 EBCDIC 表示值。
语法
ds.Ebcdic(input (string))
返回: 转换为生成的 EDBCDII 字符串的 ASCII 字符串。
示例
以下代码返回 "193 194 195 64 241 242 243":
ds.Ebcdic("ABC 123")
iconv
将字符串转换为内部存储格式。
语法
ds.Iconv(string (string), code (string))
返回: 字符串格式的内部存储格式。
示例
以下代码返回 10740:
ds.Iconv("27 MAY 97", "D2")
以下代码返回 10740:
ds.Iconv("1997 5 27", "D YMD")
IntToBool
将 integer 转换为 bool 类型。 对于任何非零值返回 true ，对于 0 返回 false。
语法
ds.IntToBool(integer (int))
返回: 布尔值 true 或 false。
示例
2 的值返回 true。
ds.IntToBool(2)
IsValid
返回给定的字符串对于给定类型是否有效。
有效类型为 "date" ， "decimal" ， "dfloat" ， "sfloat" ， "int8" ， "uint8" ， "int16" ， "uint16" ， "int32" ， "uint32" ， "int64"，"uint64"，" string "，" time "，" timestamp "。
对于数据类型 date、time 和 timestamp，您可以指定格式字符串（可选）。 格式字符串描述输入数据的格式与 date、time 或 timestamp 的缺省格式不同时，输入数据所使用的格式。 日期的缺省格式为“%yyyy-%mm-%dd”。 时间的缺省格式为 "%hh: %mm:%ss"。 时间戳记的缺省格式为 "%yyyy-%mm-%dd %hh: %mm:%ss"。 该功能不会记录警告。
语法
ds.IsValid(type (string), teststring (string), [format (string)])
返回：int8 类型的结果；如果输入对于给定类型有效，那么返回 1，否则返回 0。
示例
如果 mylink.mystring 包含字符串 "1" ，那么以下函数将返回值 1:
ds.IsValid("int8", mylink.mystring)
如果 mylink.mystring 包含字符串 "380096.06" ，那么以下函数将返回值 0:
ds.IsValid("int8", mylink.mystring)
IsValidDate
返回给定的值是否为有效的 date 类型。 该功能记录警告。
语法
ds.IsValidDate(testdate (date))
返回：int8 类型的结果；如果输入对于给定类型有效，那么返回 1，否则返回 0。
如果 mylink.mydate 包含日期 2011-09-13，那么以下函数将返回值 1。
ds.IsValidDate(mylink.mydate)
如果 mylink.mydate 包含字符串 "380096.06" ，那么以下函数将返回值 0 ，因为转换后的字符串不是有效日期。
ds.IsValidDate(mylink.mydate)
IsValidDecimal
返回给定的值是否为有效的 decimal 类型。 如果 allzerosflag 设置为 0 ，那么全零表示无效。 缺省情况下，allzerosflag 设置为 0。
语法
ds.IsValidDecimal(testvalue (decimal), [allzerosflag (uint8)])
返回：int8 类型的结果；如果输入对于给定类型有效，那么返回 1，否则返回 0。
示例
如果 mylink.mynum 包含值 310007.65，那么以下函数将返回值 1。
ds.IsValidDecimal(mylink.mynum)
IsValidTime
返回给定的时间是否为有效的 time 类型。
语法
ds.IsValidTime(testtime (time))
返回：int8 类型的结果；如果输入对于给定类型有效，那么返回 1，否则返回 0。
示例
如果 mylink.mytime 包含时间 23:09:22，那么以下函数将返回值 1：
ds.IsValidTime(mylink.mytime)
IsValidTimestamp
返回给定的时间戳记是否为有效的 timestamp 类型。
语法
ds.IsValidTimestamp(testtimestamp (timestamp))
返回：int8 类型的结果；如果输入对于给定类型有效，那么返回 1，否则返回 0。
示例
如果 mylink.mytimestamp 包含时间 2011-09-13 23:09:22，那么以下函数将返回值 1：
ds.IsValidTimestamp(mylink.mytimestamp)
奥孔夫
将表达式转换为输出格式。
语法
ds.Oconv(expression (string), conversion (string))
返回: 结果为格式字符串的输出格式。
示例
以下代码返回 1997-147:
ds.Oconv(10740, "D-YJ")
以下代码返回 27 MAY 97:
ds.Oconv(10740, "D DMY, [A3,2]")
RawNumAt
返回指定 raw 字段中指定索引值的整数值。 索引从 0 开始。
语法
ds.RawNumAt(rawfield (string), index (int32))
返回：给定索引中的整数值（int32 格式）。
示例
如果 column mylink.myraw 包含派生自字符串 "hello" (即 "{ 0x68 0x65 0x6C 0x6C 0x6F }") 的原始值，则以下函数返回整数 104 (字符 h 的 ASCII 码):
ds.RawNumAt(mylink.myraw, 0)
如果 mylink.myraw 包含派生自字符串 "hello" (即 "{ 0x68 0x65 0x6C 0x6C 0x6F }") 的原始值，那么以下函数将返回 0 ，因为指定的索引超出范围:
ds.RawNumAt(mylink.myraw, 12)
RawToString
以字符串表示形式返回给定的 raw 值。 必须确保 raw 输入值包含一个字节序列，这些字节在使用输出字符串的目标字符集中为有效字符。
例如，原始值 { 0xE0 0x41 0x42 } 不是有效的 UTF-8 字符序列，因为前导字节 0xE0 应后跟 [0x80..0xBF] 范围内的字节。
如果将原始值 "{ xE0 x41 x42 }传递给RawToString函数，然后以UTF-8 编码方式访问输出字符串，可能会发生错误。
语法
ds.RawToString(rawfield (string))
返回：字符串格式的给定原始值。
示例
如果 mylink.myraw 包含值 { 0x31 0x31 0x30 0x35 0x32 0x32 0x30 0x39 }，那么以下函数将返回字符串 "11052209"。
ds.RawToString(mylink.myraw)
序号
根据 ASCII 字符生成数字代码值。 您可以选择指定 allow8bits 参数来转换 8 位 ASCII 值。
语法
ds.Seq(seq (char))
返回：ASCII 字符数字代码。
示例
以下示例将字符 A 输出为 ASCII 码 65。
ds.Seq("A")
SeqAt
返回给定字符串中指定位置上字符的数字代码点值。 索引从 0 开始。 如果指定的索引超出范围，那么该函数将返回 0。
语法
ds.SeqAt(basestring (string), index (int32))
返回：给定字符串中指定位置处的字符的数字代码点值（int32 格式）。
示例
如果 mylink.mystring 包含字符串 "horse" ，那么以下函数将返回值 0x6F (即，字符 o 的 ASCII 值)。
ds.SeqAt(mylink.mystring, 1)
StringToBool
将字符串转换为 bool 类型。 对于空字符串，返回 false ，对于任何其他值，返回 true。
语法
ds.StringToBool(string (string))
返回: 布尔值 true 或 false。
示例
空字符串返回 false。
ds.StringToBool("")
StringToDate
返回给定字符串中的日期（采用指定格式）。 如果字符串包含缺省格式 yyyy-mm-dd 的日期，那么不必指定格式字符串。
语法
ds.StringToDate(string (string), [format (string)])
返回: 指定格式的迄今为止的字符串。
示例
如果 mylink.mystring 包含字符串 "1958-08-18" ，那么以下函数将返回日期 1958-08-18。
ds.StringToDate(mylink.mystring)
如果 mylink.mystring 包含字符串 "18:08:1958" ，那么以下函数将返回日期 1958-08-18。
ds.StringToDate(mylink.mystring,"%dd:%mm:%yyyy")
StringToDecimal
以十进制表示形式返回给定的字符串。 参数 rtype 指定取整类型，并设置为以下某个值（可选）：
ceil：向正无穷方向对源字段取整。 例如，1.4-> 2，-1.6-> --1。
floor：向负无穷方向对源字段取整。 例如，1.6-> 1，-1.4-> --2。
round_inf：通过向正无穷方向对正数值取整并向负无穷方向对负数值取整，向最接近的可表示值对源字段进行取整或截断。 例如，1.4-> 1，1.5-> 2，-1-1.4-> --1，-1.5->-22。
trunc_zero：不论符号如何，丢弃位于目标数据支持的最右侧小数位右侧的任何小数位。 例如，如果目标是整数，那么将截断所有小数位。 如果目标是另一个小数位较小的小数位，那么它会舍入或截断为目标小数位的小数位大小。 例如，1.6-> 1，-1.6-> --1。
语法
ds.StringToDecimal(string (string), [rtype (string)])
返回：decimal 格式的字符串。
示例
如果 mylink.mystring 包含字符串 "19982.22" ，那么以下函数将返回十进制 19982.22。
ds.StringToDecimal(mylink.mystring)
如果 mylink.mystring 包含字符串 "19982.2276" ，那么以下函数将返回十进制 19982.23。
ds.StringToDecimal(mylink.mystring,"ceil")
StringToRaw
返回要作为原始代码值的字符串。
语法
ds.StringToRaw(string (string))
返回：字符串对应的原始代码值。
示例
如果 mylink.mystring 包含字符串 "hello" ，那么以下函数将返回值 "{0x68 0x65 0x6C 0x6C 0x6F}"。
ds.StringToRaw(mylink.mystring)
StringToTime
返回给定字符串的时间表示。
语法
ds.StringToTime(string (string), [format (string)])
返回：time 格式的字符串。
示例
如果 mylink.mystring 包含字符串 "20:06:58" ，那么该函数将返回时间 20:06:58。
ds.StringToTime(mylink.mystring)
如果 mylink.mystring 包含字符串 "20: 6:58" ，那么此函数将返回时间 20:06:58。
ds.StringToTime(mylink.mystring,"%(h,s):%(n,s):%(s,s)")
StringToTimestamp
返回 timestamp 格式的给定字符串。
语法
ds.StringToTimestamp(string (string), [format (string)])
返回：timestamp 格式的字符串。
示例
如果 mylink.mystring 包含字符串 "1958-08-08 20:06:58" ，那么该函数将返回时间戳记 1958-08-08 20:06:58。
ds.StringToTimestamp(mylink.mystring)
如果 mylink.mystring 包含字符串 "8/ 8/1958 20: 6:58" ，那么该函数将返回时间戳记 1958-08-08 20:06:58。
ds.StringToTimestamp(mylink.mystring, "%(d,s)/%(m,s)/%yyyy%(h,s):%(n,s):%(s,s)")
StringToUstring
返回给定字符串中的一个 ustring，可选择使用指定的映射（否则使用项目缺省值）。
语法
ds.StringToUstring(string (string), [mapname (string)])
返回：ustring 格式的字符串。
示例
如果 mylink.mystring 包含字符串 "11052009" ，那么以下函数将返回 ustring "11052009"。
ds.StringToUstring(mylink.mystring)
TimestampToDate
返回给定时间戳记的日期。
语法
ds.TimestampToDate(timestamp (timestamp))
返回：时间戳记中的日期结果。
示例
如果 mylink.mytimestamp 包含时间戳记 1958-08-18 20:06:58 ，那么以下函数将返回日期 1958-08-18:
ds.TimestampToDate(mylink.mytimestamp)
TimestampToDecimal
将给定的时间戳记返回为压缩十进制。 缺省格式字符串为 " %yyyy%mm%dd%hh%nn%ss "。 例如，时间戳记 timestamp 2009-08-25 14:03:22 存储为十进制数 20090825140322。 但是，您可以选择指定格式字符串，以设置如何将日期存储为十进制数。 格式字符串必须指定仅包含数字的格式。 例如，您不能指定格式字符串，如“%yyyy/%mm/%dd%hh:%nn:%ss”，因为无法在压缩十进制值中存储斜杠字符 (/) 和冒号字符 (:)。 以下标记对于与十进制值之间的转换有效：
%yyyy (four-digit year)
%yy (two-digit year)
%NNNNyy (two-digit year with cutoff)
%mm (two-digit month)
%dd (two-digit day of month)
%ddd (three-digit day of year)
%hh (two-digit hours that use 24-hour clock)
%nn (two-digit minutes)
%ss (two-digit seconds)
%ss.N (two-digit seconds, plus the number of fractional digits allowed. The number of fractional digits is from 1 - 6 inclusive).
字面值数字 0 到 9 都有效。
如果指定的格式包含微秒（例如，%ss.4），那么将在十进制值中推断小数点的位置。 小数点的位置不必与指定的十进制小数位一致（例如，小数位 = 4）。
语法
ds.TimestampToDecimal(timestamp (timestamp), [format (string)])
返回：decimal 格式的时间戳记结果。
示例
如果 mylink.mytimestamp 包含时间戳记 1958-08-18 20:06:58 ，那么以下函数将返回十进制值 19580818200658:
ds.TimestampToDecimal(mylink.mytimestamp)
如果 mylink.mytimestamp 包含时间戳记 1958-08-18 20:06:58 ，那么以下函数将返回十进制值 200658580818:
ds.TimestampToDecimal(mylink.mytimestamp, "%hh%nn%ss%yy%mm%dd")
TimestampToString
以字符串格式返回给定时间戳记。
语法
ds.TimestampToString(timestamp (timestamp), [format (string)])
返回：string 格式的时间戳记结果。
示例
如果 mylink.mytimestamp 包含时间戳记 1958-08-18 20:06:58 ，那么该函数将返回字符串 "1958-08-18 20:06:58"。
ds.TimestampToString(mylink.mytimestamp)
如果 mylink.mytimestamp 包含时间戳记 1958-08-18 20:06:58 ，那么此函数将返回字符串 "1 8/0 8/1 9 5 8 20:06:58":
ds.TimestampToString(mylink.mytimestamp, "%dd/%mm/%yyyy %hh:%nn:%ss")
TimestampToTime
返回给定时间戳记作为时间格式。
语法
ds.TimestampToTime(timestamp (timestamp), [format (string)])
返回：time 格式的时间戳记结果。
示例
如果 mylink.mytimestamp 包含时间戳记 1958-08-18 20:06:58 ，那么此函数将返回时间 20:06:58:
ds.TimestampToTime(mylink.mytimestamp)
TimeToString
返回给定时间的字符串。
语法
ds.TimeToString(timestamp (timestamp), [format (string)])
返回：time 格式的结果。
示例
如果 mylink.mytime 包含时间 20:06:58 ，那么以下函数将返回字符串 "20:06:58":
ds.TimeToString(mylink.mytime)
如果 mylink.mytime 包含时间 20:06:58 ，那么以下函数将返回字符串 "58:06:20":
ds.TimeToString(mylink.mytime, "%ss:%nn:%hh")
TimeToDecimal
将给定的时间返回为压缩十进制。 缺省格式字符串为“%hh%nn%ss”，因此，例如时间 14:03:22 将存储为十进制数字 140322。 但是，您可以选择指定格式字符串，以指定如何将时间存储为十进制数。 格式字符串只能指定包含数字的格式。 例如，您不能指定格式字符串，如“%hh:%nn:%ss”，因为无法在压缩十进制值中存储冒号字符 (:)。 以下标记对于与十进制值之间的转换有效：
%hh (two-digit hours that use 24-hour clock)
%nn (two-digit minutes)
%ss (two-digit seconds)
%ss.N (two-digit seconds, plus the number of fractional digits allowed. The number of fractional digits is from 1 - 6 inclusive).
字面值数字 0 到 9 都有效。
如果指定的格式包含微秒（例如，%ss.4），那么将在十进制值中推断小数点的位置。 小数点的位置不必与指定的十进制小数位一致（例如，小数位 = 4）。
语法
ds.TimeToDecimal(time (time), [format (string)])
返回：decimal 格式的时间。
示例
如果 mylink.mytime 包含时间 20:06:58，那么以下函数将返回十进制值 200658：
ds.TimeToDecimal(mylink.mytime)
如果 mylink.mytime 包含时间 20:06:58，那么以下函数将返回十进制值 580620：
ds.TimeToDecimal(mylink.mytime, "%ss%nn%hh")
UniChar
根据 0 到 65535 范围内的十进制值生成单个 Unicode 字符。
语法
ds.UniChar(expression (int32))
返回: 格式字符串的结果。
示例
以下代码返回 "按照":
ds.UniChar(0x00F5)
UniSeq
根据单个 Unicode 字符生成十进制值。
语法
ds.UniSeq(expression (string))
返回: 格式为 int32的 Unicode 字符的相应十进制数。
示例
以下代码返回 195:
ds.UniSeq("ä")
UstringToString
返回给定 ustring 中的一个字符串，可选择使用指定的映射（否则使用项目缺省映射）。
语法
ds.UstringToString(string (ustring), [mapname(string)])
返回：string 格式的结果。
示例
如果 mylink.myustring 包含 ustring "11052009" ，那么以下函数将返回字符串 "11052009":
ds.UstringToString(mylink.myustring)
Xtd
将十六进制字符串转换为十进制。
语法
ds.Xtd(hexadecimal (string))
返回: 十六进制字符串的相应十进制值。
示例
以下代码返回 48879:
ds.Xtd("beef")
整型
返回表达式的整数部分。 指定的任何算术运算都是使用系统的完全准确性计算的。 值的小数部分将截断，而不是舍入，并且将返回剩余的整数。
语法
ds.Int(expression (dfloat))
返回: 舍入并转换为类型 int64的十进制值。
示例
以下代码返回 454:
ds.Int(454.95)
以下代码返回 2:
ds.Int(2.35)
日期和时间函数
将这些函数用于表达式中的数据和时间函数。
在自变量中指定日期，时间或时间戳记的函数使用具有特定格式的字符串:
- 对于日期，格式为
%yyyy-%mm-%dd - 对于时间，格式为
%hh:%nn:%ss。 如果扩展为包含微秒，那么格式为%hh:%nn:%ss.x，其中 x 指定秒值的小数位数。 - 对于时间戳记，格式是后跟时间格式的日期格式。
在自变量中包含星期几的函数将采用指定星期几的字符串。 星期几可指定为三个字母的缩写，也可指定为完整名称。 例如，字符串 "thu" 和 "th星期四" 都有效。
CurrentDate
返回运行作业的日期。
语法
ds.CurrentDate()
返回：date 格式的当前日期。
示例
此函数用于获取当前日期。
ds.CurrentDate()
CurrentTime
返回运行作业的时间。
语法
ds.CurrentTime()
返回: 当前时间格式。
示例
此函数用于获取当前时间。
ds.CurrentTime()
CurrentTimeMS
返回运行作业的时间，包括微秒。
语法
ds.CurrentTimeMS()
返回：time 格式的当前时间（包括微秒）。
示例
使用此函数可检索当前时间并输出数据。
ds.CurrentTimeMS()
CurrentTimestamp
返回给出作业运行日期和时间的时间戳记。
语法
ds.CurrentTimestamp()
返回: 时间戳记格式的当前时间戳记。
示例
此函数用于检索当前时间戳记并将其放入输出数据中。
ds.CurrentTimestamp()
CurrentTimestampMS
返回用于提供作业运行日期和时间的时间戳记（包括微秒）。
语法
ds.CurrentTimestampMS()
返回: 时间戳记格式的当前时间戳记。
示例
此函数用于检索当前时间戳记并将其放入输出数据中。
ds.CurrentTimestampMS()
日期
返回从内部系统日期到 1967 年 12 月 31 日 (即 0 日) 之间经过的单个数字值。 之后的所有日期都是正数，表示自第 0 天以来经过的天数。 之前的所有日期都是负数，表示第 0 天之前的天数。
语法
ds.Date()
返回: 生成的格式为 int 的日期。
示例
如果当前日期是 1967 年 11 月 15 日，那么以下代码将返回 -46。 如果当前日期是 1968 年 2 月 15 日，那么以下代码将返回 46:
ds.Date()
DateFromDaysSince
通过向基线日期添加整数来返回日期。 该整数可以是负数，这样会返回早于基准日期的日期。
语法
ds.DateFromDaysSince(number (int32), [baseline_date_object (string)])
返回: 通过向用户输入的基线日期添加整数来返回日期。
示例
如果 mylink.myintcol 包含整数 18250 ，而 mylink.mydatecol 包含日期 1958-08-18 ，那么以下三个函数等效，并返回日期 2008-08-05:
ds.DateFromDaysSince(18250,"1958-08-18")
ds.DateFromDaysSince(mylink.myintcol,"1958-08-18")
ds.DateFromDaysSince(mylink.myintcol,mylink.mydatecol)
如果 "mylink.mynegintcol包含整数-1，而 "mylink.mydatecol包含日期 1958-08-18，那么以下三个函数是等价的，并返回日期 1958-08-17：
ds.DateFromDaysSince(-1,"1958-08-18")
ds.DateFromDaysSince(mylink.mynegintcol,"1958-08-18")
ds.DateFromDaysSince(mylink.mynegintcol,mylink.mydatecol)
DateFromDaysSince2
通过向基线日期添加整数来返回日期。 该整数可以是负数，这样会返回早于基准日期的日期。
语法
ds.DateFromDaysSince2(number (int32), [baseline_date_object (date)])
返回: 通过向用户输入的基线日期添加整数来返回日期。
示例
如果 mylink.myint 包含整数 18250 ，而 mylink.mydate 包含日期 1958-08-18 ，那么以下三个函数等效，并返回日期 2008-08-05:
ds.DateFromDaysSince2(18250,"1958-08-18")
ds.DateFromDaysSince2(mylink.myint,"1958-08-18")
ds.DateFromDaysSince2(mylink.myint, mylink.mydate)
如果 "mylink.mynegint包含整数-1，而 "mylink.mydate包含日期 1958-08-18，那么以下三个函数是等价的，并返回日期 1958-08-17：
ds.DateFromDaysSince2(-1,"1958-08-18")
ds.DateFromDaysSince2(mylink.mynegint,"1958-08-18")
ds.DateFromDaysSince2(mylink.mynegint, mylink.mydate)
DateFromComponents
根据由三个单独的值指定的年月日来返回一个日期。
语法
ds.DateFromComponents(years (int32), months (int32), dayofmonth (int32))
返回: 具有指定值的单个日期。
示例
如果 mylink.year 包含值 2010 ， mylink.month 包含值 12 ，而 mylink.dayofmonth 包含值 2 ，那么以下两个函数等效，并返回日期 2010-12-02。
ds.DateFromComponents(2010, 12, 2)
ds.DateFromComponents(mylink.year, mylink.month, mylink.dayofmonth)
DateFromJulianDay
根据指定的儒略日编号返回日期。
语法
ds.DateFromJulianDay(julianday (uint32))
返回：给定儒略日值对应的日期。
示例
如果 mylink.myjul 包含值 2454614 ，那么以下两个函数等效，并返回日期 2008-05-27。
ds.DateFromJulianDay(2454614)
ds.DateFromJulianDay(mylink.myjul)
DateOffsetByComponents
返回指定的日期在应用指定的年偏移量、月偏移量和日偏移量（作为三个单独的值指定）之后得到的日期。 每个偏移值都可以是正数、零或负数。
语法
ds.DateOffsetByComponents(basedate (date), year_offset (int32), month_offset (int32), dayofmonth_offset (int32))
返回: 格式日期的给定日期偏移量。
示例
如果 mylink.basedate 包含 2011-08-18 ， mylink.yearos 包含值 2 ， mylink.monthos 包含值 0 ， mylink.dayofmonthosol 包含值 0 ，那么以下两个函数等效，并返回日期 2013-08-18。
ds.DateOffsetByComponents("2011-08-18", 2, 0, 0)
ds.DateOffsetByComponents(mylink.basedate, mylink.yearos, mylink.monthos, mylink.dayofmonthos)
如果 "mylink.basedate包含 2011-08-18，"mylink.yearos包含值-2，"mylink.monthos包含值 0，"mylink.dayofmonthosol包含值 0，那么以下两个函数是等价的，并返回日期 2009-08-18。
ds.DateOffsetByComponents("2011-08-18", -2, 0, 0)
ds.DateOffsetByComponents(mylink.basedate, mylink.yearos, mylink.monthos, mylink.dayofmonthos)
天
从系统日期开始返回月中的第几天。
语法
ds.Day()
返回 :int 格式的月份中的第几天。
示例
如果当前日期为 1967-12-31 ，那么以下代码将返回 31。
ds.Day()
DaysSinceFromDate
采用类型为日期的给定日期和类型为字符串的源日期，并返回从源日期到给定日期的天数。
语法
ds.DaysSinceFromDate(given_date (date), source_date_string (string))
返回: 类型为 int32的两个给定日期之间的天差。
示例
如果 mylink.mysourcedate 包含日期 1958-08-18 ，而 mylink.mygivendate 包含日期 2008-08-18 ，那么以下两个函数等效，并返回整数值 18263。
ds.DaysSinceFromDate(mylink.mygivendate, mylink.mysourcedate)
ds.DaysSinceFromDate("2008-08-18","1958-08-18")
DaysSinceFromDate2
采用类型为日期的给定日期和类型为日期的源日期，并返回从源日期到给定日期的天数。
语法
ds.DaysSinceFromDate2(given_date (date), source_date_object (date))
返回：两个给定日期之间间隔的天数（int32 格式）。
示例
如果 mylink.mysourcedate 包含日期 1958-08-18 ，而 mylink.mygivendate 包含日期 2008-08-18 ，那么以下两个函数等效，并返回整数值 18263。
ds.DaysSinceFromDate2(mylink.mygivendate, mylink.mysourcedate)
ds.DaysSinceFromDate2("2008-08-18","1958-08-18")
DaysInMonth
返回指定的基准日期中月份的天数。
语法
ds.DaysInMonth(basedate (date))
返回：int32 格式的月份天数。
示例
如果 mylink.mysourcedate 包含日期 1958-08-18 ，那么以下两个函数等效，将返回整数值 31。
ds.DaysInMonth(mylink.mysourcedate)
ds.DaysInMonth("1958-08-18")
DaysInYear
返回指定的基准日期中年份的天数。
语法
ds.DaysInYear(basedate (date))
返回：int32 格式的年份天数。
示例
如果 mylink.mysourcedate 包含日期 2012-08-18，那么以下两个函数等效，都会返回整数值 366：
ds.DaysInYear(mylink.mysourcedate)
ds.DaysInYear("2012-08-18")
如果 mylink.mysourcedate 包含日期 2011-08-18 ，那么以下两个函数等效，将返回整数值 365。
ds.DaysInYear(mylink.mysourcedate)
ds.DaysInYear("2011-08-18")
DateOffsetByDays
返回指定的日期在应用指定天数的偏移量之后得到的日期。 偏移值可以是正数、零或负数。
语法
ds.DateOffsetByDays(basedate (date), dayoffset (int32))
返回：具有相应偏移量的日期对象。
示例
如果 mylink.basedate 包含 2011-08-18 并且 mylink.dayoffset 包含值 2 ，那么以下两个函数等效，并返回日期 2011-08-20。
ds.DateOffsetByDays("2011-08-18", 2)
ds.DateOffsetByDays(mylink.basedate, mylink.dayoffset)
如果 mylink.basedate 包含 2011-08-18 ，而 mylink.dayoffset 包含值 -31 ，那么以下两个函数等效，将返回日期 2011-07-18。
ds.DateOffsetByDays("2011-08-18", -31)
ds.DateOffsetByDays(mylink.basedate, mylink.dayoffset)
HoursFromTime
返回时间的小时部分。
语法
ds.HoursFromTime(time (time))
返回：int8 格式的小时值。
示例
如果 mylink.mytime 包含时间 22:30:00，那么以下两个函数是等效的，都返回整数值 22。
ds.HoursFromTime(mylink.mytime)
ds.HoursFromTime("22:30:00")
JulianDayFromDate
根据指定的日期返回对应的儒略日编号。
语法
ds.JulianDayFromDate(time (time))
返回：给定日期的儒略日值（int32 格式）。
示例
如果 mylink.mydate 包含日期 2008-05-27 ，那么以下两个函数等效，并返回值 2454614。
ds.JulianDayFromDate("2008-05-27")
ds.JulianDayFromDate(mylink.mydate)
MicroSecondsFromTime
返回时间的微秒部分。
语法
ds.MicroSecondsFromTime(time (time))
返回：给定时间的微秒值（int32 格式）。
示例
如果 mylink.mytime 包含时间 22:30:00.32，那么以下函数将返回值 320000：
ds.MicroSecondsFromTime(mylink.mytime)
MidnightSecondsFromTime
返回从午夜到指定时间的秒数。
语法
ds.MidnightSecondsFromTime(time (time))
返回: 从午夜到时间的第二个值，采用 int8 格式。
示例
如果 mylink.mytime 包含时间 00:30:52，那么以下两个函数是等效的，都返回值 1852：
ds.MidnightSecondsFromTime("00:30:52")
ds.MidnightSecondsFromTime(mylink.mytime)
MinutesFromTime
返回时间的分钟部分。
语法
ds.MinutesFromTime(time (time))
返回: 时间的分钟值，采用 int8 格式。
示例
如果 mylink.mytime 包含时间 22:30:52，那么以下两个函数是等效的，都返回值 30：
ds.MinutesFromTime("22:30:52")
ds.MinutesFromTime(mylink.mytime)
MonthDayFromDate
返回指定日期的日部分。
语法
ds.MonthDayFromDate(date (date))
返回: int8 格式的从给定日期开始的月份中的日期。
示例
如果 mylink.mydate 包含日期 2008-08-18，那么以下两个函数是等效的，都返回值 18：
ds.MonthDayFromDate("2008-08-18")
ds.MonthDayFromDate(mylink.mydate)
MonthFromDate
返回指定日期的月份。
语法
ds.MonthFromDate(date (date))
返回: 格式为 int8的月份数。
示例
如果 mylink.mydate 包含日期 2008-08-18 ，那么以下两个函数都将返回值 8:
ds.MonthFromDate("2008-08-18")
ds.MonthFromDate(mylink.mydate)
WeekdayFromDate
返回自给定日期以来的星期几。 您可以指定视为一周中第一天的日期，如果未指定，那么缺省情况下为星期日。
语法
ds.WeekdayFromDate(date (date), [origin_day (string)])
返回: 自给定日期以来的一周中的第几天，格式为 int8 。
示例
如果 mylink.mydate 包含日期 2008-08-18，那么以下两个函数是等效的，都返回值 1：
ds.WeekdayFromDate("2008-08-18")
ds.WeekdayFromDate(mylink.mydate)
如果 mylink.mydate 包含日期 2008-08-18 ，而 mylink.origin_day 包含 "星期六" ，那么以下函数等效，并返回值 2:
ds.WeekdayFromDate("2008-08-18", "saturday")
ds.WeekdayFromDate("2008-08-18", "sat")
ds.WeekdayFromDate(mylink.mydate, mylink.origin_day)
NextWeekdayFromDate
返回源日期之后第一个指定的星期几的日期。 将星期几指定为全名，例如， thweek ，或三个字母的缩写，例如， "thu"。
语法
ds.NextWeekdayFromDate(sourcedate (date), day_of_week (string))
返回：给定日期的日部分。
示例
如果 mylink.mysourcedate 包含日期 2008-08-18 并且指定的星期几是星期四，那么以下两个函数等效，并返回值 2008-08-21:
ds.NextWeekdayFromDate("2008-08-18", "thursday")
ds.NextWeekdayFromDate(mylink.mysourcedate, "thu")
NthWeekdayFromDate
返回从源日期偏移指定星期数后的指定星期几的日期。 星期几可以用完整名称指定，例如 thursday；也可以用三字母缩写指定，例如 thu。 偏移值可以是正数、负数或零。
语法
ds.NthWeekdayFromDate(basedate (date), day_of_week (string), week_offset (int32))
返回：与指定日期偏移几周的指定工作日所在的日期。
示例
如果 mylink.mydate 包含日期 2009-08-18 ，并且使用偏移量 1 指定了星期四，那么以下两个函数等效，并返回值 2009-08-20。 将返回第一次出现的星期四。 在上述示例中，该星期四与日期 2009-08-18 出现在同一星期中。 日期 2009-08-18 是星期二。
ds.NthWeekdayFromDate("2009-08-18", "thursday", 1)
ds.NthWeekdayFromDate(mylink.mydate, "thu", 1)
如果 "mylink.mydate包含日期 2009-08-18，并且指定了偏移量为-2 的星期四，那么以下两个函数是等价的，并返回值 2009-08-06。 返回过去的两个星期四。
ds.NthWeekdayFromDate("2009-08-18", "thursday", -2)
ds.NthWeekdayFromDate(mylink.mydate, "thu", -2)
PreviousWeekdayFromDate
返回源日期之前最近一个指定星期几的日期。 将星期几指定为全名，例如， thweek ，或三个字母的缩写，例如， "thu"。
语法
ds.PreviousWeekdayFromDate(sourcedate (date), day_of_week (string))
返回：距离指定日期最近的一个工作日所在的日期。
示例
如果 mylink.mysourcedate 包含指定的日期 2008-08-18 和星期四，那么以下两个函数等效，并返回值 2008-08-14:
ds.PreviousWeekdayFromDate("2008-08-18", "thursday")
ds.PreviousWeekdayFromDate(mylink.mysourcedate, "thu")
SecondsFromTime
返回时间的第二部分。
语法
ds.SecondsFromTime(time (time))
返回 :dfloat 格式的时间的第二个值。
示例
如果 mylink.mytime 包含时间 22:30:52，那么以下两个函数是等效的，都返回值 52：
ds.SecondsFromTime("22:30:52")
ds.SecondsFromTime(mylink.mytime)
SecondsSinceFromTimestamp
返回两个时间戳记对象之间的秒数。
语法
ds.SecondsSinceFromTimestamp(timestamp (timestamp), timestamp_base_string (string))
返回 :dfloat 格式的第二个值。
示例
如果 mylink.mytimestamp 包含时间戳记 2008-08-18 22:30:52 ，并且 mylink.mytimestamp_base 包含时间戳记 2008-08-19 22:30:52 ，那么以下两个函数等效，并返回值 -86400:
ds.SecondsSinceFromTimestamp("2008-08-18 22:30:52","2008-08-19 22:30:52")
ds.SecondsSinceFromTimestamp(mylink.mytimestamp, mylink.mytimestamp_base)
SecondsSinceFromTimestamp2
返回两个时间戳记对象之间的秒数。
语法
ds.SecondsSinceFromTimestamp2(timestamp (timestamp), timestamp_base_object (timestamp))
返回 :dfloat 格式的第二个值。
示例
如果 mylink.mytimestamp 包含时间戳记 2008-08-18 22:30:52 ，并且 mylink.mytimestamp_base 包含时间戳记 2008-08-19 22:30:52 ，那么以下两个函数等效，并返回值 -86400:
ds.SecondsSinceFromTimestamp2("2008-08-18 22:30:52","2008-08-19 22:30:52")
ds.SecondsSinceFromTimestamp2(mylink.mytimestamp, mylink.mytimestamp_base)
时间
返回表示一天中的内部时间的字符串值。 内部时间是自午夜起经过到最接近的千分之一秒 (本地时间) 的秒数。
语法
ds.Time()
返回: 格式字符串的结果时间。
示例
如果当前时间为 11:17:43:19 ，那么以下代码将返回 40663.842:
ds.Time()
TimeDate
以格式字符串形式返回系统时间和日期。
语法
ds.TimeDate()
返回：string 格式的系统时间和日期。
TimeFromComponents
以 int32格式返回给定小时，分钟，秒和微秒的日期类型时间。
语法
ds.TimeFromComponents(hours (int32), minutes (int32), seconds (int32), microseconds (int32))
返回: 日期类型中的时间。
示例
如果 mylink.hourcol 包含值 10 ， mylink.mincol 包含值 12 ， mylink.seccol 包含值 2 ， mylink.mseccol 包含 0 ，那么以下两个函数等效，返回时间 10:12:02:
ds.TimeFromComponents(10, 12, 2, 0)
ds.TimeFromComponents(mylink.hourcol, mylink.mincol, mylink.seccol, mylink.mseccol)
TimeFromMidnightSeconds
以时间格式返回系统时间。
语法
ds.TimeFromMidnightSeconds(seconds (time))
返回: 自午夜以来的秒数 (以时间格式表示)。
示例
如果 mylink.mymidnightseconds 包含值 240，那么以下两个函数是等效的，都返回值 00:04:00：
ds.TimeFromMidnightSeconds(240)
ds.TimeFromMidnightSeconds(mylink.mymidnightseconds)
TimeOffsetByComponents
返回基准时间在应用小时偏移量、分钟偏移量和秒偏移量（每个偏移量都以单独的值指定）之后得到的时间。 秒偏移量可以包括小数。
语法
ds.TimeOffsetByComponents(basetime (time), hour_offset (int32), minute_offset (int32), second_offset (dfloat))
返回：与指定值对应的时间偏移量。
示例
如果 mylink.basetime 包含 14:05:29，mylink.houros 包含值 2，mylink.minos 包含值 0，并且 mylink.secos 包含值 20，那么以下两个函数是等效的，都返回时间 16:05:49。
ds.TimeOffsetByComponents("14:05:29", 2, 0, 20)
ds.TimeOffsetByComponents(mylink.basetime, mylink.houros, mylink.minos, mylink.secos)
TimeOffsetBySeconds
返回基准时间在应用秒偏移量之后得到的时间。 秒偏移量可以包括小数。
语法
ds.TimeOffsetBySeconds(basetime (time), second_offset (dfloat))
返回: 由指定值偏移的时间 (以秒为单位)。
示例
如果 mylink.basetime 包含 14:05:29.30 并且 mylink.secos 包含值 2.5，那么以下两个函数等效，并返回时间 14:05:31。
ds.TimeOffsetBySeconds("14:05:29.30", 2.5)
ds.TimeOffsetBySeconds(mylink.basetime, mylink.secos)
TimestampFromDateTime
返回来自给定日期和时间的时间戳记。
语法
ds.TimestampFromDateTime(date (date), time (time))
返回：给定日期和时间的时间戳记。
示例
如果 mylink.mydate 包含日期 2008-08-18 ，而 mylink.mytime 包含时间 22:30:52 ，那么以下两个函数等效，并返回时间戳记 2008-08-18 22:30:52:
ds.TimestampFromDateTime("2008-08-18","22:30:52")
ds.TimestampFromDateTime(mylink.mydate, mylink.mytime)
TimestampFromSecondsSince
返回派生自基本时间戳记对象的秒数的时间戳记。
语法
ds.TimestampFromSecondsSince(seconds (dfloat), [base_timestamp_object (string)])
返回: 从给定的秒数值派生的时间戳记。
示例
如果 mylink.myseconds 包含值 2563 ，并且 mylink.timestamp_base 包含时间戳记 2008-08-18 22:30:52 ，那么以下两个函数等效，并返回时间戳记 2008-08-18 23:13:35:
ds.TimestampFromSecondsSince(2563,"2008-08-18 22:30:52")
ds.TimestampFromSecondsSince(mylink.myseconds,mylink.timestamp_base)
TimestampFromSecondsSince2
返回派生自基本时间戳记对象的秒数的时间戳记。
语法
ds.TimestampFromSecondsSince2(seconds (dfloat), [base_timestamp_object (timestamp)])
返回: 从给定的秒数值派生的时间戳记。
示例
如果 mylink.myseconds 包含值 2563 ，并且 mylink.timestamp_base 包含时间戳记 2008-08-18 22:30:52 ，那么以下两个函数等效，并返回时间戳记 2008-08-18 23:13:35:
ds.TimestampFromSecondsSince2(2563,"2008-08-18 22:30:52")
ds.TimestampFromSecondsSince2(mylink.myseconds, mylink.timestamp_base)
TimestampFromTimet
返回给定 UNIX time_t 字符串值中的时间戳记。
语法
ds.TimestampFromTimet(timet_string (int32))
返回: 从给定的秒数值派生的时间戳记。
示例
如果 mylink.mytimet 包含值 1234567890 ，那么以下两个函数等效，并返回时间戳记 2009-02-13 23:31:30:
ds.TimestampFromTimet(1234567890)
ds.TimestampFromTimet(mylink.mytimet)
TimestampFromTime2
返回来自给定时间和时间戳记对象的时间戳记。 时间对象中的值会覆盖时间戳记对象中的时间值，以便仅使用时间戳记中的日期部分。
语法
ds.TimestampFromTime2(time (time), timestamp (timestamp))
返回：给定时间和时间戳记对象中的时间戳记。
示例
如果 mylink.mytime 包含时间 12:03:22 ，而 mylink.mytimestamp 包含时间戳记 2008-08-18 22:30:52 ，那么以下两个函数等效，并返回时间戳记 2008-08-18 12:03:22:
ds.TimestampFromTime2("12:03:22", "2008-08-18 22:30:52")
ds.TimestampFromTime2(mylink.mytime, mylink.mytimestamp)
TimestampOffsetByComponents
返回时间戳记，带有派生自包含年偏移量、月偏移量、日偏移量、小时偏移量、分钟偏移量和秒偏移量的基本时间戳记的偏移量，每个偏移量作为单独的值给出。 秒偏移量可以包括微秒。
语法
ds.TimestampOffsetByComponents(basetimestamp (timestamp), year_offset (int32), month_offset (int32), dayofmonth_offset (int32), hour_offset (int32), minute_offset (int32), second_offset (dfloat))
返回：与指定值对应的时间戳记偏移量。
示例
如果 "mylink.basetimestamp包含 2009-08-18 14:05:29，"mylink.yearos"包含 0，"mylink.monthos"包含值 2，"mylink.dayos"包含值-4，"mylink.houros"包含值 2，"mylink.minos"包含值 0，"mylink.secos"包含值 20，那么以下两个函数是等价的，并返回时间戳 2009-10-14 16:05:49。
ds.TimestampOffsetByComponents("2009-08-18 14:05:29", 0, 2, -4, 2, 0, 20)
ds.TimestampOffsetByComponents(mylink.basetimestamp, mylink.houros,
mylink.minos, mylink.secos)
TimestampOffsetBySeconds
返回时间戳记，带有派生自带有秒的基本时间戳记的偏移量。 秒偏移量可以包括微秒。
语法
ds.TimestampOffsetBySeconds(basetimestamp (timestamp), second_offset (dfloat))
返回: 时间戳记格式的指定值的时间戳记偏移量。
示例
如果 mylink.basetimestamp 包含 2009-08-18 14:05:29 并且 mylink.secos 包含值 32760 ，那么以下两个函数等效，并返回时间戳记 2009-08-18 23:11:29:
ds.TimestampOffsetBySeconds("2009-08-18 14:05:29", 32760)
ds.TimestampOffsetBySeconds(mylink.basetimestamp, mylink.secos)
TimetFromTimestamp
返回来自给定时间戳记的 UNIX time_t 值。
语法
ds.TimetFromTimestamp(timestamp (timestamp))
返回: UNIX time_t (按给定时间戳记) ，格式为 int32 。
示例
如果 mylink.mytimestamp 包含值 2009-02-13 23:31:30 ，那么以下两个函数等效，并返回值 1234567890:
ds.TimetFromTimestamp("2009-02-13 23:31:30")
ds.TimetFromTimestamp(mylink.mytimestamp)
YeardayFromDate
返回指定的日期在该年份中所处的天数。
语法
ds.YeardayFromDate(date (date))
返回：int16 格式的天数。
示例
如果 mylink.mydate 包含日期 2008-08-18，那么以下两个函数是等效的，都返回值 231：
ds.YeardayFromDate("2008-08-18")
ds.YeardayFromDate(mylink.mydate)
YearFromDate
返回指定的日期所在年份。
语法
ds.YearFromDate(date (date))
返回：int16 格式的年份值。
示例
如果 mylink.mydate 包含日期 2008-08-18，那么以下两个函数是等效的，都返回值 2008：
ds.YearFromDate("2008-08-18")
ds.YearFromDate(mylink.mydate)
YearweekFromDate
返回指定的日期在该年份中所处的星期数。
语法
ds.YearweekFromDate(date (date))
返回：int16 格式的星期数。
示例
如果 mylink.mydate 包含日期 2008-08-18，那么以下两个函数是等效的，都返回值 33：
ds.YearweekFromDate("2008-08-18")
ds.YearweekFromDate(mylink.mydate)
月
返回当前月份。
语法
ds.Month()
返回: 当前月份。
示例
以下代码以 int 格式返回当前月份。
ds.Month()
年
返回当前年份。
语法
ds.Year()
返回: 当前年份为 int 格式。
示例
以下代码返回当前年份。
ds.Year()
运算符函数
运算符函数比较两个对象并返回布尔值 (true 或 false):
等于
比较两个对象是否相同。
语法
ds.EQ(object1 (any), object2 (any))
返回: 如果对象值相等，那么返回 true ，否则返回 false。
示例
下列表达式返回 true：
ds.EQ(null,null)
ds.EQ(true,true)
ds.EQ("1",1)
ds.EQ("1",1.0)
以下表达式返回 false:
ds.EQ(1,null)
ds.EQ(false,true)
ds.EQ("a","b")
不等于
比较两个对象是否不相同。
语法
ds.NE(object1 (any), object2 (any))
返回: 如果对象值不相等，那么返回 true ，否则返回 false。
示例
下列表达式返回 true：
ds.NE(1,null)
ds.NE(true,false)
ds.NE(false,true)
ds.NE("a","b")
以下表达式返回 false:
ds.NE(null,null)
ds.NE(true,true)
ds.NE(false,false)
ds.NE("a","a")
小于
采用两个对象作为参数，如果第一个对象小于第二个对象，那么返回 true。
语法
ds.LT(object1 (any), object2 (any))
返回: 如果第一个对象小于第二个对象，那么返回 true ，否则返回 false。
示例
下列表达式返回 true：
ds.LT("a","b")
以下表达式返回 false:
ds.LT("a","a")
ds.LT("a","b")
ds.LT("202310071855","20380727")
大于
采用两个对象作为参数，如果第一个对象大于第二个对象，那么返回 true。
语法
ds.GT(object1 (any), object2 (any))
如果第一个对象大于第二个对象，那么返回 true ，否则返回 false。
示例
下列表达式返回 true：
ds.GT("b","a")
以下表达式返回 false:
ds.GT("a","a")
ds.GT("5.12","5.123")
大于或等于
采用两个对象作为参数，如果第一个对象大于或等于第二个对象，那么返回 true。
语法
ds.GE(object1 (any), object2 (any))
返回: 如果第一个对象大于或等于第二个对象，那么返回 true ，否则返回 false。
示例
下列表达式返回 true：
ds.GE(2, 1)
ds.GE("a","a")
小于或等于
将两个对象作为参数，如果第一个对象小于或等于第二个对象，那么返回 true。
语法
ds.LE(object1 (any), object2 (any))
返回: 如果第一个对象小于或等于第二个对象，那么返回 true ，否则返回 false。
示例
下列表达式返回 true：
ds.GE(1, 2)
ds.LE("a","a") == true
逻辑函数
逻辑函数执行位运算。
BitAnd
返回两个整数参数的逐位与运算 (AND)。
语法
ds.BitAnd(number1 (uint64), number2 (uint64))
返回：uint64 格式的逐位与运算 (AND)。
示例
如果 mylink.mynumber1 包含数字 352，并且 mylink.mynumber2 包含数字 400，那么以下两个函数是等效的，都返回值 256：
ds.BitAnd(352,400)
ds.BitAnd(mylink.mynumber1, mylink.mynumber2)
BitCompress
返回由采用二进制“1”和“0”表示法的字符串自变量转换而成的整数。
语法
ds.BitCompress(string (string))
返回: 由格式为 uint64的二进制表示的结果数字。
示例
如果 mylink.mynumber1 包含字符串 "0101100000" ，那么以下两个函数都返回数字 352。
ds.BitCompress("0101100000")
ds.BitCompress(mylink.mynumber)
BitExpand
返回一个字符串，其中包含给定整数的二进制“1”和“0”表示法。
语法
ds.BitExpand(number (uint64))
返回：一个包含整数的二进制表示形式的字符串。
示例
如果 mylink.mynumber1 包含数字 352 ，那么以下两个函数等效，并返回字符串 "101100000"。
ds.BitExpand(352)
ds.BitExpand(mylink.mynumber)
BitOr
返回两个整数参数的逐位与运算 (OR)。
语法
ds.BitOr(number1 (uint64), number2 (uint64))
返回：两个整数参数的逐位或运算 (OR)。
示例
如果 mylink.mynumber1 包含数字 352，并且 mylink.mynumber2 包含数字 400，那么以下两个函数是等效的，都返回值 496：
ds.BitOr(352,400)
ds.BitOr(mylink.mynumber1, mylink.mynumber2)
BitXOr
返回两个整数参数的逐位与运算 (Exclusive OR)。
语法
ds.BitXOr(number1 (uint64), number2 (uint64))
返回：uint64 格式的逐位异或运算 (Exclusive OR)。
示例
如果 mylink.mynumber1 包含数字 352，并且 mylink.mynumber2 包含数字 400，那么以下两个函数是等效的，都返回值 240：
ds.BitXOr(352,400)
ds.BitXOr(mylink.mynumber1, mylink.mynumber2)
非
返回表达式逻辑值的补码。 如果表达式的值为 true ，那么 Not 函数将返回值 false (0)。 如果表达式的值为 false ，那么 NOT 函数将返回值 true (1)。 求值结果为 0 的数字表达式返回逻辑值 False。 求值结果为 NULL 值以外的其他任何值的数字表达式返回逻辑值 True。 空字符串在逻辑上为 False。 其他所有字符串表达式，包括包含空字符串、空格或数字 0 和空格的字符串都为 True。
语法
ds.Not()
返回: complement 的值，采用 int8 格式。
示例
如果 mylink.myexpression 包含表达式 5-5 ，那么以下两个函数等效，并返回值 1:
ds.Not(5-5)
ds.Not(mylink.myexpression)
如果 mylink.myexpression 包含表达式 5+5，那么以下两个函数是等效的，都返回值 0：
ds.Not(5+5)
ds.Not(mylink.myexpression)
SetBit
返回特定位设置为特定状态的整数，其中 origfield 是要对其执行操作的输入值，bitlist 是一个字符串，包含由逗号分隔的要设置状态的位数字的列表，bitstate 为 1 或 0，表明要将这些位设置为哪种状态。
语法
ds.SetBit(origfield (uint64), bitlist (string), bitstate (uint8))
返回：其各个位已设置为指定状态的数字（uint64 格式）。
示例
如果 mylink.origfield 包含数字 352 ， mylink.bitlist 包含列表 "2,4,8" ，而 mylink.bitstate 包含值 1 ，那么以下两个函数等效，并返回值 494:
ds.SetBit(356,"2,4,8",1)
ds.SetBit(mylink.origfield, mylink.bitlist, mylink.bitstate)
是
返回 1 的 true 值。
语法
ds.True()
返回: 整数 1。
示例
以下代码返回 1:
ds.True()
错
返回 0 的 false 值。
语法
ds.False()
返回: 整数 0。
示例
以下代码返回 0:
ds.False()
数学函数
数学函数执行数学运算。
Abs
返回任意数字表达式的绝对值。 表达式的绝对值是其无符号量级。
语法
ds.Abs(numeric_expression (int32))
返回：数字表达式的绝对值（dfloat 格式）。
示例
如果 mylink.number1 包含数字 12，并且 mylink.number2 包含数字 34，那么以下两个函数是等效的，都返回数字 22：
ds.Abs(12-34)
ds.Abs(mylink.mynumber1-mylink.mynumber2)
如果 mylink.number1 包含数字 34，并且 mylink.number2 包含数字 12，那么以下两个函数是等效的，都返回数字 22：
ds.Abs(34-12)
ds.Abs(mylink.mynumber1-mylink.mynumber2)
Acos
计算表达式的三角反余弦值。 该表达式的值必须是数字值。 结果以弧度表示。
语法
ds.Acos(numeric_expression (dfloat))
返回：dfloat 格式的弧度结果。
示例
如果 mylink.number 包含数字 0.707106781，那么以下两个函数等效，并返回值 0.7854:
ds.Acos(0.707106781)
ds.Acos(mylink.mynumber)
ACOS
返回表达式的三角弧余弦值。 输入必须是数字值。 结果以度数表示。
语法
ds.ACOS(expression (float64))
返回: float64 格式的角度 (以度为单位)。
示例
以下代码返回值 45:
ds.ACOS(0.707106781)
Asin
计算表达式的三角反正弦值。 该表达式的值必须是数字值。 结果以弧度表示。
语法
ds.Asin(numeric_expression (dfloat))
返回：dfloat 格式的弧度结果。
示例
如果 mylink.number 包含数字 0.707106781，那么以下两个函数等效，并返回值 0.7854:
ds.Asin(0.707106781)
ds.Asin(mylink.mynumber)
ASIN
返回表达式的三角正弦。 输入是以度数表示的角度。
语法
ds.ASIN(expression(float64))
返回: float64 格式的角度 (以度为单位)。
示例
以下代码返回值 45:
ds.ASIN(0.707106781)
Atan
计算表达式的三角反正切值。 该表达式的值必须是数字值。 结果以弧度表示。
语法
ds.Atan(numeric_expression (dfloat))
返回：dfloat 格式的弧度结果。
示例
如果 mylink.number 包含数字 135 ，那么以下两个函数等效，并返回值 1.5634，即弧切线为 135 的角度:
ds.Atan(135)
ds.Atan(mylink.mynumber)
ATAN
返回表达式的三角反正切。 输入必须是数字值。 结果以度数表示。
语法
ds.ATAN(expression(float64))
返回 :dfloat 格式的角度 (以度数为单位)。
示例
以下代码返回值 45:
ds.ATAN(1)
Atan2
通过使用两个输入的符号计算两个输入的三角反正切，以确定结果的象限。 输入必须为数字值。 结果以弧度表示。
语法
ds.Atan2(numeric_expression (dfloat, dfloat))
返回：dfloat 格式的弧度结果。
示例
如果 mylink.number1 包含数字 10.0 ，而 mylink.number2 包含数字 -10.0，那么以下两个函数等效，并返回值 2.3562:
ds.Atan2(10.0, -10.0)
ds.Atan2(mylink.mynumber1, mylink.mynumber2)
Ceil
计算大于等于指定十进制值的最小整数值。
语法
ds.Ceil(number (dfloat))
返回：int32 格式的最小整数值。
示例
如果 mylink.number 包含数字 2355.66，那么以下两个函数是等效的，都返回值 2356：
ds.Ceil(2355.66)
ds.Ceil(mylink.mynumber)
Cos
计算表达式的三角余弦值。 该表达式的值必须是数字值。 该表达式必须生成一个数字值，该数字值是以弧度表示的角度。
语法
ds.Cos(radians (dfloat))
返回：以弧度表示的角度（dfloat 格式）。
示例
如果 mylink.number 包含数字 0.785398，那么以下两个函数是等效的，都返回值 0.7071：
ds.Cos(0.785398)
ds.Cos(mylink.mynumber)
销售成本
返回角度的三角余弦值。 表达式是一个以度为单位的值的角度。
语法
ds.COS(expression(float64))
返回: float64 格式的角度 (以度为单位)。
示例
以下代码返回值 0.7071:
ds.COS(45)
Cosh
计算表达式的双曲余弦值。 该表达式的值必须是数字值。
语法
ds.Cosh(number (dfloat))
返回：dfloat 格式的余弦结果。
示例
如果 mylink.number 包含数字 2，那么以下两个函数是等效的，都返回值 3.7622：
ds.Cosh(2)
ds.Cosh(mylink.mynumber)
分区
计算表达式的双曲余弦值。 该表达式的值必须是数字值。
语法
ds.Div(dividend (dfloat), divisor (dfloat))
返回：dfloat 格式的余弦结果。
示例
如果 mylink.dividend 包含数字 100，并且 mylink.divisor 包含数字 25，那么以下两个函数是等效的，都返回值 4：
ds.Div(100,25)
ds.Div(mylink.dividend, mylink.divisor)
扩充
计算以 e 为底，表达式值指定次幂的结果。 e 的值近似于 2.71828。 该表达式的值必须是数字值。
语法
ds.Exp(number (dfloat))
返回：e 的指定次幂（dfloat 格式）。
示例
如果 mylink.number 包含数字 5，那么以下两个函数是等效的，都返回值 54.5982：
ds.Exp(5-1)
ds.Exp(mylink.number-1)
Fabs
计算指定浮点值的绝对值。
语法
ds.Fabs(number (dfloat))
返回：浮点数的绝对值。
示例
如果 mylink.number 包含数字 -26.53，那么以下两个函数是等效的，都返回值 26.53：
ds.Fabs(-26.53)
ds.Fabs(mylink.number)
Floor
计算小于等于指定十进制值的最大整数值。
语法
ds.Floor(number (dfloat))
返回: 小于或等于 int32 格式的十进制值的最大整数。
示例
如果 mylink.number 包含数字 203.25，那么以下两个函数是等效的，都返回值 203：
ds.Floor(203.25)
ds.Floor(mylink.number)
Ldexp
返回 2 的指数次幂乘以尾数的双精度浮点值。
语法
ds.Ldexp(mantissa (dfloat), exponent (int32))
返回：dfloat 格式的尾数结果。
示例
如果 mylink.mantissa 包含数字 2，并且 mylink.exponent 包含数字 3，那么以下两个函数是等效的，都返回值 16：
ds.Ldexp(2,3)
ds.Ldexp(mylink.mantissa, mylink.exponent)
Llabs
计算指定整数值的绝对值。
语法
ds.Llabs(number (integer))
返回：给定整数的绝对值（无符号整数格式）。
示例
如果 mylink.number 包含数字 -26，那么以下两个函数是等效的，都返回值 26。
ds.Llabs(-26)
ds.Llabs(mylink.number)
行
计算以 e为底的表达式的自然对数。 e 的值近似于 2.71828。 该表达式的值必须为大于 0 的数字值。
语法
ds.Ln(number (dfloat))
返回：以 e 为底的表达式的对数。
示例
如果 mylink.number 包含数字 6 ，那么以下两个函数等效，并返回值 1.7918:
ds.Ln(6)
ds.Ln(mylink.number)
Log10
返回指定值的以 10 为底的对数。
语法
ds.Log10(number (dfloat))
返回: 生成的 dfloat 格式的以 10 为底的对数。
示例
如果 mylink.number 包含数字 6 ，那么以下两个函数等效，并返回值 1.7782:
ds.Log10(6)
ds.Log10(mylink.number)
最大值
返回两个参数值中较大的值。
语法
ds.Max(number1 (int32), number2(int32))
返回: int32 格式的两个整数中的较大者。
示例
如果 mylink.number1 包含数字 6，并且 mylink.number1 包含数字 101，那么以下两个函数是等效的，都返回值 101：
ds.Max(6,101)
ds.Max(mylink.number1, mylink.number2)
最小值
返回两个自变量值的最小值。
语法
ds.Min(number1 (int32), number2(int32))
返回：两个整数中的较小者。
示例
如果 mylink.number1 包含数字 6，并且 mylink.number1 包含数字 101，那么以下两个函数是等效的，都返回值 6：
ds.Min(6,101)
ds.Min(mylink.number1, mylink.number2)
Mod
计算两个表达式 (dividend, divisor) 的模数（余数）。
语法
ds.Mod(dividend (int32), divisor (int32))
返回：int32 格式的模数结果。
示例
如果 mylink.dividend 包含数字 115，并且 mylink.divisor 包含数字 25，那么以下两个函数是等效的，都返回值 15：
ds.Mod(115,25)
ds.Mod(mylink.dividend, mylink.divisor)
Neg
对数字求反。
语法
ds.Neg(number (dfloat))
返回: 生成的 dfloat 格式的求反数。
示例
如果 mylink.number 包含数字 123，那么以下两个函数是等效的，都返回值 -123：
ds.Neg(123)
ds.Neg(mylink.number)
Pwr
计算表达式的指定次幂的值 (expression, power)。
语法
ds.Pwr(expression (dfloat), power (dfloat))
返回: 以 dfloat 格式将生成的数字提升到指定的幂。
示例
如果 mylink.expression 包含数字 2，并且 mylink.power 包含数字 3，那么以下两个函数是等效的，都返回值 8：
ds.Pwr(2,3)
ds.Pwr(mylink.expression, mylink.power)
兰特
返回 0 到 232-1 之间的伪随机整数。
语法
ds.Rand()
返回：uint32 格式的随机整数结果。
示例
此函数用于生成伪随机数：
ds.Rand()
随机
返回 0 到 232-1 之间的伪随机整数。
语法
ds.Random()
返回：uint32 格式的随机整数结果。
示例
此函数用于生成随机数：
ds.Random()
朗德
生成任何正或负随机整数或 0。 采用整数的总数作为输入，包括可以从中选择随机数的 0。 即，如果 n 是 numeric_expression 的值，那么将从数字 0 到 (n-1) 生成随机数。
语法
ds.Rnd(numeric_expression (int))
返回: 从 0 到 (numeric_expression - 1) 的整数格式的随机数。
示例
以下代码返回 0-19 的随机数。
ds.Rnd(20)
Sin
计算表达式的三角正弦值。 该表达式的值必须是数字值。 该表达式必须生成一个数字值，该数字值是以弧度表示的角度。
语法
ds.Sin(radians (dfloat))
返回：dfloat 格式的角度结果。
示例
如果 mylink.number 包含数字 0.785398，那么以下两个函数是等效的，都返回值 0.7071：
ds.Sin(0.785398)
ds.Sin(mylink.mynumber)
SIN
返回表达式的三角正弦。 输入是以度数表示的角度。
语法
ds.SIN(expression(float64))
返回 :dfloat 格式的角度 (以度数为单位)。
示例
以下代码返回值 0.7071:
ds.SIN(45)
Sinh
计算表达式的双曲正弦值。 该表达式的值必须是数字值。
语法
ds.Sinh(number (dfloat))
返回：dfloat 格式的正弦结果。
示例
如果 mylink.number 包含数字 2 ，那么以下两个函数等效，并返回值 3.6269:
ds.Sinh(2)
ds.Sinh(mylink.mynumber)
平方根
计算数字的平方根。
语法
ds.Sqrt(number (dfloat))
返回：给定数字的平方根结果（dfloat 格式）。
示例
如果 mylink.number 包含数字 450，那么以下两个函数是等效的，都返回值 21.2132：
ds.Sqrt(450)
ds.Sqrt(mylink.mynumber)
黄褐色
计算表达式的三角正切值。 该表达式必须生成一个数字值，该数字值是以弧度表示的角度。
语法
ds.Tan(radians (dfloat))
返回：dfloat 格式的正切结果。
示例
如果 mylink.number 包含数字 0.7853981，那么以下两个函数等效，并返回值 1:
ds.Tan(0.7853981)
ds.Tan(mylink.mynumber)
TAN
返回 TAN 函数以返回输入的三角正切。 输入表示以度数表示的角度。
语法
ds.TAN(expression(float64))
返回: float64 格式的角度 (以度为单位)。
示例
以下代码返回值 1:
ds.TAN(45)
ATAN
返回表达式的三角反正切。 输入必须是数字值。 结果以度数表示。
语法
ds.ATAN(expression(float64))
返回: float64 格式的角度 (以度为单位)。
示例
以下代码返回值 45:
ds.ATAN(1)
Tanh
计算表达式的双曲正切值。 该表达式的值必须是数字值。
语法
ds.Tanh(number (dfloat))
返回：dfloat 格式的正切结果。
示例
如果 mylink.number 包含数字 2，那么以下两个函数是等效的，都返回值 0.964028：
ds.Tanh(2)
ds.Tanh(mylink.mynumber)
数字函数
数字函数用于抽取十进制数或浮点数中的尾数。 表达式编辑器中的“数字”类别还包含类型为 casting 的函数，您可以使用该函数对数据类型为 double、float 或 integer 的数字进行强制类型转换。
当在结果为字符串的派生中使用变换器函数 AsDouble()， AsFloat()和 AsInteger() 时，它们的行为与其他变换器数据转换函数不同。 此行为是因为变换器编译器不会将这些函数的函数结果转换为字符串。
AsDouble
将给定数字视为双精度数。
语法
ds.AsDouble(number (int, float and so on))
返回: 双精度值格式的数字。
示例
在以下表达式中，输入 mynumber 包含一个整数，但函数输出一个双精度值。 如果 mylink.mynumber 包含值 56 ，那么以下两个函数等效，并返回值 12.963:
ds.AsDouble(56/4.32)
ds.AsDouble(mylink.mynumber/4.32)
AsFloat
将给定数字视为浮点数。
语法
ds.AsFloat(number (int, double and so on))
返回：float 格式的数字。
示例
在以下表达式中，输入 mynumber 包含一个整数，但函数输出一个浮点数。 如果 mylink.mynumber 包含值 56 ，那么以下两个函数等效，并返回值 12.963:
ds.AsFloat(56/4.32)
ds.AsFloat(mylink.mynumber/4.32)
AsInteger
将给定数字视为整数。 但是，当将十进制分配给整数时，与将浮点数或双精度值分配给整数时，行为上存在差异。 如果是从浮点数或双精度数转换为整数，那么这是对整数的简单赋值。 对于十进制 AsInteger()，将启动函数并将输出舍入为最接近的值。
语法
ds.AsInteger(number (float, double and so on))
返回：integer 格式的数字。
示例
在以下表达式中，输入值 12.962963 的类型为 Double。 尽管该值的类型为 Double，但函数输出一个整数。 因此，它是对整数函数的简单赋值，并返回值 12:
ds.AsInteger(12.962963)
在以下表达式中，类似 (56/4.32) 的计算被视为 "十进制" 类型， AsInteger() 函数调用开始向最接近的值舍入并返回值 13:
ds.AsInteger(56/4.32)
修订
将数字值转换为具有指定精度数的浮点数。 如果数字求值为空值，那么将返回空值。 精度值是与浮点数中的精度位数相对应的数字值。 缺省精度为 4。 方式值是一个标志，用于指定处理多余数字的方式。 如果方式为 0 或未指定，那么将舍入多余的数字。 如果方式不是 0 ，那么将截断多余的数字。
语法
ds.FIX(numeric_expression (string), precision (int8), mode (int32))
返回: 转换的格式 dfloat 数。
示例
以下代码返回数字 37.7363。
ds.FIX("37.73629273")
MantissaFromDecimal
返回给定十进制数的尾数。
语法
ds.MantissaFromDecimal(number (decimal))
返回：dfloat 格式的尾数。
示例
如果 mylink.number 包含数字 243.7675，那么以下两个函数是等效的，都返回值 7675：
ds.MantissaFromDecimal(243.7675)
ds.MantissaFromDecimal(mylink.mynumber)
MantissaFromDFloat
返回给定双精度浮点数的尾数。
语法
ds.MantissaFromDFloat(number (dfloat))
返回：dfloat 格式的尾数。
示例
如果 mylink.number 包含数字 1.234412000000000010E+4，那么以下函数将返回值 1:
ds.MantissaFromDFloat(mylink.mynumber)
实数
将字符串中的数字转换为浮点类型，而不会丢失准确性。
语法
ds.Real(numeric_expression (string))
返回: 转换的格式 dfloat 数。
示例
以下代码返回数字 1.23。
ds.Real("1.23")
原始函数
使用 "原始" 函数可获取包含原始数据的列中数据的长度。
RawLength
返回原始字符串的长度。
语法
ds.RawLength(input string (string))
返回：原始字符串的长度（int32 格式）。
示例
如果 mylink.rawdata 包含来自位图的原始数据，那么以下函数将返回该位图的大小（以字节为单位）：
ds.RawLength(mylink.rawdata)
字符串函数
将这些函数用于表达式中与字符串相关的函数。
AlNum
检查指定的字符串中是否只包含字母数字字符。
语法
ds.AlNum(string (string))
返回：int8 类型的结果；如果输入对于给定类型有效，那么返回 1，否则返回 0。
示例
如果 mylink.mystring1 包含字符串“OED_75_9*E”，那么以下函数将返回值 0 (false)。
ds.AlNum(mylink.mystring1)
如果 mylink.mystring2 包含字符串“12redroses”，那么以下函数将返回值 1 (true)。
ds.AlNum(mylink.mystring2)
Alpha
检查指定的字符串是否只包含字母字符。
语法
ds.Alpha(string (string))
返回：int8 类型的结果；如果输入对于给定类型有效，那么返回 1，否则返回 0。
示例
如果 mylink.mystring1 包含字符串 "12redroses" ，那么以下函数将返回值 0 (false)。
ds.Alpha(mylink.mystring1)
如果 mylink.mystring2 包含字符串 "头" ，那么以下函数将返回值 1 (true)。
ds.Alpha(mylink.mystring2)
cats
并置两个字符串。
语法
ds.Cats(str1 (string), str2 (string))
返回: 生成的并置字符串。
示例
以下代码返回 "ABC123"。
ds.Cats("ABC", "123")
将：
将表达式中的给定子串替换为替换字符串。
如果 substring 自变量为空字符串，那么会返回 expression 自变量的值。
如果替换自变量的值为空字符串，那么将除去从 begin 自变量的值指示的位置开始出现的所有子串。 如果出现参数的值小于或等于 0 ，那么将替换从 begin 参数的值指示的位置开始的所有出现。 否则，替换的出现次数将由出现自变量的值指示，从 begin 自变量的值指示的位置开始。 如果 begin 自变量的值小于或等于 1，那么将从出现的第一个 substring 开始进行替换。 否则，替换从由 thebegin 自变量的值指示的位置开始。
语法
ds.Change(expression (string), substring (string), replacement (string), [occurrence (int32), [begin (int32)]])
返回：替换了所有子字符串的新字符串。
示例
如果 "mylink.mystring"包含表达式 "aaabbbcccbbb"，那么下面的函数将返回字符串"aaaZZZcccZZZ"。
ds.Change(mylink.mystring,"bbb","ZZZ")
如果 mylink.mystring 包含表达式 "ABC" 并且子串为空，那么以下函数将返回字符串 "ABC"。
ds.Change(mylink.mystring,"","ZZZ")
如果 mylink.mystring 包含表达式 "aaabbbcccbbb" 并且替换为空，那么以下函数将返回字符串 "aaaccc"。
ds.Change(mylink.mystring, "bbb", "")
CompactWhiteSpace
返回将所有连续空格减少到单个空格后得到的字符串。
语法
ds.CompactWhiteSpace(string (string))
返回：去掉了多余空格的字符串结果。
示例
如果 mylink.mystring 包含字符串 "too many spaces" ，那么以下函数将返回字符串 "too many spaces":
ds.CompactWhiteSpace(mylink.mystring)
比较
比较用于排序的两个字符串。 比较可以采用左对齐形式（缺省值），也可以采用右对齐形式。 右对齐比较将指定字符串中的数字子串作为数字进行比较。
在每个字符串中，数字字符串必须出现相同的字符位置。 例如，对字符串 AB100 和 AB99 的右对齐比较结果表明 AB100 大于 AB99，这是因为 100 大于 99。 字符串 AC99 和 AB100 的左对齐比较指示 AC99 更大，因为 C 大于 B。
语法
ds.Compare(string1 (string), string2 (string), [justification ("L" or "R")])
返回：int8 类型的结果；如果 string1 小于 string2，那么返回 -1；如果两个字符串相同，那么返回 0；如果 string1 大于 string2，那么返回 1。
示例
如果 mylink.mystring1 包含字符串 "AB99" ，而 mylink.mystring2 包含字符串 "AB100" ，那么以下函数将返回结果 1。
ds.Compare(mylink.mystring1, mylink.mystring2, "L")
如果 "mylink.mystring1"包含字符串 "AB99"，而mylink.mystring2包含字符串AB100"，那么下面的函数将返回结果-1。
ds.Compare(mylink.mystring1, mylink.mystring2, "R")
CompareNoCase
比较用于排序的两个字符串（忽略其大小写）。
语法
ds.CompareNoCase(string1 (string), string2 (string))
返回：int8 类型的结果；如果 string1 小于 string2，那么返回 -1；如果两个字符串相同，那么返回 0；如果 string1 大于 string2，那么返回 1。
示例
如果 mylink.mystring1 包含字符串 "巧克力蛋糕" ，而 mylink.mystring2 包含字符串 "巧克力蛋糕" ，那么以下函数将返回结果 0。
ds.CompareNoCase(mylink.mystring1, mylink.mystring2)
CompareNum
比较两个字符串的前 n 个字符（n 由用户指定）。
语法
ds.CompareNum(string1 (string), string2 (string), length (int16))
返回：int8 类型的结果；如果 string1 小于 string2，那么返回 -1；如果两个字符串相同，那么返回 0；如果 string1 大于 string2，那么返回 1。
示例
如果 mylink.mystring1 包含字符串 "巧克力" ，而 mylink.mystring2 包含字符串 "巧克力治疗" ，那么以下函数将返回结果 0。
ds.CompareNum(mylink.mystring1, mylink.mystring2,4)
CompareNumNoCase
比较两个字符串的前 n 个字符（忽略其大小写，n 由用户指定）。
语法
ds.CompareNumNoCase(string1 (string), string2 (string), length (int16))
返回：int8 类型的结果；如果 string1 小于 string2，那么返回 -1；如果两个字符串相同，那么返回 0；如果 string1 大于 string2，那么返回 1。
示例
如果 mylink.myraw 包含字符串 "巧克力" ，而 mylink.mystring2 包含字符串 "巧克力治疗" ，那么以下函数将返回结果 0。
ds.CompareNumNoCase(mylink.mystring1, mylink.mystring2,4)
转换
将字符串转换为指定的内部或外部存储格式。 字符串表达式用于对要转换的字符串求值。
下表显示了可为转换指定的值。 conv_code 指定转换中涉及的存储格式类型， conv_mode 指定用于输入或输出的格式。 如果对 conv_mode指定 "I" ，那么将使用 ICONV() 函数进行转换。 如果为 conv_mode指定 "O" ，那么将使用 OCONV() 函数进行转换。
转换值表
conv_code |
conv_mode |
描述 |
|---|---|---|
| MX | I | 将输入字符串从十六进制转换为十进制。 |
| MB | I | 将输入字符串从二进制转换为十进制。 |
| MX0C | I | 将输入字符串从十六进制转换为 ASCII 字符串。 |
| MB0C | I | 将输入字符串从二进制转换为 ASCII 字符串。 |
| MX | O | 将输入字符串从十进制转换为十六进制。 |
| MB | O | 将输入字符串从十进制转换为二进制。 |
| MX0C | O | 将输入字符串从 ASCII 字符串转换为十六进制。 |
| MB0C | O | 将输入字符串从 ASCII 字符串转换为二进制。 |
语法
ds.Conversion(string (string), conv_code (string), conv_mode (string))
返回: 转换后的字符串。
示例
如果 mylink.mystring 包含字符串 "1111" ，那么以下函数将返回值 15。
ds.Conversion(mylink.mystring,"MB", "I")
如果 mylink.mystring 包含字符串 "CDE" ，那么以下函数将返回值 434445。
ds.Conversion(mylink.mystring,"MX0C", "O")
转换
转换给定 expression 中指定的字符串中的字符。 将一个列表中指定的字符转换为另一个列表中指定的字符。
语法
ds.Convert(fromlist (string), tolist (string), expression (string))
返回：包含转换后的指定字符的字符串。
示例
如果 mylink.mystring1 包含字符串 "NOW IS THE TIME" ，那么以下函数将返回字符串 "NOW YS XHE XYME"。
ds.Convert("TI","XY", mylink.mystring1)
计数
统计子串在字符串中出现的次数。
语法
ds.Count(string (string), substring (string))
返回: int32 格式的子串出现次数。
示例
如果 mylink.mystring1 包含字符串 "巧克力滴，巧克力冰淇淋，巧克力棒" ，那么以下函数将返回 3。
ds.Count(mylink.mystring1, "choc")
Dcount
统计字符串中定界字段的数目。
语法
ds.Dcount(string (string), delimiter (string))
返回: int32 格式的定界字段数。
示例
如果 mylink.mystring1 包含字符串 "巧克力滴，巧克力冰淇淋，巧克力棒" ，那么以下函数将返回 3。
ds.Dcount(mylink.mystring1,",")
DownCase
将字符串中的所有大写字母转换为小写字母。
语法
ds.DownCase(string (string))
返回: 生成的字符串 (全小写)。
示例
如果'mylink.mystring1包含字符串'"CaMel'cAsE",，那么下面的函数将返回字符串 "camel case"。
ds.DownCase(mylink.mystring1)
DQuote
在字符串两边加上双引号。
语法
ds.DQuote(string (string))
返回：用双引号括起的字符串结果。
示例
如果 mylink.mystring1 包含字符串需要引号，那么以下函数将返回字符串 "需要引号"。
ds.DQuote(mylink.mystring1)
Ereplace
将 expression 中的 substring 替换为 replacement 字符串。
如果 substring 自变量为空字符串，那么 replacement 自变量的值将前缀 expression 自变量的值。 如果替换自变量是空字符串，那么将除去从 begin 自变量的值指示的位置开始的所有出现的子串。 如果实例参数的值小于或等于 0 ，那么将替换从 begin 参数的值开始的所有实例。 否则，将从 begin 自变量的值指示的位置开始，替换出现，替换的数量根据 occurrence 自变量的值指示确定。 如果 begin 自变量的值小于或等于 1，那么将从出现的第一个 substring 开始进行替换。 否则，替换将从 begin 自变量的值所指示的位置开始。
语法
ds.Ereplace(expression (string), substring (string), replacement (string), [occurrence (int32), [begin (int32)]])
返回：替换了所有出现的子字符串的字符串结果。
示例
如果 mylink.mystring 包含表达式 "ABC" 并且子串为空，那么以下函数将返回值 "ZZZABC"。
ds.Ereplace(mylink.mystring,"","ZZZ")
如果 mylink.mystring 包含表达式 "aaabbbcccbbb" 并且替换为空，那么以下函数将返回值 "aaaccc"。
ds.Ereplace(mylink.mystring, "bbb", "")
Exchange
替换字符串中的字符。
语法
ds.Exchange(str (string), findStr (string), replaceStr (string))
返回: 生成的带有替换字符的字符串。
示例
以下代码返回: ".B.BC"。
ds.Exchange("ABABC", "41", "2E")
EXTRACT
从动态数组中访问指定字段，值或子值的数据内容。 与 REMOVE类似的函数。
输入动态数组必须只有 CHAR (254) ， CHAR (253) ， CHAR (252) 作为定界符，并且它们的层次结构必须是前写的。 可以分别通过 AM ， FM ， VM ， SM 或 SVM 函数进行检索。 FM 是字符串字段的定界符， VM 是字符串值的定界符， SM 是字符串子值的定界符。
要了解有关 "EXTRACT的更多信息，请参阅EXTRACT 函数。
语法
ds.EXTRACT(str (string), field (int64), [value (int64), subvalue (int64)])
返回: 生成的格式字符串的抽取字符串。
示例
以下代码均返回: "9 ü 3 ü 5"。 动态数组包含以 FM/AM 分隔的 3 个字段，第一个字段中的 2 个值，第一个值中的 1 个子值等等。
ds.EXTRACT("1" + ds.FM() + "4" + ds.VM() + "9" + ds.SM() + "3" + ds.SM() + "5" + ds.FM() + "1" + ds.VM() + "0" + ds.SM() + "7" + ds.SM() + "3", 2, 2)
ds.EXTRACT("1" + ds.AM() + "4" + ds.VM() + "9" + ds.SM() + "3" + ds.SM() + "5" + ds.AM() + "1" + ds.VM() + "0" + ds.SM() + "7" + ds.SM() + "3", 2, 2)
以下代码返回空字符串，因为只有 3 个字段，而不是 10 个或更多字段。
ds.EXTRACT("1" + ds.FM() + "4" + ds.VM() + "9" + ds.SM() + "3" + ds.SM() + "5" + ds.FM() + "1" + ds.VM() + "0" + ds.SM() + "7" + ds.SM() + "3", 10, 0, 0)
字段
返回位于字符串中指定定界符之间的一个或多个子串。 自变量 occurrence 指定第几个出现的定界符用作终止符。 自变量 number 指定返回多少个子串（可选）。
语法
ds.Field(string (string), delimiter (string), occurrence (int32), [number (int32)])
返回：定界符之间的相应字符串。
示例
如果 mylink.mystring1 包含字符串 "巧克力滴，巧克力冰淇淋，巧克力棒，巧克力营养师" ，那么以下函数将返回字符串 " 巧克力冰激凌 "。
ds.Field(mylink.mystring1,",",2)
如果 mylink.mystring1 包含字符串 "巧克力滴，巧克力冰淇淋，巧克力棒，巧克力营养师" ，那么以下函数将返回字符串 " 巧克力冰淇淋，巧克力棒 "。
ds.Field(mylink.mystring1,",",2,2)
FieldStore
通过插入，删除或替换由指定定界符字符串分隔的字段来修改字符串。 定界符字符串表示要修改的字符串，可以是任何单个 ASCII 字符。 此函数还采用参数 start (修改开始的输入字符串的位置) 和 number (这是在输入字符串中插入新字符串的次数)。
语法
ds.FieldStore(str (string), delimiter (string), start (int8), number (int8), new_fields (string))
返回: 格式字符串的已修改字符串。
示例
以下代码返回字符串 A#B#C#D#5:
ds.FieldStore("1#2#3#4#5", "#", 1, 4, "A#B#C#D")
弗特姆
使用 FMT 函数或格式表达式来格式化数据以进行输出。 任何 BASIC 表达式都可以通过跟在它后面使用格式表达式来进行格式化以输出。 有关 Fmt 函数语法的详细信息，请参阅 FMT 函数。
语法
ds.Fmt(string (string), format (string))
返回: 生成的格式字符串的格式化数据。
示例
以下代码返回字符串 "23-69-86":
ds.Fmt("236986","R##-##-##")
以下代码返回数字 "***** $555,666 ，898.00":
ds.Fmt("555666898","20*R2$,")
FmtDP
将类型为字符串的多字节字符集转换为目标格式。 如果未启用全球化 (全球化) ，那么 FmtDP 函数的工作方式类似于等效的 Fmt 函数。 有关 FmtDP 函数的语法的详细信息，请参阅 FmtDP 函数。
语法
ds.FmtDP(string (string), format (string), [mapname (string)])
返回: 格式字符串的转换字符串。
示例
以下代码返回数字 56789:
ds.FmtDP("123456789","R#5")
折叠
折叠字符串以创建子串。 string 是要折叠的字符串。 length 是子串的长度 (以字符计)。
ds.Fold(str (string), length (int8))
返回: 生成的折叠字符串。
以下代码返回 "T E S I S A B I S A B E S T E S T E D D D STRING"。
ds.Fold("THIS IS A TEST FOLDED STRING", 5)
福尔德普
在全球化 (全球化) 方式下，折叠字符串以创建使用字符显示位置的子串。
语法
ds.Folddp(str (string), length (int), opmap (string))
返回: 生成的折叠字符串。
示例
以下代码返回: "这里需要使用 UNICODE STRING"。
ds.Folddp("这里需要 UNICODE STRING", 5, "0")
索引
查找子串的起始字符位置。 自变量 occurrence 指定要查找第几个出现的子串。
语法
ds.Index(string (string), substring (string), occurrence (int32))
返回: int32 格式的出现次数的结果。
示例
如果 mylink.mystring1 包含字符串 "巧克力滴，巧克力冰淇淋，巧克力棒，巧克力营养师" ，那么以下函数将返回值 18。
ds.Index(mylink.mystring1,"chocolate",2)
居左
返回字符串中最左侧的 n 个字符。
语法
ds.Left(string (string) number (int32))
返回：字符串中最左侧的 n 个字符。
示例
如果 mylink.mystring1 包含字符串 "巧克力滴，巧克力冰淇淋，巧克力棒，巧克力营养师" ，那么以下函数将返回字符串 "巧克力"。
ds.Left(mylink.mystring1,9)
Len
返回字符中字符串的长度。
语法
ds.Len(string (string))
返回: 字符串的长度，采用 int32 格式。
示例
如果 mylink.mystring1 包含字符串 "巧克力" ，那么以下函数将返回值 9。
ds.Len(mylink.mystring1)
伦德普
在全球化 (全球化) 方式下，返回字符串的长度及其总显示位置。
语法
ds.Lendp(str (string), opmap (string))
返回: 格式为 int64的字符串的长度。
示例
以下代码返回: 19。
ds.Lendp("这里需要 UNICODE STRING", "0")
匹配
与 MATCHES 的同义词。 用于将字符串表达式与模式进行比较。 要了解有关 "Match语法的更多信息，请参阅匹配操作符。
语法
ds.Match(str (string), pattern (string))
返回: 模式是否与格式为 Boolean 的输入字符串匹配的结果。
示例
以下代码返回 false:
ds.Match("XYZ123AB", "3X3N")
以下代码返回 true:
ds.Match("XYZ123AB", "3X3N...")
MatchField
搜索字符串并返回其与输入 pattern 参数匹配的部分。 要了解有关 "MatchField语法的更多信息，请参阅MATCH 操作符。
语法
ds.MatchField(str (string), pattern (string), field (int))
返回: 格式字符串的结果。
示例
以下代码返回字符串 "XYZ":
ds.MatchField("XYZ123AB", "3X3N...", 1)
编号
如果字符串可以转换为数字，那么返回 1。否则，返回 0。
语法
ds.Num(string (string))
返回: 如果字符串可以转换为数字，那么返回 1 ，否则返回 0 ，格式为 int32 。
示例
如果 mylink.mystring1 包含字符串 "22" ，那么以下函数将返回值 1。
ds.Num(mylink.mystring1)
如果 mylink.mystring1 包含字符串 "二十二" ，那么以下函数将返回值 0。
ds.Num(mylink.mystring1)
PadString
返回用指定的填充字符数填充的字符串。
语法
ds.PadString(string (string) padstring (string) padlength (int32))
返回：填充字符串结果。
示例
如果 mylink.mystring1 包含字符串 "AB175" ，那么以下函数将返回字符串 "AB17500000"。
ds.PadString(mylink.mystring1,"0",5)
移除
抽取并返回由系统定界符分隔的动态数组元素，并指示找到了哪个系统定界符。 它接受一个 CHAR 作为定界符，并返回对应于找到的定界符的数字。
| 编号 | 分隔符类型 |
|---|---|
| 0 | 字符串结束 |
| 1 | 项标记 ASCII CHAR (255) |
| 2 | 字段标记 ASCII CHAR (254) |
| 3 | 值标记 ASCII CHAR (253) |
| 4 | 子值标记 ASCII CHAR (252) |
| 5 | 文本标记 ASCII CHAR (251) |
| 6 | ASCII CHAR (250) (PIOPEN 风格中不可用) |
| 7 | ASCII CHAR (249) (PIOPEN 风格中不可用) |
| 8 | ASCII CHAR (248) (在 PIOPEN 类型模板中不可用) |
有关 REMOVE 功能的更多信息，请参阅REMOVE 功能。
语法
ds.REMOVE(str (string))
返回: 除去格式字符串列表的定界符后生成的字符串，以及与找到的定界符对应的数字。
示例
以下代码返回 ["3" ， "12"]。
ds.REMOVE("12" + ds.VM() + "12" + ds.VM())
居右
返回字符串中最右侧的 n 个字符。
语法
ds.Right(string (string) number (int32))
返回：字符串中最右侧的 n 个字符。
示例
如果 mylink.mystring1 包含字符串 "巧克力滴，巧克力冰淇淋，巧克力棒，巧克力营养师" ，那么以下函数将返回字符串 "dippers"。
ds.Right(mylink.mystring1,7)
soundex
返回一个代码，该代码根据 SOUNDEX 求值的标准开放式算法来标识一组 (大致) 发音相似的词。
语法
ds.Soundex(string (string))
返回：用于标识一组发音相似的单词的代码。
示例
如果 mylink.mystring1 包含字符串 "Griffin" ，那么以下函数将返回代码 "G615"。
ds.Soundex(mylink.mystring1)
如果 mylink.mystring1 包含字符串 "Griphin" ，那么以下函数还会返回代码 "G615"。
ds.Soundex(mylink.mystring1)
空间
返回包含 n 个空格字符的字符串。
语法
ds.Space(length (int32))
返回：包含指定长度的空格的字符串。
示例
如果 mylink.mylength 包含数字 100，那么以下函数将返回一个包含 100 个空格的字符串。
ds.Space(mylink.mylength)
SQuote
将字符串用单引号括起来。
语法
ds.SQuote(string (string))
返回：用单引号括起的字符串。
示例
如果 mylink.mystring1 包含字符串需要引号，那么以下函数将返回字符串 "需要引号"。
ds.SQuote(mylink.mystring1)
Str
将字符串重复指定的次数。
语法
ds.Str(string (string), repeats (int32))
返回：重复了 n 次的字符串结果。
示例
如果 mylink.mystring1 包含字符串需要 "choc" ，那么以下函数将返回字符串 "巧克力巧克力巧克力"。
ds.Str(mylink.mystring1,5)
StripWhiteSpace
在除去字符串中的所有空格字符后返回该字符串。
语法
ds.StripWhiteSpace(string (string))
返回：不含空格的字符串。
示例
如果 mylink.mystring 包含字符串 "太多空格" ，那么以下函数将返回字符串 "toomanyspaces":
ds.StripWhiteSpace(mylink.mystring)
子串
返回指定的子串。
指定 n 时，该函数将获取字符串的最后 n 个字符。
当指定了 start 和 length 时，函数将从字符串的 start 位置开始获取长度等于 length 的字符。
指定 定界符 时，该函数将获取一个或多个位于字符串中指定定界符之间的子串。 occu 是定界符数， num 是生成的子串中定界符之间的子串长度。
语法
ds.Substring(string (string), n (int8))
ds.Substring(string (string), start (int8), length (int8))
ds.Substring(string (string), delimiter (string), occu (int8), num (int8))
返回: 生成的格式字符串的子串数组。
示例
以下代码返回 "ab.cd"。
ds.Substring("ab.cd", ".", 1, 2)
子串
创建一个动态数组，其中所有元素都是输入动态数组的相应元素的子串。
语法
ds.Substrings(str (string), start (int8), length (int8))
返回: 生成的具有与输入数组对应的子串的字符串格式的动态数组。
示例
以下代码将返回 "NESýITHþ23üý50ü"。
ds.Substrings("JONESýSMITHþ1.23ü20ý2.50ü10", 3, 20)
删除
除去所有前导空格、结尾空格和制表符。 此函数还会将空格或制表符的内部出现至少至一个。
参数 stripchar 指定除空格或跳格之外的字符（可选）。 自变量 options 指定要执行的修剪操作的类型，并包含以下一个或多个值:
A：移除所有出现的 stripchar。
B：移除出现的前导和尾随 stripchar。
D：移除前导、尾随和多余的空格字符。
E：移除尾随空格字符。
F：移除前导空格字符。
L：移除所有出现的前导 stripchar。
R：移除出现的前导、尾随和多余的 stripchar。
T：移除所有出现的尾随 stripchar。
语法
ds.Trim(string (string), [stripchar (string)], [options (string)])
返回：修剪后的字符串。
示例
如果 mylink.mystring 包含字符串 " 具有空格的字符串 "，然后以下函数返回字符串" 具有空格的字符串 ":
ds.Trim(mylink.mystring)
如果 mylink.mystring 包含字符串 " ..除去 .. 冗余 .. 点 .... " ， 那么以下函数将返回字符串 "Remove.redundant.dots":
ds.Trim(mylink.mystring,".")
如果 mylink.mystring 包含字符串 "Remove .. all.. dots...." ， 那么以下函数将返回字符串 "Removealldot":
ds.Trim(mylink.mystring,".","A")
如果 mylink.mystring 包含字符串 "Remove .. trailing.. dots...." ， 然后，以下函数返回字符串 "Remove .. trailing.. dot":
ds.Trim(mylink.mystring,".","T")
TrimB
除去字符串中所有结尾空格和制表符。
语法
ds.TrimB(string (string))
返回：修剪后的字符串。
示例
如果 mylink.mystring 包含字符串 "尾随空格过多" ，那么以下函数将返回字符串 "尾随空格过多":
ds.TrimB(mylink.mystring)
TrimF
除去字符串中所有前导空格和制表符。
语法
ds.TrimF(string (string))
返回：修剪后的字符串。
示例
如果 mylink.mystring 包含字符串 " 过多前导空格 "，那么以下函数将返回字符串" 过多前导空格 ":
ds.TrimF(mylink.mystring)
TrimLeadingTrailing
除去字符串中所有前导空格、结尾空格和制表符。
语法
ds.TrimLeadingTrailing(string (string))
返回：修剪后的字符串。
示例
如果 mylink.mystring 包含字符串 " 太多空格 "，那么以下函数返回字符串" 太多空格 ":
ds.TrimLeadingTrailing(mylink.mystring)
UpCase
将字符串中的所有小写字母转换为大写字母。
语法
ds.UpCase(string (string))
返回: 生成的字符串 (全大写)。
示例
如果 "mylink.mystring1包含字符串 ""CaMel cAsE",那么下面的函数将返回字符串 "CAMELCASE"：
ds.UpCase(mylink.mystring1)
IM
返回 CHAR (255)。 工作方式与 AM 相同。
语法
ds.IM()
返回: 生成的 CHAR (255)。
示例
以下代码将返回 "维尔"。
ds.IM()
FM
返回 CHAR (254)。
语法
ds.FM()
返回: 生成的 CHAR (254)。
示例
以下代码返回 "守则"。
ds.FM()
上午
返回 CHAR (254)。 工作方式与 FM 相同。
语法
ds.AM()
返回: 生成的 CHAR (254)。
示例
以下代码返回 "守则"。
ds.AM()
虚拟机
返回 CHAR (253)。
语法
ds.VM()
返回: 生成的 CHAR (253)。
示例
以下代码返回 "ý"。
ds.VM()
SM
返回 CHAR (252)。 工作方式与 SVM 相同。
语法
ds.SM()
返回: 生成的 CHAR (252)。
示例
以下代码返回 "ü"。
ds.SM()
SVM
返回 CHAR (252)。 工作方式与 SM 相同。
语法
ds.SVM()
返回: 生成的 CHAR (252)。
示例
以下代码返回 "ü"。
ds.SVM()
TM
返回 CHAR (251)。
语法
ds.TM()
返回: 生成的 CHAR (251)。
示例
以下代码返回 "a"。
ds.TM()
实用程序函数
实用程序函数指定与检索有关特定 DataStage 函数的信息相关的各种用途。
ElementAt
返回由索引指定的列表中的元素。
语法
ds.ElementAt(list (object))
返回: 格式对象的元素索引。
示例
以下代码返回 "b":
ds.ElementAt(["a","b","c"], 1)
以下代码返回 2:
ds.ElementAt([1,2,3], 1)
GetCommandName
获取 "运行 Bash 脚本活动" 的节点标识，并检索 Run bash 脚本活动的命令名。
语法
ds.GetCommandName(tasks.activity_id (string))
返回: 格式字符串的命令名。
示例
以下代码返回任务 run_bash_script_5的命令名:
ds.GetCommandName(tasks.run_bash_script_5)
GetCommandOutput
获取 "运行 Bash 脚本活动" 的节点标识，并检索其标准输出。 它相当于 CEL 表达式:
tasks.<activity_id>.results.standard_output
语法
ds.GetCommandOutput(tasks.activity_id (string))
返回: 格式字符串的标准输出。
示例
以下代码返回任务 run_bash_script_5的标准输出:
ds.GetCommandOutput(tasks.run_bash_script_5)
GetErrorMessage
仅在异常处理程序中的任务中使用，输出是在发生异常时记录为警告的消息文本。
语法
ds.GetErrorMessage()
返回: 生成的格式字符串的消息。
示例
以下代码返回失败任务的错误消息:
ds.GetErrorMessage()
GetErrorNumber
仅在异常处理程序中的任务中使用，输出为整数，指示启动的错误类型。 1 或-11。
1 指示任务运行了已取消的作业，并且未设置任何特定处理程序。
--1表示任务因其他原因运行失败。
语法
ds.GetErrorNumber()
返回: 生成格式为 int 的整数。
示例
以下代码返回异常处理程序活动类型的错误号:
ds.GetErrorNumber()
GetErrorSource
仅在异常处理程序中的任务中使用，输出是引发异常的活动阶段的阶段名称。
语法
ds.GetErrorSource()
返回: 格式字符串的任务的结果值。
示例
以下代码返回失败的任务:
ds.GetErrorSource()
GetJobName
返回运行函数时 "运行 DataStage " 活动的作业名。 它相当于 CEL 表达式:
tasks.<activity_id>.results.job_name
语法
ds.GetJobName(tasks.activity_id (string))
返回: 格式字符串的作业名。
示例
以下代码返回任务 run_datastage_flow_1的作业名:
ds.GetJobName(tasks.run_datastage_flow_1)
GetJobNameWithInvocationId
如果作业在多个实例中运行并且作业调用标识不为空，那么返回在运行函数时带有后缀调用标识的 "运行 DataStage " 活动的作业名。
语法
ds.GetJobNameWithInvocationId(tasks.nodeId)
返回: 格式字符串的作业名，后缀为调用标识 (如果可用)。
示例
以下代码返回具有任务名称 rowGenPeekJob 和调用标识 bigloop1的 rowGenPeekJob.bigloop1 :
ds.GetJobNameWithInvocationId(tasks.rowGenPeekJob)
GetJobStatus
获取 "运行 DataStage 活动" 的节点标识，并检索其 <activity_name>.$JobStatus的作业状态。 它相当于以下包裹表达式:
((tasks.<activity_id>.results.status == 'Completed') ? 1 : ((tasks.<activity_id>.results.status == 'CompletedWithWarnings') ? 2 : ((tasks.<activity_id>.results.status == 'Cancelled') ? 96 : 3)))
语法
ds.GetJobStatus(tasks.activity_id (string))
返回: 格式为 int 的作业状态。
示例
以下代码返回任务 run_datastage_flow_1的状态:
ds.GetJobStatus(tasks.run_datastage_flow_1)
GetListCounter
仅在具有列表计数器的循环中在任务中使用，输出是计数器变量的当前值。
语法
ds.GetListCounter()
返回: 格式字符串计数器的结果值。
示例
以下代码返回循环的当前值。
ds.GetListCounter()
GetNumericCounter
仅在具有数字计数器的循环中的任务中使用，输出是循环的计数器变量的当前值。
语法
ds.GetNumericCounter()
返回: 格式为 int 的计数器的结果值。
示例
以下代码返回循环的当前值。
ds.GetNumericCounter()
GetOutputArg
从类型为字符串的 JSON 的输入返回键的指定值。
语法
ds.GetOutputArg(JSON (string), key_value (string))
返回: 属性字段的值。
示例
以下代码返回字符串值 "tom":
ds.GetOutputArg("{"name":"tom"}", "name")
GetReturnValue
获取 "运行 Bash 脚本活动" 的节点标识，并返回 "运行 Bash 脚本" 活动的值。 它相当于以下 CEL 表达式:
tasks.<activity_id>.results.return_value
语法
ds.GetReturnValue(tasks.activity_id (string))
返回: 格式为 int 的任务的结果值。
示例
以下代码返回任务 tasks.run_bash_script_5的值:
ds.GetReturnValue(tasks.run_bash_script_5)
GetUserStatus
获取 DataStage 流任务的标识，并返回序列作业中 DataStage 流任务的状态。 如果在并行作业中运行，那么该函数不起作用。 它相当于 CEL 表达式:
tasks.<activity_id>.results.user_status
语法
ds.GetUserStatus(tasks.run_datastage_id (string))
返回: 格式字符串的 DataStage 流任务标识的状态。
示例
以下代码返回任务标识 run_datastage_5的值:
ds.GetUserStatus(tasks.run_datastage_5)
LogName
返回当前用户的登录名。
语法
ds.LogName()
返回: 格式字符串的当前用户的登录名。
示例
以下代码返回当前用户的登录名。
ds.LogName()
路径
返回当前用户的路径名。
语法
ds.Path()
返回: 格式字符串的当前用户的路径名。
示例
以下代码返回当前用户的路径名。
ds.Path()
模式
返回当前用户的模式名称。
语法
ds.Schema()
返回: 格式字符串的当前用户的模式名称。
示例
以下代码返回当前用户的模式名称。
ds.Schema()
UserNo
返回当前用户的用户编号。
语法
ds.UserNo()
返回: 格式为 int 的当前用户的用户信息。
示例
以下代码返回当前用户的用户编号。
ds.UserNo()
谁
返回当前用户。
语法
ds.Who()
返回: 格式字符串的当前用户。
示例
以下代码返回当前用户。
ds.Who()
空处理函数
执行空处理的函数。
IsNull
当输入表达式求值为空值时，返回 true。
语法
ds.IsNull(input (any))
返回: 表达式是否求值为 null (格式为 Boolean) 的结果。
示例
以下代码返回 true。
ds.IsNull(null)
以下代码返回 false。
ds.IsNull(0)
IsNotNull
当输入表达式未求值为空值时，返回 true。
语法
ds.IsNotNull(input (any))
返回: 表达式是否求值为 null (格式为 Boolean) 的结果。
示例
以下代码返回 false。
ds.IsNotNull(null)
以下代码返回 true。
ds.IsNotNull(0)
Null
返回空值。
语法
ds.Null()
返回: 空值。
示例
以下代码返回 null。
ds.Null()
NullToEmpty
如果输入为空，那么返回空字符串，否则返回输入列值。
语法
ds.NullToEmpty(input (any))
返回: 空字符串或输入值。
示例
以下代码返回 "AA"。
ds.NullToEmpty("AA")
以下代码返回 ""。
ds.NullToEmpty(null)
NullStr
返回空字符串 CHAR (128)。
语法
ds.NullStr()
返回: 空字符串 CHAR (128)。
示例
以下代码返回 €。
ds.NullStr()
NullToValue
如果输入为空，那么返回指定的值，否则返回输入列值。
语法
ds.NullToValue(input (any), default (any))
返回: 指定的值或输入值。
示例
以下代码返回 "test"。
ds.NullToValue("test", "default")
以下代码返回 "default"。
ds.NullToValue(null, "default")
以下代码返回 1。
ds.NullToValue(null, 1)
NullToZero
如果输入为空，那么返回 0 ，否则返回输入列值。
语法
ds.NullToZero(input (any))
返回: 0 或输入值。
示例
以下代码返回 88。
ds.NullToZero(88)
以下代码返回 0。
ds.NullToZero(null)
SetNull
将 Null 值赋给目标列。
语法
ds.SetNull()
返回: 将目标设置为空值。
示例
以下代码返回 null。
ds.SetNull()
宏函数
用于处理与 DataStage 序列作业相关的一组项目元数据的检索的函数。
JobName
返回顺序器作业名。
语法
ds.JobName
返回: 格式字符串的排序器作业名。
示例
以下代码返回定序器作业名。
ds.JobName
JobStartDate
返回定序器作业开始日期。
语法
ds.JobStartDate
返回: 格式字符串的排序器作业开始日期。
示例
以下代码返回定序器作业开始日期。
ds.JobStartDate
JobStartTime
返回定序器作业开始时间。
语法
ds.JobStartTime
返回: 格式字符串的定序器作业开始时间。
示例
以下代码返回定序器作业开始时间。
ds.JobStartTime
JobStartTimestamp
返回排序器作业开始时间戳记。
语法
ds.JobStartTimestamp
返回: 格式时间戳记的排序器作业开始时间戳记。
示例
以下代码返回定序器作业开始时间戳记。
ds.JobStartTimestamp
HostName
返回 DataStage 服务器的主机名。
语法
ds.HostName
返回: 格式字符串的排序器作业 InvocationId 。
示例
以下代码返回定序器作业 InvocationId。
ds.HostName
ProjectName
返回正在运行的定序器作业的项目名称
语法
ds.ProjectName
返回: 正在运行的定序器作业的项目名称。
示例
以下代码返回正在运行的定序器作业的项目名称。
ds.ProjectName
ProjectId
返回正在运行的定序器作业的项目标识。
语法
ds.ProjectId
返回: 正在运行的定序器作业的项目标识。
示例
以下代码返回正在运行的定序器作业的项目标识。
ds.ProjectId
JobId
返回正在运行的定序器作业的作业标识。
语法
ds.JobId
返回: 正在运行的定序器作业的作业标识。
示例
以下命令返回正在运行的定序器作业的作业标识。
ds.JobId
JobController
返回正在运行的定序器作业的管道流名称。
语法
ds.JobController
返回: 正在运行的定序器作业的管道流名称。
示例
以下命令返回正在运行的定序器作业的管道流名称。
ds.JobController
父主题: 向管道添加条件