#### 基础函数
##### 内容
- 数字
- 日期时间
- 字符串
- 数组
##### 数字
###### 内容
- FloatN
- FloatToStrEx
- FormatFloatExt
- WebZero
- RoundTo5
- SimpleRoundTo2
- DivValue
- Dataisequal
###### FloatN
用途：将浮点数按指定小数位数四舍五入。
参数：value 为输入数值；digits 为保留的小数位数。
返回：数值。
范例
```tsl
return FloatN(12.6578, 2);
// 结果：12.66
```
###### FloatToStrEx
用途：将浮点数格式化为字符串，保留指定小数位数。
参数：value 为输入数值；digits 为保留的小数位数。
返回：字符串。
范例
```tsl
return FloatToStrEx(12.6578, 2);
// 结果：’ 12.66’
```
###### FormatFloatExt
用途：按扩展格式输出数值字符串，支持千分位与空值处理。
参数：value 为输入数值；format 为格式参数（可选）。
返回：字符串。
范例
```tsl
return FormatFloatExt(12345.67, 1);
// 结果：’ 12,345.67’
return FormatFloatExt("123");
// 结果：’ -’
```
###### WebZero
用途：当数值为 0 时返回空字符串，否则返回数值字符串。
参数：value 为输入数值。
返回：字符串。
范例
```tsl
return WebZero(0);
// 结果：’’ // 空字串
```
###### RoundTo5
用途：将数值按 0.5 的步长进行四舍五入。
参数：value 为输入数值。
返回：数值。
范例
```tsl
return RoundTo5(0.35);
// 结果：0.5
```
###### SimpleRoundTo2
用途：按指定小数位数进行四舍五入（对负数同样生效）。
参数：value 为输入数值；digits 为保留的小数位数。
返回：数值。
范例
范例01：
```tsl
return SimpleRoundTo2(1234.56789654, -2);
// 结果：1234.57
```
范例02：
```tsl
return SimpleRoundTo2(-1234.5658965, -2);
// 结果：-1234.56
```
###### DivValue
用途：当除数不为 0 时返回 v1 / v2，否则返回 0。
参数：v1 为被除数；v2 为除数。
返回：数值。
算法如果v2不为0，则返回v1/v2，否则返回0。范例
```tsl
return DivValue(8, 2);
// 返回：4
```
###### Dataisequal
用途：判断两个数据是否相等。
参数：a 与 b 为待比较的数据。
返回：布尔值。
##### 日期时间
###### 内容
- ISO8601
- GMT时间
- 常用日期时间函数
- 简单转换函数
- 普通日期函数
- 分解函数
- 起始结束函数
- 关系函数
- 范围判定函数
- 范围获得函数
- 范围生成函数
- 时间推移函数
- 组合、分解日期函数
- 日期重组函数
- 日期格式的转换
- 宽字节日期格式转换函数
###### ISO8601
标有ISO8601标准的函数的含义包括以下几点：
1、对于某一周属于某年（或某月）的认定标准是是否有四天以上属于某年（或某月）。例如，对于某年第一周的认定是此年的第一个星期四所在的周。这保证了这个周至少有4天在这个年份中。
这同时意味着一年总的周数必然是52或53。
2、一周的开始是星期一，结束是星期天。分别用1到7的数字表示。
###### GMT时间
GMT时间就是英国格林威治时间，也就是世界标准时间，是本初子午线上的地方时，是0时区的区时，与我国的标准时间北京时间（东八区）相差8小时，即晚8小时。
当GMT时间为00:00:00时，北京时间为8:00:00。
###### 常用日期时间函数
####### 内容
- Time
- DecodeTime
- DayOfWeek
- EncodeTime
- Now
- DecodeDate
- Date
- TryEncodeDate
- TryEncodeTime
- DecodeDateFully
- EncodeDate
- TryStrToDate
- StrToDateTimeDef
- DateTimeToInternetStr
- IncAMonth
- StrToTime
- CurrentYear
- TryStrToTime
- StrToDate
- DateTimeGMTToHttpStr
- DateToStr
- StrToTimeDef
- DateTimeToStr
- DateTimeToString
- Strtodatetime2
- FormatDateTime
- DateTimeGMTToCookieStr
- StrToDateTime
- IsLeapYear
- GMTToLocalDateTime
- TimeToStr
- StrToDateDef
- TryStrToDateTime
####### Time
用途：日期时间处理函数。
参数：无。
返回：日期或时间值。
范例
```tsl
return Time(); // 输出0.59
```
参考TDateTime
####### DecodeTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
DecodeTime(strtoTime("13:33:45.500"), hour, min, sec, msec);
return array(hour, min, sec, msec);
// 返回 array(13,33,45,500)
```
参考TDateTime EncodeDate EncodeTime TryEncodeDate TryEncodeTime DecodeDateFully
DecodeDate
####### DayOfWeek
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
dow := DayOfWeek(EncodeDate(2011, 8, 8));
return dow; // 输出：2
```
参考TDateTime
####### EncodeTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
Time1 := EncodeTime(12, 35, 35, 100);
return time1; // 输出：0.52471(12:35:35.1)
```
参考TDateTime EncodeDate TryEncodeDate TryEncodeTime DecodeTime DecodeDate
DecodeDateFully
####### Now
用途：日期时间相关函数。
参数：无。
返回：处理后的结果值。
范例
```tsl
return Now(); // 输出40763.59
```
参考TDateTime
####### DecodeDate
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
DecodeDate(inttodate(20140115), year, month, day);
return array(year, month, day );
// 输出array(2014,1,15)
```
参考TDateTime EncodeDate DecodeTime DecodeDateFully EncodeTime TryEncodeDate
TryEncodeTime
####### Date
用途：日期时间处理函数。
参数：无。
返回：日期或时间值。
范例
```tsl
// 当前的日期
return Date(); // 输出41656
```
参考TDateTime
####### TryEncodeDate
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
if TryEncodeDate(2011, 12, 25, date) then return date; // 输出：40902
else return "encode error";
// 输出 encode error
if TryEncodeDate(2011, 12, 32, date) then return date
else return "encode error";
// 输出 encode error
```
参考TDateTime EncodeDate TryEncodeTime DecodeTime DecodeDate DecodeDateFully
EncodeTime
####### TryEncodeTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
if TryEncodeTime(12, 20, 30, 200, time) then return time//输出:0.51
else return "eccode error ";
```
参考TDateTime EncodeDate DecodeTime DecodeDate DecodeDateFully EncodeTime
TryEncodeDate
####### DecodeDateFully
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
Flag := DecodeDateFully(inttodate(20140115), year, month, day, dow);
fname := ifthen(1, '闰年', '平年');
return array(year, month, day, dow, fname);
// 返回：array(2014,1,15,4,'闰年')
```
参考TDateTime EncodeDate DecodeTime EncodeTime TryEncodeDate TryEncodeTime
DecodeDate
####### EncodeDate
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
date := EncodeDate(2011, 8, 6);
return date; // 输出：40761
```
参考TDateTime EncodeTime TryEncodeDate TryEncodeTime DecodeDate DecodeDateFully
DecodeTime
####### TryStrToDate
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
if TryStrToDate("2010-02-04 ", date) then return date; // 输出40213
```
参考TDateTime SetFormatLocalCode GetFormatLocalCode
####### StrToDateTimeDef
用途：将字符串转换为对应类型。
参数：
返回：转换后的数值或日期。
范例
```tsl
return StrToDateTimeDef("2011-08-08 16:61:16 ", now()); // 输出当前系统日期时间
```
参考TDateTime SetFormatLocalCode GetFormatLocalCode
####### DateTimeToInternetStr
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
EndT := strtodatetime('2014-01-01 10:00:00');
datetime := DateTimeToInternetStr(EndT, 0);
return datetime; // 输出Wed, 1 Jan 2014 10:00:00 +0800
```
####### IncAMonth
范例
```tsl
year := 2011;
month := 8;
day := 8;
IncAmonth(year, month, day, 4);
return EncodeDate(year, month, day); // 输出40885
```
####### StrToTime
用途：将字符串转换为对应类型。
参数：
返回：转换后的数值或日期。
范例
```tsl
return StrToTime("15:20:34"); // 输出0.64
```
参考TDateTime SetFormatLocalCode GetFormatLocalCode
####### CurrentYear
用途：日期时间相关函数。
参数：无。
返回：处理后的结果值。
范例
```tsl
return CurrentYear(); // 输出2011
```
####### TryStrToTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
if TryStrToTime("15:52:35", time) then return time; // 输出0.66
```
参考TDateTime SetFormatLocalCode GetFormatLocalCode
####### StrToDate
用途：将字符串转换为对应类型。
参数：
返回：转换后的数值或日期。
范例
```tsl
return StrToDate("2010-02-04"); // 输出40213
```
参考TDateTime SetFormatLocalCode GetFormatLocalCode
####### DateTimeGMTToHttpStr
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
EndT := strtodatetime('2014-01-01 10:00:00');
datetime := DateTimeGMTToHttpStr(EndT);
return datetime; // 输出：Wed, 01 Jan 2014 10:00:00 GMT
```
####### DateToStr
用途：将输入值转换为字符串。
参数：
返回：字符串。
范例
```tsl
EndT := inttodate(20140117);
return DateToStr(EndT); // 输出 2014-01-17
```
参考TDateTime SetFormatLocalCode GetFormatLocalCode
####### StrToTimeDef
用途：将字符串转换为对应类型。
参数：
返回：转换后的数值或日期。
范例
```tsl
time := StrToTimeDef("15:61:34 ", time());
return time; // 输出当前系统时间
```
参考TDateTime SetFormatLocalCode GetFormatLocalCode
####### DateTimeToStr
用途：将输入值转换为字符串。
参数：
返回：字符串。
范例
```tsl
EndT := now();
return DateTimeToStr(EndT); // 输出当前系统日期时间
```
参考TDateTime SetFormatLocalCode GetFormatLocalCode
####### DateTimeToString
用途：将输入值转换为字符串。
参数：
返回：字符串。
范例
```tsl
DateTimeToString(result, 'YYYY-MM-DD HH:NN:SS', now());
return result; // 输出当期系统日期时间
```
参考TDateTime SetFormatLocalCode GetFormatLocalCode
差异说明在不同操作系统中，返回的日期格式会有所差异，差异同FormaTDateTime，FAQ：FormatDateTime
####### Strtodatetime2
范例
```tsl
// 字符串2021-8-12 10:31:24:199 转换为日期时间格式(包含毫秒)
s := "2021-8-12 10:31:24:199"
return StrToDateTime2(s); // 结果：44420.4384745255
```
####### FormatDateTime
用途：按指定格式输出结果。
参数：
返回：日期或时间值。
范例
```tsl
return FormatDateTime("C", now()); // 输出2011-08-08 16:27:08
return FormatDateTime("Dddddd", now()); // 输出2011年8月8日
```
参考SetFormatLocalCode GetFormatLocalCode
差异说明其转换结果依赖运行环境的操作系统的日期时间格式，如表示星期时，有些操作系统上表示方式为“周五”，而有些操作系统上表示为“五”。
####### DateTimeGMTToCookieStr
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
EndT := strtodatetime('2014-01-01 10:00:00');
datetime := DateTimeGMTToCookieStr(EndT);
return datetime; // 输出Wed, 01-Jan-2014 10:00:00 GMT
```
####### StrToDateTime
用途：将字符串转换为对应类型。
参数：
返回：转换后的数值或日期。
范例
```tsl
return StrToDateTime("2011-08-08 16:00:16 "); // 输出40763.67
```
参考TDateTime SetFormatLocalCode GetFormatLocalCode
####### IsLeapYear
用途：判断条件是否成立。
参数：
返回：布尔值。
范例
```tsl
return IsLeapYear(2000); // 输出1
return IsLeapYear(2011); // 输出0
```
参考IsInLeapYear
####### GMTToLocalDateTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
GMT := "Wed, 01 Jan 2014 10:00:00 GMT ";
datetime := GMTToLocalDateTime(GMT);
return datetime; // 输出：41640.75 （时间为2014-01-01 18:00:00）
```
####### TimeToStr
范例
```tsl
// 输入时间或者日期时间
return timeToStr(0.5);
return timetostr(now());
```
参考TDateTime SetFormatLocalCode GetFormatLocalCode
####### StrToDateDef
用途：将字符串转换为对应类型。
参数：
返回：转换后的数值或日期。
范例
```tsl
return StrToDateDef("2010-02-30", date()); // 转换失败输出当前日期40763
```
参考TDateTime SetFormatLocalCode GetFormatLocalCode
####### TryStrToDateTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
if TryStrToDateTime("2010-02-04 16:11:35 ", datetime) then return datetime; // 输出40213.67
```
参考TDateTime SetFormatLocalCode GetFormatLocalCode
###### 简单转换函数
####### 内容
- DateToInt
- IntToDate
- StrToDateExt
- ExcelIntToDate
- ExcelDateToInt
- FormatStrToDateTime2
####### DateToInt
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
DateTime := 40559;
return DateToInt(DateTime);
// 结果：20110116
```
####### IntToDate
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
Rdate := 20110116;
return IntToDate(Rdate);
// 结果: 40559
```
####### StrToDateExt
用途：将字符串转换为对应类型。
参数：
返回：转换后的数值或日期。
范例
```tsl
S := '16/1/2011';
StrFormat := 0;
return StrToDateExt(S, StrFormat);
// 结果：40559
```
####### ExcelIntToDate
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
// 报告期为2010年年报
RDate := 20101231;
return ExcelIntToDate(RDate);
// 结果：40543
```
####### ExcelDateToInt
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
RDate := 20101231;
return ExcelDateToInt(RDate);
// 结果：20101231
```
####### FormatStrToDateTime2
用途：按指定格式输出结果。
参数：
返回：日期或时间值。
范例
```tsl
// 字符串2021-8-12 10:31:24:199 转换为日期时间格式(包含毫秒)
s := "2021.01.04T23:00:00.000";
FormatStr := "yyyy.mm.ddThh:nn:ss.zzz";
return FormatStrToDateTime2(S, FormatStr); // 结果：44200.9583333333
```
###### 普通日期函数
####### 内容
- IsInLeapYear
- IsPM
- IsValidDate
- IsValidTime
- IsValidDateTime
- IsValidDateDay
- IsValidDateWeek
- IsValidDateMonthWeek
- WeeksInYear
- WeeksInAYear
- DaysInYear
- DaysInAYear
- DaysInMonth
- DaysInAMonth
- Today
- Yesterday
- Tomorrow
- IsToday
- IsSameDay
####### IsInLeapYear
用途：判断条件是否成立。
参数：
返回：布尔值。
范例
```tsl
if IsInLeapYear(date) then return "this year is a leap year "
else return "this year is not a leap year ";
```
参考TDateTime IsLeapYear
####### IsPM
用途：判断条件是否成立。
参数：
返回：布尔值。
范例
```tsl
if IsPM(Time()) then return "is PM "
else return "is AM ";
```
参考TDateTime
####### IsValidDate
用途：判断条件是否成立。
参数：
返回：布尔值。
范例
```tsl
if IsValidDate(2011, 8, 34) then return "right "
else return "wrong ";
// 输出 wrong
```
参考IsValidTime IsValidDateTime IsValidDateDay IsValidDateWeek
IsValidDateMonthWeek
####### IsValidTime
用途：判断条件是否成立。
参数：
返回：布尔值。
范例
```tsl
if IsValidTime(17, 48, 45, 678) then return "right time "
else return "wrong time "; // 输出 right time
```
参考IsValidDate IsValidDateTime IsValidDateDay IsValidDateWeek
IsValidDateMonthWeek
####### IsValidDateTime
用途：判断条件是否成立。
参数：
返回：布尔值。
范例
```tsl
if IsValidDateTime(2011, 8, 8, 17, 57, 56, 245) then return "right "
else return "wrong ";
// 输出 right
```
参考IsValidDate IsValidTime IsValidDateDay IsValidDateWeek IsValidDateMonthWeek
####### IsValidDateDay
用途：判断条件是否成立。
参数：
返回：布尔值。
范例
```tsl
if IsValidDateDay(2010, 345) then return "valid "
else return "not valid ";
// 输出 valid
```
参考IsValidDate IsValidTime IsValidDateTime IsValidDateWeek IsValidDateMonthWeek
####### IsValidDateWeek
用途：判断条件是否成立。
参数：
返回：布尔值。
范例
```tsl
if IsValidDateWeek (2010, 15, 4) then return "valid "
else return "not valid ";
// 输出 valid
```
参考IsValidDate IsValidTime IsValidDateTime IsValidDateDay IsValidDateMonthWeek
####### IsValidDateMonthWeek
用途：判断条件是否成立。
参数：
返回：布尔值。
范例
```tsl
if IsValidDateMonthWeek(2000, 10, 2, 3) then return "valid "
else return "not valid ";
```
输出 valid参考IsValidDate IsValidTime IsValidDateTime IsValidDateDay
IsValidDateWeek
####### WeeksInYear
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
num := WeeksInYear (Date());
return num; // 输出52
```
参考TDateTime WeeksInAYear DaysInYear DaysInAYear DaysInMonth DaysInAMonth
####### WeeksInAYear
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
num := WeeksInAYear (2010);
return num; // 输出52
```
参考WeeksInYear DaysInYear DaysInAYear DaysInMonth DaysInAMonth
####### DaysInYear
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
days := DaysInYear (Date());
return days; // 输出365
```
参考TDateTime WeeksInYear WeeksInAYear DaysInAYear DaysInMonth DaysInAMonth
####### DaysInAYear
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
days := DaysInAYear (2010);
return days; // 输出365
```
参考WeeksInYear WeeksInAYear DaysInYear DaysInMonth DaysInAMonth
####### DaysInMonth
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
days := DaysInMonth (inttodate(20131201));
return days; // 输出31
```
参考TDateTime WeeksInYear WeeksInAYear DaysInYear DaysInAYear DaysInAMonth
####### DaysInAMonth
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
days := DaysInAMonth (2010, 2);
return days; // 输出28
```
参考WeeksInYear WeeksInAYear DaysInYear DaysInAYear DaysInMonth
####### Today
用途：日期时间相关函数。
参数：无。
返回：处理后的结果值。
范例
```tsl
datetime := Today();
return DateToStr(datetime); // 输出2011-08-08
```
参考TDateTime Yesterday Tomorrow
####### Yesterday
用途：日期时间相关函数。
参数：无。
返回：处理后的结果值。
范例
```tsl
Datetime := Yesterday();
return DateToStr(datetime); // 输出2011-08-07
```
参考TDateTime Today Tomorrow
####### Tomorrow
用途：日期时间相关函数。
参数：无。
返回：处理后的结果值。
范例
```tsl
Datetime := Tomorrow();
return DateToStr(datetime); // 输出2011-08-09
```
参考TDateTime Today Yesterday
####### IsToday
用途：判断条件是否成立。
参数：
返回：布尔值。
范例
```tsl
Today := today();
Aday := today + 2;
if istoday(aday) then return "aday is today "
else return "aday is not today "; // 输出aday is not today
```
参考TDateTime
####### IsSameDay
用途：判断条件是否成立。
参数：
返回：布尔值。
范例
```tsl
Today := today();
Aday := today + 2;
if isSameDay(aday, today) then return "sameday "
else return " not sam day"; // 输出:not sameday
```
参考TDateTime
###### 分解函数
####### 内容
- DateOf
- TimeOf
- YearOf
- MonthOf
- DayOf
- HourOf
- MinuteOf
- SecondOf
- MilliSecondOf
####### DateOf
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
return DateOf(now()); // 返回今天的日期
```
参考TDateTime TimeOf DecodeDate
####### TimeOf
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
return TimeOf (now()); // 返回当前所处的时间点
// 截取某个日期时间的时间点
EndT := strtodatetime("2014-01-17 10:00:00");
return TimeOf(EndT); // 返回0.4167
```
参考TDateTime DecodeTime DateOf
####### YearOf
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
year := Yearof(strToDate('2010-08-08'));
return year;
// 输出: 2010
```
参考TDateTime DecodeDate MonthOf DayOf HourOf MinuteOf SecondOf MilliSecondOf
####### MonthOf
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
month := Monthof(strToDate('2010-08-08'));
return month; // 输出: 8
```
参考TDateTime DecodeDate YearOf DayOf HourOf MinuteOf SecondOf MilliSecondOf
####### DayOf
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
hour := dayof(strtodatetime('2011-08-08 11:22:06'));
return hour; // 输出: 8
```
参考TDateTime DecodeDate YearOf MonthOf HourOf MinuteOf SecondOf MilliSecondOf
####### HourOf
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
hour := hourof(strtodatetime('2011-08-08 11:22:06'));
return hour; // 输出: 11
```
参考TDateTime DecodeDate YearOf MonthOf DayOf MinuteOf SecondOf MilliSecondOf
####### MinuteOf
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
minute := minuteof(strtodatetime('2011-08-08 11:22:06'));
return minute; // 输出: 22
```
参考TDateTime DecodeDate YearOf MonthOf DayOf HourOf SecondOf MilliSecondOf
####### SecondOf
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
second := secondof(strtodatetime('2011-08-08 11:22:06'));
return second; // 输出: 6
```
参考TDateTime DecodeDate YearOf MonthOf DayOf HourOf MinuteOf MilliSecondOf
####### MilliSecondOf
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
millisecond := Millisecondof(StrToDateTime('2011-08-08 11:22:06.990'));
return millisecond; // 输出: 990
```
参考TDateTime DecodeDate YearOf MonthOf DayOf HourOf MinuteOf SecondOf
###### 起始结束函数
####### 内容
- StartOfTheYear
- EndOfTheYear
- StartOfAYear
- EndOfAYear
- StartOfTheMonth
- EndOfTheMonth
- StartOfAMonth
- EndOfAMonth
- StartOfTheWeek
- EndOfTheWeek
- StartOfAWeek
- EndOfAWeek
- StartOfTheDay
- EndOfTheDay
- StartOfADay
- EndOfADay
- StartOfTheHalfYear
- StartOfTheQuarter
- EndOfTheQuarter
- EndOfTheHalfYear
####### StartOfTheYear
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
dTime := StartOfTheYear(StrToDateTime('2011-08-08 11:22:06.990'));
return dateTimeToStr(dTime); // 输出: 2011-01-01
```
参考TDateTime EndOfTheYear StartOfAYear EndOfAYear StartOfTheMonth EndOfTheMonth
StartOfAMonth EndOfAMonth StartOfTheWeek EndOfTheWeek StartOfAWeek EndOfAWeek
StartOfTheDay EndOfTheDay StartOfADay EndOfADay
####### EndOfTheYear
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
year := EndOfTheYear(StrToDateTime('2011-08-08 11:22:06.990'));
return dateTimeToStr(year); // 输出: 2011-12-31 23:59:59
```
参考TDateTime StartOfTheYear StartOfAYear EndOfAYear StartOfTheMonth
EndOfTheMonth StartOfAMonth EndOfAMonth StartOfTheWeek EndOfTheWeek StartOfAWeek
EndOfAWeek StartOfTheDay EndOfTheDay StartOfADay EndOfADay
####### StartOfAYear
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
year := StartOfAYear(2011);
return datetimetostr(year); // 输出: 2011-01-01
```
参考TDateTime StartOfTheYear EndOfTheYear EndOfAYear StartOfTheMonth
EndOfTheMonth StartOfAMonth EndOfAMonth StartOfTheWeek EndOfTheWeek StartOfAWeek
EndOfAWeek StartOfTheDay EndOfTheDay StartOfADay EndOfADay
####### EndOfAYear
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
year := EndOfAYear(2011);
return datetimetostr(year); // 输出: 2011-12-31 23:59:59
```
参考TDateTime StartOfTheYear EndOfTheYear StartOfAYear StartOfTheMonth
EndOfTheMonth StartOfAMonth EndOfAMonth StartOfTheWeek EndOfTheWeek StartOfAWeek
EndOfAWeek StartOfTheDay EndOfTheDay StartOfADay EndOfADay
####### StartOfTheMonth
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
year := StartOfTheMonth(strtodatetime('2011-08-08 12:48:22.990'));
return datetimetostr(year); // 输出: 2011-08-01
```
参考TDateTime StartOfTheYear EndOfTheYear StartOfAYear EndOfAYear EndOfTheMonth
StartOfAMonth EndOfAMonth StartOfTheWeek EndOfTheWeek StartOfAWeek EndOfAWeek
StartOfTheDay EndOfTheDay StartOfADay EndOfADay
####### EndOfTheMonth
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
year := EndOfTheMonth(strtodatetime('2011-08-08 12:48:22.990'));
return DatetimeToStr(year); // 输出: 2011-08-31 23:59:59
```
参考TDateTime StartOfTheYear EndOfTheYear StartOfAYear EndOfAYear
StartOfTheMonth StartOfAMonth EndOfAMonth StartOfTheWeek EndOfTheWeek
StartOfAWeek EndOfAWeek StartOfTheDay EndOfTheDay StartOfADay EndOfADay
####### StartOfAMonth
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
tdate := StartOfAMonth(2011, 08);
return dateTimeToStr(tdate); // 输出: 2011-08-01
```
参考TDateTime
####### EndOfAMonth
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
Ttime := EndOfAMonth(2011, 08);
return datetimetostr(Ttime); // 输出: 2011-08-31 23:59:59
```
参考TDateTime StartOfTheYear EndOfTheYear StartOfAYear EndOfAYear
StartOfTheMonth EndOfTheMonth StartOfAMonth StartOfTheWeek EndOfTheWeek
StartOfAWeek EndOfAWeek StartOfTheDay EndOfTheDay StartOfADay EndOfADay
####### StartOfTheWeek
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
year := StartOfTheWeek(strtodatetime('2011-08-07'));
return datetimetostr(year); // 输出: 2011-08-01
// 其中2011-08-07是星期天，2011-08-01是星期一
```
参考TDateTime StartOfTheYear EndOfTheYear StartOfAYear EndOfAYear
StartOfTheMonth EndOfTheMonth StartOfAMonth EndOfAMonth EndOfTheWeek
StartOfAWeek EndOfAWeek StartOfTheDay EndOfTheDay StartOfADay EndOfADay
####### EndOfTheWeek
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
year := EndOfTheWeek(strtodatetime('2011-08-01'));
return datetimetostr(year); // 输出: 2011-08-07 23:59:59
// 其中2011-08-01是星期一，输出结果2011-08-07是星期天
```
参考TDateTime StartOfTheYear EndOfTheYear StartOfAYear EndOfAYear
StartOfTheMonth StartOfAMonth EndOfAMonth StartOfTheWeek EndOfTheWeek
StartOfAWeek EndOfAWeek StartOfTheDay EndOfTheDay StartOfADay EndOfADay
####### StartOfAWeek
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
范例一：
```tsl
// 取当年的第一个完整周
year := StartOfAWeek(2011, 1, 1);
return datetimetostr(year); // 输出: 2011-01-03
```
范例二：
```tsl
year := StartOfAWeek(2011, 2, 1);
return datetimetostr(year); // 输出：2011-01-10
```
参考TDateTime StartOfTheYear EndOfTheYear StartOfAYear EndOfAYear
StartOfTheMonth EndOfTheMonth EndOfAMonth StartOfTheWeek EndOfTheWeek
StartOfAWeek EndOfAWeek StartOfTheDay EndOfTheDay StartOfADay EndOfADay
####### EndOfAWeek
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
范例一：
```tsl
year := EndOfAWeek(2011, 1, 7);
return datetimetostr(year); // 输出: 2011-01-09 23:59:59
```
范例二：
```tsl
year := EndOfAWeek (2011, 2, 7);
return datetimetostr(year); // 输出：2011-01-16 23:59:59
```
参考TDateTime StartOfTheYear EndOfTheYear StartOfAYear EndOfAYear
StartOfTheMonth EndOfTheMonth StartOfAMonth EndOfAMonth StartOfTheWeek
EndOfTheWeek StartOfAWeek StartOfTheDay EndOfTheDay StartOfADay EndOfADay
####### StartOfTheDay
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
year := StartOfTheDay(strtodatetime('2011-08-08 23:59:59'));
return datetimetostr(year); // 输出: 2011-08-08
```
参考TDateTime StartOfTheYear EndOfTheYear StartOfAYear EndOfAYear
StartOfTheMonth EndOfTheMonth StartOfAMonth EndOfAMonth StartOfTheWeek
EndOfTheWeek StartOfAWeek EndOfAWeek EndOfTheDay StartOfADay EndOfADay
####### EndOfTheDay
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
year := EndOfTheDay(strtodatetime('2011-08-08 01:01:10'));
return datetimetostr(year); // 输出: 2011-08-08 23:59:59
```
参考TDateTime StartOfTheYear EndOfTheYear StartOfAYear EndOfAYear
StartOfTheMonth EndOfTheMonth StartOfAMonth EndOfAMonth StartOfTheWeek
EndOfTheWeek StartOfAWeek EndOfAWeek StartOfTheDay StartOfADay EndOfADay
####### StartOfADay
范例
```tsl
year := StartofADay(2011, 8, 8);
return datetimetostr(year); // 输出: 2011-08-08
```
参考TDateTime StartOfTheYear EndOfTheYear StartOfAYear EndOfAYear
StartOfTheMonth EndOfTheMonth StartOfAMonth EndOfAMonth StartOfTheWeek
EndOfTheWeek StartOfAWeek EndOfAWeek StartOfTheDay EndOfTheDay EndOfADay
####### EndOfADay
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
year := EndOfADay(2015, 1, 5);
return datetimetostr(year); // 输出: 2015-01-05 23:59:59
```
参考TDateTime StartOfTheYear EndOfTheYear StartOfAYear EndOfAYear
StartOfTheMonth EndOfTheMonth StartOfAMonth EndOfAMonth StartOfTheWeek
EndOfTheWeek StartOfAWeek EndOfAWeek StartOfTheDay EndOfTheDay StartOfADay
####### StartOfTheHalfYear
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
EndT := 40599; // 40559表示2011年1月16号
return StartOfTheHalfYear(EndT);
// 结果：40544 //40544表示2011年1月1号
```
####### StartOfTheQuarter
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
EndT := 40540; // 40540表示2010年12月28日
return StartOfTheQuarter (EndT);
// 结果：40452 //40452表示2010年10月1号
```
####### EndOfTheQuarter
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
EndT := 40540; // 40540表示2010年12月28日
return EndOfTheQuarter (EndT);
// 结果：40543 //40543表示2010年12月31号
```
####### EndOfTheHalfYear
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
EndT := 40540; // 40540表示2010年12月28日
return EndOfTheHalfYear (EndT);
// 结果：40543 //40543表示2010年12月31号
```
###### 关系函数
####### 内容
- HourOfTheYear
- HourOfTheMonth
- MonthOfTheYear
- MilliSecondOfTheYear
- WeekOfTheYear
- WeekOfTheMonth
- MinuteOfTheYear
- SecondOfTheYear
- DayOfTheYear
- DayOfTheMonth
- SecondOfTheMinute
- HourOfTheWeek
- SecondOfTheMonth
- DayOfTheWeek
- MinuteOfTheDay
- MilliSecondOfTheSecond
- SecondOfTheWeek
- MinuteOfTheMonth
- MinuteOfTheHour
- MinuteOfTheWeek
- MilliSecondOfTheDay
- MilliSecondOfTheMonth
- HourOfTheDay
- MilliSecondOfTheHour
- SecondOfTheHour
- MilliSecondofTheMinute
- SecondOfTheDay
- MilliSecondOfTheWeek
####### HourOfTheYear
范例
```tsl
hour := HourOfTheYear(strtodatetime('2011-01-03 10:00:00'));
return hour; // 输出: 58
```
参考TDateTime HourOf MonthOfTheYear WeekOfTheYear DayOfTheYear MinuteOfTheYear
SecondOfTheYear MilliSecondOfTheYear
####### HourOfTheMonth
范例
```tsl
hour := HourOfTheMonth(strtodatetime('2011-01-22 10:00:00'));
return hour; // 输出: 514
```
参考TDateTime HourOf WeekOfTheMonth DayOfTheMonth MinuteOfTheMonth
SecondOfTheMonth MilliSecondOfTheMonth
####### MonthOfTheYear
范例
```tsl
month := MonthOfTheYear(strtodate('2011-08-08'));
return month; // 输出: 8
```
参考TDateTime MonthOf WeekOfTheYear DayOfTheYear HourOfTheYear MinuteOfTheYear
SecondOfTheYear MilliSecondOfTheYear
####### MilliSecondOfTheYear
范例
```tsl
millisecond := MilliSecondOfTheYear(strtodatetime('2011-01-03'));
return millisecond; // 输出: 172800000
```
参考TDateTime MilliSecondOf MonthOfTheYear WeekOfTheYear DayOfTheYear
HourOfTheYear MinuteOfTheYear SecondOfTheYear
####### WeekOfTheYear
范例
```tsl
week := WeekOfTheYear(strtodate('2011-01-03'));
return week; // 输出: 1
```
参考TDateTime MonthOfTheYear DayOfTheYear HourOfTheYear MinuteOfTheYear
SecondOfTheYear MilliSecondOfTheYear
####### WeekOfTheMonth
定义1：WeekOfTheMonth(AValue: TDateTime): Integer;
说明：返回由参数AValue指定的时间是处于当月的第几个周。
注意：使用了ISO8601标准，这意味着可能指定的时间所处的周不属于当前月份，那么返回的将是相对与其他月份的周数。如果当月1号是周四及周四之前，则本周会纳入本月，即本周是本月的第一周，如果当月1号是周四之后，比如是周五，则还属于上月的周期内，即为上月的最后一周。
参数：
- AValue：TDateTime类型，日期时间
- AYear：整数，年，返回值
- AMonth：整数，月，返回值
返回：整数，值域是[1，6]
范例：
```tsl
month := weekOfTheMonth(strtodatetime('2011-01-22'));
return month; // 输出: 3
```
定义2：WeekOfTheMonth(AValue: TDateTime; var AYear, AMonth: Integer): Integer;
说明：返回由参数AValue指定的时间是处于当月的第几个周。
注意：使用了ISO8601标准，这意味着可能指定的时间所处的周不属于当前月份，那么返回的将是相对与其他月份的周数，通过参数Ayear，Amonth将所属的年份和月份返回
参数：
- AValue：TDateTime类型，日期时间
- AYear：整数，年，返回值
- AMonth：整数，月，返回值
返回：整数，值域是[1，6]
范例：
```tsl
week := WeekOfTheMonth(strtodatetime('2011-01-22'), 2011, 1);
return week; // 输出: 3
```
参考：TDateTime，DayOfTheMonth，HourOfTheMonth，MinuteOfTheMonth，SecondOfTheMonth，MilliSecondOfTheMonth
####### MinuteOfTheYear
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
minute := MinuteOfTheYear(strtodatetime('2011-01-03 10:00:00'));
return minute; // 输出: 3480
```
参考TDateTime MinuteOf MonthOfTheYear WeekOfTheYear DayOfTheYear HourOfTheYear
SecondOfTheYear MilliSecondOfTheYear
####### SecondOfTheYear
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
second := SecondOfTheYear(strtodatetime('2011-01-03'));
return second; // 输出: 208800
```
参考TDateTime SecondOf MonthOfTheYear WeekOfTheYear DayOfTheYear HourOfTheYear
MinuteOfTheYear MilliSecondOfTheYear
####### DayOfTheYear
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
d := DayOfTheYear(strtodate('2011-01-03'));
return d; // 输出: 3
```
参考TDateTime DayOf MonthOfTheYear WeekOfTheYear HourOfTheYear MinuteOfTheYear
SecondOfTheYear MilliSecondOfTheYear
####### DayOfTheMonth
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
day := DayOfTheMonth(strtodatetime('2011-01-22'));
return day; // 输出: 22
```
参考TDateTime DayOf WeekOfTheMonth HourOfTheMonth MinuteOfTheMonth
SecondOfTheMonth MilliSecondOfTheMonth
####### SecondOfTheMinute
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
second := SecondOfTheMinute(strtodatetime('2011-01-05 01:30:01'));
return second; // 输出: 1
```
参考TDateTime SecondOf MilliSecondofTheMinute MilliSecondOfTheSecond
####### HourOfTheWeek
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
hour := HourOfTheWeek(strtodatetime('2011-01-05 10:00:00'));
return hour; // 输出: 58
```
参考TDateTime HourOf DayOfTheWeek MinuteOfTheWeek SecondOfTheWeek
MilliSecondOfTheWeek
####### SecondOfTheMonth
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
second := SecondOfTheMonth(strtodatetime('2011-01-22 10:00:00'));
return second; // 输出: 1850400
```
参考TDateTime SecondOf WeekOfTheMonth DayOfTheMonth HourOfTheMonth
MinuteOfTheMonth MilliSecondOfTheMonth
####### DayOfTheWeek
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
Dayofweek := DayOfTheWeek(strtodatetime('2011-01-03'));
return dayofweek;
// 输出: 1
```
参考TDateTime DayOf HourOfTheWeek MinuteOfTheWeek SecondOfTheWeek
MilliSecondOfTheWeek
####### MinuteOfTheDay
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
minute := MinuteOfTheDay(strtodatetime('2011-01-05 01:22:22'));
return minute; // 输出: 82
```
参考TDateTime MinuteOf HourOfTheDay SecondOfTheDay MilliSecondOfTheDay
####### MilliSecondOfTheSecond
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
millisecond := MilliSecondOfTheSecond(strtodatetime('2011-01-05 01:30:01.990'));
return millisecond; // 输出:990
```
参考TDateTime MilliSecondOf MilliSecondofTheMinute
####### SecondOfTheWeek
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
second := SecondOfTheWeek(strtodatetime('2011-01-05 10:00:00'));
return second; // 输出: 208800
```
参考TDateTime SecondOf DayOfTheWeek HourOfTheWeek MinuteOfTheWeek
MilliSecondOfTheWeek
####### MinuteOfTheMonth
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
minute := MinuteOfTheMonth(strtodatetime('2011-01-22 10:00:00'));
return minute; // 输出: 30840
```
参考TDateTime MinuteOf WeekOfTheMonth DayOfTheMonth HourOfTheMonth
SecondOfTheMonth MilliSecondOfTheMonth
####### MinuteOfTheHour
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
minute := MinuteOfTheHour(strtodatetime('2011-01-05 01:30:01'));
return minute; // 输出: 30
```
参考TDateTime MinuteOf MinuteOfTheHour SecondOfTheHour MilliSecondOfTheHour
####### MinuteOfTheWeek
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
minute := MinuteOfTheWeek(strtodatetime('2011-01-05 10:00:00'));
return minute; // 输出: 3480
```
参考TDateTime MinuteOf DayOfTheWeek HourOfTheWeek SecondOfTheWeek
MilliSecondOfTheWeek
####### MilliSecondOfTheDay
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
millisecond := MilliSecondOfTheDay(strtodatetime('2011-01-05 01:30:01'));
return millisecond; // 输出: 5401000
```
参考TDateTime MilliSecondOf HourOfTheDay MinuteOfTheDay SecondOfTheDay
####### MilliSecondOfTheMonth
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
millisecond := MilliSecondOfTheMonth(strtodatetime('2011-01-22 10:00:00'));
return millisecond; // 输出: 1850400000
```
参考TDateTime MilliSecondOf WeekOfTheMonth DayOfTheMonth HourOfTheMonth
MinuteOfTheMonth SecondOfTheMonth
####### HourOfTheDay
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
hour := HourOfTheDay(strtodatetime('2011-01-05 23:22:22'));
return hour; // 输出: 23
```
参考TDateTime HourOf MinuteOfTheDay SecondOfTheDay MilliSecondOfTheDay
####### MilliSecondOfTheHour
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
millisecond := MilliSecondOfTheHour(strtodatetime('2011-01-05 01:30:01'));
return millisecond; // 输出: 1801000
```
参考TDateTime MilliSecondOf MinuteOfTheHour SecondOfTheHour
####### SecondOfTheHour
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
second := SecondOfTheHour(strtodatetime('2011-01-05 01:30:01'));
return second; // 输出: 1801
```
参考TDateTime SecondOf MinuteOfTheHour MilliSecondOfTheHour
####### MilliSecondofTheMinute
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
millisecond := MilliSecondofTheMinute(strtodatetime('2011-01-05 01:30:01'));
return millisecond; // 输出: 1000
```
参考TDateTime SecondOf MilliSecondOf MilliSecondOfTheSecond
####### SecondOfTheDay
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
second := SecondOfTheDay(strtodatetime('2011-01-05 01:30:01'));
return second; // 输出: 5401
```
参考TDateTime SecondOf HourOfTheDay MinuteOfTheDay MilliSecondOfTheDay
####### MilliSecondOfTheWeek
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
millisecond := MilliSecondOfTheWeek(strtodatetime('2011-01-05 10:00:00'));
return millisecond; // 输出: 208800000
```
参考TDateTime MilliSecondOf DayOfTheWeek HourOfTheWeek MinuteOfTheWeek
SecondOfTheWeek
###### 范围判定函数
####### 内容
- WithinPastYears
- WithinPastMonths
- WithinPastWeeks
- WithinPastDays
- WithinPastHours
- WithinPastMinutes
- WithinPastSeconds
- WithinPastMilliSeconds
####### WithinPastYears
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
范例一：
```tsl
// 2010年1月5日至2013年1月4日之间，不足3年，因此，判断为2年内
flag := WithinPastYears(strtodatetime('2010-01-05'), strtodatetime('2013-01-04'), 2);
return flag; // 输出: 1
```
范例二：
```tsl
// //2010年1月5日至2013年1月5日之间，相隔 3年，因此，判断为不在2年内
flag := WithinPastYears(strtodatetime('2010-01-05'), strtodatetime('2013-01-05'), 2);
return flag; // 输出: 0
```
参考TDateTime WithinPastMonths WithinPastWeeks WithinPastDays WithinPastHours
WithinPastSeconds WithinPastMinutes WithinPastMilliSeconds
####### WithinPastMonths
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
范例一：
```tsl
// 2011年1月5日到2011年7月6日的天数是182，而天数必须大于182.62(6*30.4375)，才能达到6个月，所以，1月5日还属于7月6日前推5个月范围内。
flag := WithinPastMonths(strtodatetime('2011-01-05'), strtodatetime('2011-07-06'), 5);
return flag; // 输出: 1
```
范例二：
```tsl
flag := WithinPastMonths(strtodatetime('2011-01-05'), strtodatetime('2011-07-07'), 5);
return flag; // 输出: 0
```
参考TDateTime WithinPastYears WithinPastWeeks WithinPastDays WithinPastHours
WithinPastSeconds WithinPastMinutes WithinPastMilliSeconds
####### WithinPastWeeks
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
范例一：
```tsl
// 2011年1月1日至2011年1月28日之间的天数为27天，不足28天(4*7)，所以仍在3周内
flag := WithinPastWeeks(strtodatetime('2011-01-01'), strtodatetime('2011-01-28'), 3);
return flag; // 输出: 1
```
范例二：
```tsl
// 2011年1月1日至2011年1月28日之间的天数为27天，不足28天(4*7)，所以仍在3周内
flag := WithinPastWeeks(strtodatetime('2011-01-01'), strtodatetime('2011-01-29'), 3);
return flag; // 输出: 0
```
参考TDateTime WithinPastYears WithinPastMonths WithinPastDays WithinPastHours
WithinPastSeconds WithinPastMinutes WithinPastMilliSeconds
####### WithinPastDays
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
范例一：
```tsl
flag := WithinPastDays(strtodate('2011-01-01'), strtodate('2011-01-11'), 10);
return flag; // 输出: 1
```
范例二：
```tsl
flag := WithinPastDays(strtodate('2011-01-01'), strtodate('2011-01-12'), 10);
return flag; // 输出: 0
```
参考TDateTime WithinPastYears WithinPastMonths WithinPastWeeks WithinPastHours
WithinPastSeconds WithinPastMinutes WithinPastMilliSeconds
####### WithinPastHours
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
范例一：
```tsl
// 不足11个小时
flag := WithinPastHours(strtodatetime('2011-01-01 00:00:00'), strtodatetime('2011-01-01 10:30:00'), 10);
return flag; // 输出: 1
```
范例二：
```tsl
flag := WithinPastHours(strtodatetime('2011-01-01 00:00:00'), strtodatetime('2011-01-01 11:00:00'), 10);
return flag; // 输出: 0
```
参考TDateTime WithinPastYears WithinPastMonths WithinPastWeeks WithinPastDays
WithinPastSeconds WithinPastMinutes WithinPastMilliSeconds
####### WithinPastMinutes
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
flag := WithinPastMinutes(strtodatetime('2011-01-01 10:00:00'), strtodatetime('2011-01-01 10:10:00'), 10);
return flag; // 输出: 1
flag := WithinPastMinutes(strtodatetime('2011-01-01 10:00:00'), strtodatetime('2011-01-01 10:11:00'), 10);
return flag; // 输出: 0
```
参考TDateTime WithinPastYears WithinPastMonths WithinPastWeeks WithinPastDays
WithinPastHours WithinPastSeconds WithinPastMilliSeconds
####### WithinPastSeconds
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
范例一：
```tsl
flag := WithinPastSeconds(strtodatetime('2011-01-01 10:00:00'), strtodatetime('2011-01-01 10:00:10'), 10);
return flag; // 输出: 1
```
范例二：
```tsl
flag := WithinPastSeconds(strtodatetime('2011-01-01 10:00:00'), strtodatetime('2011-01-01 10:00:11'), 10);
return flag; // 输出: 0
```
参考TDateTime WithinPastYears WithinPastMonths WithinPastWeeks WithinPastDays
WithinPastHours WithinPastMinutes WithinPastMilliSeconds
####### WithinPastMilliSeconds
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
ANow := strtodatetime('2011-01-01 10:00:00.100');
AThen := strtodatetime('2011-01-01 10:00:00.200');
flag := WithinPastMilliSeconds(ANow, AThen , 100);
return flag; // 输出: 1
```
参考TDateTime WithinPastYears WithinPastMonths WithinPastWeeks WithinPastDays
WithinPastHours WithinPastSeconds WithinPastMinutes
###### 范围获得函数
####### 内容
- YearsBetween
- MonthsBetween
- WeeksBetween
- DaysBetween
- HoursBetween
- MinutesBetween
- SecondsBetween
- MilliSecondsBetween
####### YearsBetween
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
years := YearsBetween(strtodatetime('2009-01-01 00:00:00'), strtodatetime('2011-01-01 23:59:59.999'));
return years; // 输出: 2
```
参考TDateTime MonthsBetween WeeksBetween DaysBetween HoursBetween MinutesBetween
SecondsBetween MilliSecondsBetween
####### MonthsBetween
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
months := MonthsBetween(strtodatetime('2011-05-01'), strtodatetime('2011-08-01'));
return months; // 输出: 3
```
参考TDateTime YearsBetween WeeksBetween DaysBetween HoursBetween MinutesBetween
SecondsBetween MilliSecondsBetween
####### WeeksBetween
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
weeks := WeeksBetween(strtodatetime('2011-05-01'), strtodatetime('2011-08-01'));
return weeks; // 输出: 13
```
参考TDateTime YearsBetween MonthsBetween DaysBetween HoursBetween MinutesBetween
SecondsBetween MilliSecondsBetween
####### DaysBetween
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
范例一：
```tsl
days := DaysBetween(strtodate('2011-05-01'), strtodate('2011-08-01'));
return days; // 输出: 92
```
范例二：
```tsl
// 不足完整的一天：39815.04167-39814.08333=0.95834
// 2009-01-01 02:00:00：日期时间为39814.08333
// 2009-01-02 01:00:00：日期时间为39815.04167
days := DaysBetween(strtodatetime('2009-01-01 02:00:00'), strtodatetime('2009-01-02 01:00:00'));
return days; // 输出: 0
```
参考TDateTime YearsBetween MonthsBetween WeeksBetween HoursBetween
MinutesBetween SecondsBetween MilliSecondsBetween
####### HoursBetween
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
Hours := HoursBetween(strtodatetime('2011-08-01 00:00:00'), strtodatetime('2011-08-01 12:00:00'));
return hours; // 输出: 12
```
参考TDateTime YearsBetween MonthsBetween WeeksBetween DaysBetween MinutesBetween
SecondsBetween MilliSecondsBetween
####### MinutesBetween
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
minutes := MinutesBetween(strtodatetime('2011-08-01 00:00:00'), strtodatetime('2011-08-01 12:00:00'));
return minutes; // 输出: 720
```
参考TDateTime YearsBetween MonthsBetween WeeksBetween DaysBetween HoursBetween
SecondsBetween MilliSecondsBetween
####### SecondsBetween
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
seconds := SecondsBetween(strtodatetime('2011-08-01 00:00:00'), strtodatetime('2011-08-01 12:00:00'));
return seconds; // 输出: 43200
```
参考TDateTime YearsBetween MonthsBetween WeeksBetween DaysBetween HoursBetween
MinutesBetween MilliSecondsBetween
####### MilliSecondsBetween
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
BegT := strtodatetime('2011-08-01 00:00:00');
EndT := strtodatetime('2011-08-01 12:00:00');
milliseconds := MilliSecondsBetween(BegT, EndT);
return milliseconds; // 输出: 43200000
```
参考TDateTime YearsBetween MonthsBetween WeeksBetween DaysBetween HoursBetween
MinutesBetween SecondsBetween
###### 范围生成函数
####### 内容
- YearSpan
- MonthSpan
- WeekSpan
- DaySpan
- HourSpan
- MinuteSpan
- SecondSpan
- MilliSecondSpan
####### YearSpan
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
years := YearSpan(strtodatetime('2010-08-01 00:00:00'), strtodatetime('2012-08-01 12:00:00'));
return years; // 输出: 2.00274
```
参考TDateTime MonthSpan WeekSpan DaySpan HourSpan MinuteSpan SecondSpan
MilliSecondSpan
####### MonthSpan
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
months := MonthSpan(strtodatetime('2010-08-01 00:00:00'), strtodatetime('2012-08-01 12:00:00'));
return months; // 输出: 24.03
```
参考TDateTime YearSpan WeekSpan DaySpan HourSpan MinuteSpan SecondSpan
MilliSecondSpan
####### WeekSpan
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
BegT := strtodatetime('2010-08-01 00:00:00');
EndT := strtodatetime ('2012-08-01 12:00:00');
weeks := WeekSpan(BegT, EndT);
return weeks; // 输出: 104.5
```
参考TDateTime YearSpan MonthSpan DaySpan HourSpan MinuteSpan SecondSpan
MilliSecondSpan
####### DaySpan
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
BegT := strtodatetime('2010-08-01 00:00:00');
EndT := strtodatetime('2012-08-01 12:00:00');
days := DaySpan(BegT, EndT);
return days; // 输出: 731.5
```
参考TDateTime YearSpan MonthSpan WeekSpan HourSpan MinuteSpan SecondSpan
MilliSecondSpan
####### HourSpan
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
hours := HourSpan(strtodatetime('2010-08-01 00:00:00'), strtodatetime('2012-08-01 12:00:00'));
return hours; // 输出: 17556
```
参考TDateTime YearSpan MonthSpan WeekSpan DaySpan MinuteSpan SecondSpan
MilliSecondSpan
####### MinuteSpan
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
BegT := strtodatetime('2010-08-01 00:00:00');
EndT := strtodatetime('2012-08-01 12:00:00');
minutes := MinuteSpan(BegT, EndT);
return minutes; // 输出: 1053360
```
参考TDateTime YearSpan MonthSpan WeekSpan DaySpan HourSpan SecondSpan
MilliSecondSpan
####### SecondSpan
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
BegT := strtodatetime('2010-08-01 00:00:00');
EndT := strtodatetime('2012-08-01 12:00:00');
seconds := SecondSpan(BegT, EndT);
return seconds; // 输出: 63201600
```
参考TDateTime YearSpan MonthSpan WeekSpan DaySpan HourSpan MinuteSpan
MilliSecondSpan
####### MilliSecondSpan
范例
```tsl
BegT := strtodatetime('2010-08-01 00:00:00');
EndT := strtodatetime('2012-08-01 12:00:00');
milliseconds := SecondSpan(BegT, EndT);
return milliseconds; // 输出: 63201600000
```
参考TDateTime YearSpan MonthSpan WeekSpan DaySpan HourSpan MinuteSpan SecondSpan
###### 时间推移函数
####### 内容
- IncYear
- IncHalfYear
- IncQuarter
- IncMonth
- IncWeek
- IncDay
- IncHour
- IncMinute
- IncSecond
- IncMilliSecond
####### IncYear
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
incyears := IncYear(strtodatetime('2010-08-01'), 10);
return datetostr(incyears); // 输出: 2020-08-01
```
参考TDateTime
####### IncHalfYear
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
Avalue := 40179; // 40179表示2010年1月1号
Number := 2;
return IncHalfYear(AValue, Number);
// 结果：40544 //40544表示2011年1月1号
```
####### IncQuarter
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
Avalue := 40179; // 40179表示2010年1月1号
Number := 2;
return IncQuarter(AValue, Number);
// 结果：40360 //40360表示2010年7月1号
```
####### IncMonth
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
incmonths := IncMonth(strtodatetime('2010-08-01'), 2);
return datetostr(incmonths); // 输出: 2010-10-01
```
参考TDateTime
####### IncWeek
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
incweeks := IncWeek(strtodatetime('2010-08-01'), 1);
return datetostr(incweeks); // 输出: 2010-08-08
```
参考TDateTime
####### IncDay
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
incdays := IncDay(strtodatetime('2010-08-01'), 10);
return datetostr(incdays); // 输出: 2010-08-11
```
参考TDateTime
####### IncHour
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
inchours := IncHour(strtodatetime('2010-08-01 00:01:01'), 10);
return datetimetostr(inchours); // 输出: 2010-08-01 10:01:01
```
参考TDateTime
####### IncMinute
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
incminutes := IncMinute(strtodatetime('2010-08-01 00:01:01'), 50);
return datetimetostr(incminutes); // 输出: 2010-08-01 00:51:01
```
参考TDateTime
####### IncSecond
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
incseconds := IncSecond(strtodatetime('2010-08-01 00:01:01'), 50);
return datetimetostr(incseconds); // 输出: 2010-08-01 00:01:51
```
参考TDateTime
####### IncMilliSecond
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
incmilliseconds := IncMilliSecond(strtodatetime('2010-08-01 00:01:01.950'), 50);
return datetimetostr(incmilliseconds); // 输出: 2010-08-01 00:01:02
```
参考TDateTime
###### 组合、分解日期函数
####### 内容
- EncodeDateTime
- DecodeDateTime
- EncodeDateWeek
- DecodeDateWeek
- DecodeDateDay
- EncodeDateMonthWeek
- DecodeDateMonthWeek
- TryEncodeDateTime
- TryEncodeDateWeek
- TryEncodeDateDay
- TryEncodeDateMonthWeek
####### EncodeDateTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
timeset := EncodeDateTime(2011, 08, 08, 09, 32, 45, 990);
return datetimetostr(timeset); // 输出: 2011-08-08 09:32:45
```
参考TDateTime YearOf MonthOf DayOf HourOf MinuteOf SecondOf MilliSecondOf
DecodeDateTime EncodeDateWeek DecodeDateWeek DecodeDateDay EncodeDateMonthWeek
DecodeDateMonthWeek
####### DecodeDateTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
EndT := strtodatetime('2011-08-08 12:09:10.990');
DecodeDateTime(EndT, year, month, day, hour, minute, second, millisecond);
return array(year, month, day, hour, minute, second, millisecond);
// 输出：array(2011,8,8,12,9,10,990)
```
参考TDateTime YearOf MonthOf DayOf HourOf MinuteOf SecondOf MilliSecondOf
EncodeDateTime EncodeDateWeek DecodeDateWeek DecodeDateDay EncodeDateMonthWeek
DecodeDateMonthWeek
####### EncodeDateWeek
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
// 一个自然周至少要有4天属于该年的日期，这一周才属于这年。
// 1月1日和1月2日所属周只有2天处于2011年，所以，这周属于2010年，2011年的第一周从2011年1月3日算起
week := EncodeDateWeek(2011, 1, 1);
return datetostr(week);
// 输出: 2011-01-03
```
参考TDateTime YearOf MonthOf DayOf HourOf MinuteOf SecondOf MilliSecondOf
EncodeDateTime DecodeDateTime DecodeDateWeek DecodeDateDay EncodeDateMonthWeek
DecodeDateMonthWeek
####### DecodeDateWeek
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
DecodeDateWeek(strtodatetime('2011-08-08'), year, weekofyear, dayofweek);
return array( year, weekofyear, dayofweek);
// 输出: array(2011, 32,1)
```
参考TDateTime YearOf MonthOf DayOf HourOf MinuteOf SecondOf MilliSecondOf
EncodeDateTime DecodeDateTime EncodeDateWeek DecodeDateDay EncodeDateMonthWeek
DecodeDateMonthWeek
####### DecodeDateDay
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
DecodeDateDay(strtodatetime('2011-08-08'), year, dayofyear);
return array(year, dayofyear);
// 输出: array(2011,220)
```
参考TDateTime YearOf MonthOf DayOf HourOf MinuteOf SecondOf MilliSecondOf
EncodeDateTime DecodeDateTime EncodeDateWeek DecodeDateWeek EncodeDateMonthWeek
DecodeDateMonthWeek
####### EncodeDateMonthWeek
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
monthweek := EncodeDateMonthWeek(2011, 8, 2, 1);
return datetimetostr(monthweek); // 输出: 2011-08-08
```
参考TDateTime YearOf MonthOf DayOf HourOf MinuteOf SecondOf MilliSecondOf
EncodeDateTime DecodeDateTime EncodeDateWeek DecodeDateWeek DecodeDateDay
DecodeDateMonthWeek
####### DecodeDateMonthWeek
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
DecodeDateMonthWeek(strtoDatetime("2011-08-10"), year, month, weekofMonth, dayOfWeek1);
return array(year, month, weekofMonth, dayOfWeek1); // 输出: array(2011,8,2,3)
```
参考TDateTime YearOf MonthOf DayOf HourOf MinuteOf SecondOf MilliSecondOf
EncodeDateTime DecodeDateTime EncodeDateWeek DecodeDateWeek DecodeDateDay
EncodeDateMonthWeek
####### TryEncodeDateTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
Flag := TryEncodeDateTime(2011, 8, 10, 10, 01, 01, 999, Atime);
return array(flag, datetimetostr(Atime)); // 输出: array(1,'2011-08-10 10:01:01')
```
参考TDateTime YearOf MonthOf DayOf HourOf MinuteOf SecondOf MilliSecondOf
TryEncodeDateWeek TryEncodeDateDay TryEncodeDateMonthWeek
####### TryEncodeDateWeek
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
Flag := TryEncodeDateWeek(2011, 1, Atime, 1);
return array(flag, datetimetostr(Atime)); // 输出: array(1,'2011-01-03')
```
参考TDateTime YearOf MonthOf DayOf HourOf MinuteOf SecondOf MilliSecondOf
TryEncodeDateTime TryEncodeDateDay TryEncodeDateMonthWeek
####### TryEncodeDateDay
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
Flag := TryEncodeDateDay(2011, 1, Atime);
return array(flag, datetimetostr(Atime)); // 输出: array(1,'2011-01-01')
```
参考TDateTime YearOf MonthOf DayOf HourOf MinuteOf SecondOf MilliSecondOf
TryEncodeDateTime TryEncodeDateWeek TryEncodeDateMonthWeek
####### TryEncodeDateMonthWeek
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
Flag := TryEncodeDateMonthWeek(2011, 1, 1, 1, Atime);
return array(flag, datetimetostr(Atime)); // 输出: array(1,'2011-01-03')
```
参考TDateTime YearOf MonthOf DayOf HourOf MinuteOf SecondOf MilliSecondOf
TryEncodeDateTime TryEncodeDateWeek TryEncodeDateDay
###### 日期重组函数
####### 内容
- RecodeYear
- RecodeMonth
- RecodeDay
- RecodeHour
- RecodeMinute
- RecodeSecond
- RecodeMilliSecond
- RecodeDate
- RecodeTime
- RecodeDateTime
- TryRecodeDateTime
- CompareDateTime
- SameDateTime
- CompareDate
- SameDate
- CompareTime
- SameTime
- NthDayOfWeek
- DecodeDayOfWeekInMonth
- EncodeDayOfWeekInMonth
- TryEncodeDayOfWeekInMonth
####### RecodeYear
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
范例一：
```tsl
newTime := RecodeYear(strtoDatetime("2010-08-01"), 2009);
return datetimetostr(newTime); // 输出: 2009-08-01
```
范例二：
```tsl
// 用try...except...end语句进行异常处理，如果无法替换成有效的日期，则把NewTime设置为0.
try
newTime := RecodeYear(strtoDatetime("2012-02-29"), 2013);
except
newTime := 0;
end;
return newTime; // 输出: 0
```
参考TDateTime
####### RecodeMonth
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
范例一：
```tsl
try
newTime := RecodeMonth(strtodatetime("2011-08-10"), 10);
newTime := datetimetostr(newTime);
except
newTime := 0;
end;
return newTime; // 输出: 2011-10-10
```
范例二：
```tsl
try
newTime := RecodeMonth(strtodatetime("2013-3-31"), 4);
newTime := datetimetostr(newTime);
except
newTime := 0;
end;
return newTime; // 输出: 0
```
参考TDateTime
####### RecodeDay
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
范例一：
```tsl
try
newTime := RecodeDay(strtodatetime("2011-08-10"), 1);
newTime := datetostr(newTime);
except
newTime := 0;
end;
return newTime; // 输出: 2011-08-01
```
范例二：
```tsl
try
newTime := RecodeDay(strtodatetime("2011-02-28"), 31);
newTime := datetostr(newTime);
except
newTime := 0;
end;
return newTime; // 输出: 0
```
参考TDateTime
####### RecodeHour
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
newTime := RecodeHour(strtodatetime("2011-08-10 12:12:12"), 1);
return datetimetostr(newTime); // 输出: 2011-08-10 01:12:12
```
参考TDateTime
####### RecodeMinute
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
newTime := RecodeMinute (strtodatetime("2011-08-10 12:12:12"), 9);
return datetimetostr(newTime); // 输出: 2011-08-10 12:09:12
```
参考TDateTime
####### RecodeSecond
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
newTime := RecodeSecond(strtodatetime("2011-08-10 12:12:12"), 9);
return datetimetostr(newTime); // 输出: 2011-08-10 12:12:09
```
参考TDateTime
####### RecodeMilliSecond
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
newTime := RecodeMilliSecond(strtodatetime("2011-08-10 12:12:12.999"), 100);
return MilliSecondOf (newTime); // 输出: 100
```
参考TDateTime
####### RecodeDate
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
newTime := RecodeDate(strtodatetime("2011-08-10 12:12:12"), 2010, 8, 9);
return datetimetostr(newTime); // 输出: 2010-08-09 12:12:12
```
参考TDateTime
####### RecodeTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
newTime := RecodeTime(strtodatetime("2011-08-10 12:12:12.999"), 10, 8, 9, 100);
return datetimetostr(newTime); // 输出: 2011-08-10 10:08:09
```
参考TDateTime
####### RecodeDateTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
newTime := RecodeDateTime(strtodatetime("2011-08-10 12:12:12.999"), 2010, 8, 10, 10, 8, 9, 100);
return datetimetostr(newTime); // 输出: 2010-08-10 10:08:09
```
参考TDateTime
####### TryRecodeDateTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
TryRecodeDateTime(strtodatetime("2011-08-10 12:12:12.999"), 2010, 8, 10, 10, 8, 9, 100, Aresult);
return datetimetostr(Aresult); // 输出: 2010-08-10 10:08:09
```
参考TDateTime
####### CompareDateTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
result := CompareDateTime(strtodatetime("2011-08-10"), strtodatetime("2011-08-11"));
return result; // 输出: -1
```
参考TDateTime
####### SameDateTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
flag := SameDateTime(strtodatetime("2011-08-10"), strtodatetime("2011-08-11"));
return flag; // 输出: 0
```
参考TDateTime
####### CompareDate
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
result := CompareDate(strtodatetime("2011-08-10"), strtodatetime("2011-08-11"));
return result; // 输出: -1
```
参考TDateTime
####### SameDate
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
flag := SameDate(strtodatetime("2011-08-1001:00:00"), strtodatetime("2011-08-1002:00:00"));
return flag; // 输出: 1
```
参考TDateTime
####### CompareTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
result := CompareTime(strtodatetime("2011-08-10 01:00:00"), strtodatetime("2011-08-11 01:00:00"));
return result; // 输出: 0
```
参考TDateTime
####### SameTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
result := SameTime(strtodatetime("2011-08-10 01:00:00"), strtodatetime("2011-08-11 01:00:00"));
return result; // 输出: 1
```
参考TDateTime
####### NthDayOfWeek
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
EndT := strtodatetime("2014-01-06");
weekNum := NthDayOfWeek(EndT);
WOFM := WeekOfTheMonth(EndT);
return array(weekNum, WOFM); // 输出: array(1,2)
```
参考TDateTime
####### DecodeDayOfWeekInMonth
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
EndT := strtodatetime("2011-08-10 12:10:09");
DecodeDayOfWeekInMonth(endt, Ayear, Amonth, ANthDayOfWeek, ADayOfWeek);
return array(Ayear, Amonth, ANthDayOfWeek, ADayOfWeek );
// 输出: array(2011,8,2,3)
```
参考TDateTime
####### EncodeDayOfWeekInMonth
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
// 2013年10月1日是周二，1日至6日不属于这个月的周，从7日（周一）所属周开始算起
return EncodeDayOfWeekInMonth(2013, 10, 2, 1); // 输出41561（'2013-10-14'）
```
参考TDateTime
####### TryEncodeDayOfWeekInMonth
用途：日期时间相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
TryEncodeDayOfWeekInMonth(2013, 10, 2, 1, newtime);
return datetimetostr(newtime);
// 输出: 2013-10-14
```
参考TDateTime
###### 日期格式的转换
####### 内容
- DateTimeToJulianDate
- JulianDateToDateTime
- TryJulianDateToDateTime
- DateTimeToModifiedJulianDate
- ModifiedJulianDateToDateTime
- TryModifiedJulianDateToDateTime
- DateTimeToUnix
- UnixToDateTime
- FileDateToDateTime
- DateTimeToFileDate
- ExcelRDate
####### DateTimeToJulianDate
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
return DateTimeToJulianDate(strtodatetime('2014-01-01 10:00:00'));
// 输出2456658.91667
```
参考TDateTime JulianDateToDateTime TryJulianDateToDateTime
DateTimeToModifiedJulianDate ModifiedJulianDateToDateTime
TryModifiedJulianDateToDateTime DateTimeToUnix UnixToDateTime
####### JulianDateToDateTime
范例
```tsl
A := JulianDatetoDateTime(2456658.91667);
return DatetimetoStr(A); // 输出2014-01-01 10:00:00
```
参考TDateTime DateTimeToJulianDate TryJulianDateToDateTime
DateTimeToModifiedJulianDate ModifiedJulianDateToDateTime
TryModifiedJulianDateToDateTime DateTimeToUnix UnixToDateTime
####### TryJulianDateToDateTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
flag := TryJulianDateToDateTime(2456658.91667, T);
if flag then return DatetimetoStr(T);
else return 0;
// 输出2014-01-01 10:00:00
```
参考TDateTime DateTimeToJulianDate JulianDateToDateTime
DateTimeToModifiedJulianDate ModifiedJulianDateToDateTime
TryModifiedJulianDateToDateTime DateTimeToUnix UnixToDateTime
####### DateTimeToModifiedJulianDate
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
a := DateTimeToModifiedJulianDate(strtodatetime('2014-01-01 10:00:00'));
return a; // 输出56658.41667
```
参考TDateTime DateTimeToJulianDate JulianDateToDateTime TryJulianDateToDateTime
ModifiedJulianDateToDateTime TryModifiedJulianDateToDateTime DateTimeToUnix
UnixToDateTime
####### ModifiedJulianDateToDateTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
t := ModifiedJulianDateToDateTime(56658.41667);
return datetimetostr(t); // 输出2014-01-01 10:00:00
```
参考TDateTime DateTimeToJulianDate DateTimeToUnix JulianDateToDateTime
TryJulianDateToDateTime UnixToDateTime DateTimeToModifiedJulianDate
TryModifiedJulianDateToDateTime
####### TryModifiedJulianDateToDateTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
flag := TryModifiedJulianDateToDateTime(56658.41667, t);
if flag then return datetimetostr(t);
else return 0;
// 输出2014-01-01 10:00:00
```
参考TDateTime DateTimeToJulianDate JulianDateToDateTime TryJulianDateToDateTime
DateTimeToModifiedJulianDate ModifiedJulianDateToDateTime DateTimeToUnix
UnixToDateTime
####### DateTimeToUnix
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
return DateTimeToUnix(strtodatetime('2014-01-01 10:00:00'));
// 输出1388570400
```
参考TDateTime DateTimeToJulianDate JulianDateToDateTime TryJulianDateToDateTime
DateTimeToModifiedJulianDate ModifiedJulianDateToDateTime
TryModifiedJulianDateToDateTime UnixToDateTime
####### UnixToDateTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
T := UnixToDateTime(1388570400);
return datetimetostr(T);
// 输出2014-01-01 10:00:00
```
参考TDateTime DateTimeToJulianDate JulianDateToDateTime TryJulianDateToDateTime
DateTimeToModifiedJulianDate ModifiedJulianDateToDateTime
TryModifiedJulianDateToDateTime DateTimeToUnix
####### FileDateToDateTime
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
EndT := FileDateToDateTime(1143033856);
return datetimetostr(EndT);
// 输出：2014-01-01 10:00:00
```
差异说明依赖运行时操作系统相关API，与DateTimeToFileDate相对。
具体差异表现可参考：FAQ：DateTimeToFileDate
####### DateTimeToFileDate
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
EndT := strtodatetime('2014-01-01 10:00:00');
FileEndT := DateTimeToFileDate(EndT);
return array(EndT, FileEndT);
// 比较两种日期输出
// 输出：array(41640.41667,1143033856)
```
差异说明转化的结果依赖运行时操作系统相关API，转换结果会存在差异，但是同一系统中，转换与转回是自恰的。
即，通过DateTimeToFileDate转换后的结果，再通过FileDateToDateTime转回，可以得到最初未转换之前的值。
如：
```tsl
fdate := DateTimeToFileDate(20240525.1430T);
echo fdate; // windows下返回：1488548800 Linux中返回：1716618600
t := FileDateToDateTime(fdate);
return t; // 都返回20240525.1430T
```
####### ExcelRDate
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
RDate := 20101231;
return ExcelRDate(RDate);
// 结果：2010-12-31
```
###### 宽字节日期格式转换函数
####### 内容
- DateTimeGMTToCookieStrw
- DateTimeGMTToHttpStrw
- DateTimeToInternetStrw
- Datetimetostrw
- TimetoStrw
- DateToStrw
####### DateTimeGMTToCookieStrw
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
return DateTimeGMTToCookieStrw(20200723.110633T);
// 输出Thu, 23-Jul-2020 11:06:33 GMT
```
####### DateTimeGMTToHttpStrw
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
return DateTimeGMTToHttpStrw(20200723.110633T);
// 输出Thu, 23 Jul 2020 11:06:33 GMT
```
####### DateTimeToInternetStrw
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
return DateTimeToInternetStrw(20200723.110633T, 0);
// 输出Thu, 23 Jul 2020 11:06:33 +0800
```
####### Datetimetostrw
范例
```tsl
return datetimetostrw(20200720.0930T);
// 输出宽字节字符串：2020-07-20 09:30:00
```
####### TimetoStrw
用途：将输入值转换为字符串。
参数：
返回：字符串。
范例
```tsl
return TimetoStrw(9.5 / 24); // 输出宽字节字符串：09:30:00
return TimetoStrw(20200720.0930T); // 输出宽字节字符串：09:30:00
```
####### DateToStrw
用途：将输入值转换为字符串。
参数：
返回：字符串。
范例
```tsl
return datetostrw(20200720T); // 输出宽字节字符串 2020-07-20
```
##### 字符串
###### 内容
- 常用字符串函数
- 判定函数
- 替换以及处理函数
- 字符串数组相关函数
- 重复函数
- 多字节语言支持函数
- 字节函数
- 发音相关函数
- 正则表达式函数
- 正则表达式
- 多语言支持函数
- 文件名以及目录名相关处理函数
- 其它
###### 常用字符串函数
####### 内容
- StrCmp
- Chr
- WideChr
- Str2Array
- Concat
- Array2Str
- Format
- Ord
- SetLength
- CompareText
- Copy
- UpperCase
- LeftBStr
- RightBStr
- MidBStr
- GetFormatLocalCode
- Str
- RightStr
- CompareStr
- LeftStr
- Trim
- SameText
- SetChar
- AppendStr
- GetChar
- LowerCase
- SetFormatLocalCode
- Val
- Pos
- TrimRight
- AnsiFormat
- TrimLeft
- StrToIntDef
- FormatFloat
- StrToCurrDef
- Booltostr2
- StrToFloatDef
- Tostring
- IntToHex
- TryStrToInt
- FloatToStr
- TryStrToFloat
- FormatCurr
- TryStrToCurr
- StrToInt
- BoolToStr
- CurrToStr
- TryStrToBool
- SpaceByNumber
- IsValidIdent
- StrToBool
- StrToFloat
- StrToBoolDef
- IntToStr
- StrToCurr
- AnsiStr2Array
- TryUppercase
- TryLowercase
- SysEncodecryptStr
- Letters
- DecToInt64
- DecToInt64def
- TryDecToInt64
- DecToInt32
- DecToInt32def
- TryDecToInt32
- StrToInt64
- StrToInt64Def
- TryStrToInt64
- StrToInt32
- StrToInt32Def
- TryStrToInt32
- DecToInt
- DecToIntDef
- TryDecToInt
####### StrCmp
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
a := StrCmp("arr", "arry");
return a; //
// 输出；-1
```
差异说明返回值的绝对值大小无实际意义，在不同操作系统中，其绝对值大小也表现不一。
比如，对比字符或ASCII码的比较，在Linux中，返回ASCII码相差的值，Windows中只返回-1，0，1等代表大小，但是符号是一致的。
如strcmp(#97,#100);// Windows返回-1，Linux中返回-3。
####### Chr
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
aValue := Chr(50);
return aValue;
// 输出：字符串'2'
```
参考Ord
####### WideChr
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
aValue := WideChr(25105);
return aValue;
// 输出：Unicode字符串L'我'
```
参考Ord
####### Str2Array
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
r := Str2Array("SZ000001;SZ000002;SH600000", ";"); // 以分号分隔
return r;
// 输出：array("SZ000001","SZ000002","SH600000")
```
参考Array2Str
####### Concat
用途：字符串相关函数。
参数：
返回：字符串。
范例
范例01：
```tsl
arr := Concat("thank-", "you-", "very-", "much! ");
return arr; // 输出：thank-you-very-much!
```
范例02：Unicode字符串的合并
```tsl
s1 := multibytetounicodew('天软', 936);
s2 := Inttostrw(2020);
return concat(s1, s2);
// 输出宽字节字符串：天软2020
```
####### Array2Str
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
var arr := array("thank", "you", "very", "much! ");
a := Array2Str(arr, "-");
return a;
// 输出：thank-you-very-much!
```
参考Str2Array
####### Format
用途：按指定格式输出结果。
参数：
返回：字符串。
范例
1、把两个数字格式化为字符串：Format('First %d, Second %d', n1, n2);
其中n1和n2是两个整数值，第一个占位符由第一个值替代，第二个占位符由第二个值替代，以此类推。
2、Format ('%-8d', n1);
该句把数字n1转换成有长度是8个字符的字符串，并通过填充空白使文本左对齐，左对齐用减号(-)
范例01：（D 和X的使用范例）
```tsl
// 指定前2个数值转化为十进制数字字符串，第3个整数转化成十六进制字符串，3个数值必须是整数。
// 第2个转化%-5d：由于3只有1位，需要左对齐，则在右边添加4位空格
return Format('%d,%-5d,%X', 4, 3, 12);
// 输出字符串：4,3 ,C
```
范例02：（E的使用范例）
```tsl
// .1表示后面的小数位的精度。注意，v必须是一个浮点数，比如1234400.0，如果是1234400则被认为是整数，执行函数报错
return format("%.1E", 1234400.0);
// 输出字符串：1.2E+006
```
范例03：（F的使用范例）
```tsl
return format("%.1f", 1234400.56789);
// 输出字符串： 1234400.6
```
范例04：（G的使用范例）
```tsl
return format("%G", 1.2E + 006);
// 输出字符串：1200000
```
范例05：（N的使用范例）
```tsl
return format("%.1N", 1234400.56789);
// 输出字符串：1,234,400.6
```
范例06：（M的使用范例）
```tsl
return format("%.1M", 1234400.56789);
// 输出字符串：￥1,234,400.6
```
范例七：（参数的索引）
```tsl
return Format('%2:d,%1:5d,%0:X', 14, 3, 12);
// 输出字符串：12, 3,E
```
参考SetFormatLocalCode GetFormatLocalCode AnsiFormat
####### Ord
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
r := Ord("2");
return r; // 输出:50
```
参考Chr
####### SetLength
用途：字符串相关函数。
参数：
返回：整数。
范例
```tsl
// 相当于截取了源串S的前NewLength个字符
S := 'thankyou';
SetLength(S, 5);
return S;
// 输出字符串：thank
```
####### CompareText
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return CompareText("SZ000002", "SZ000001"); // 输出:1
return CompareText("SZ000001", "sz000001"); // 输出:0
return CompareText("万科A", "万科Ａ"); // 输出:-65248
```
参考CompareStr
差异说明返回值的绝对值大小无实际意义，仅符号有效。不同操作系统中，返回的绝对值会存在差异，但是在同一个操作系统中，结果是确定的。
如执行：return CompareText("Tinysoft","tsl");
在Windows下返回-1，在Linux中返回：-10
####### Copy
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
a := Copy('thank you', 3, 6);
return a; // 输出字符串：ank yo
```
参考Concat
####### UpperCase
用途：进行大小写转换。
参数：
返回：字符串。
范例
```tsl
return UpperCase("sz000001");
// 输出：SZ000001
```
参考LowerCase
####### LeftBStr
用途：进行字符串提取或替换处理。
参数：
返回：字符串。
范例
```tsl
arr := LeftBStr("i am a student", 4);
return arr; // 输出字符串：i am
```
####### RightBStr
用途：进行字符串提取或替换处理。
参数：
返回：字符串。
范例
```tsl
arr := RightBStr("i am a student", 4);
return arr; // 输出:dent
```
####### MidBStr
范例
```tsl
arr := midBStr("i am a student", 6, 6);
return arr; // 输出: a stud
```
####### GetFormatLocalCode
用途：按指定格式输出结果。
参数：无。
返回：字符串。
范例
```tsl
SetFormatLocalCode(0);
return GetFormatLocalCode(); // 输出:0
```
参考SetFormatLocalCode Format AnsiFormat
####### Str
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
Str(114, s);
return s; // 输出:1.14000000000000E+0002
```
参考Val
####### RightStr
用途：进行字符串提取或替换处理。
参数：
返回：字符串。
范例
```tsl
return RightStr('abccccdddd', 2);
// 结果：’dd’
```
####### CompareStr
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return CompareStr("万科A", "万科Ａ");
// 输出：-65248
```
参考CompareText
差异说明返回值的绝对值大小无实际意义，仅符号有效。不同操作系统中，返回的绝对值会存在差异，但是在同一个操作系统中，结果是确定的。
如执行：return CompareStr("Tinysoft","tsl");
在Windows下返回-1，在Linux中返回：-2099710
####### LeftStr
用途：进行字符串提取或替换处理。
参数：
返回：字符串。
范例
```tsl
return LeftStr('abccccdddd', 2);
// 结果：'ab'
```
####### Trim
用途：去除字符串首尾空白字符（空格、换行等）。
参数：s（字符串）。
返回：字符串。
范例
```tsl
return Trim(" Hello! \r\n Tinysoft ");
```
结果：
```text
Hello!
Tinysoft
```
参考TrimLeft TrimRight
####### SameText
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return SameText("SZ000001", "sz000001"); // 输出: 1
```
####### SetChar
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
var arr := "I am a student";
SetChar(arr, 10, 116);
return arr; // 输出: I am a sttdent
```
####### AppendStr
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
s := "申万";
AppendStr(s, "采掘");
return s; // 输出：申万采掘
```
####### GetChar
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
arr := GetChar("i am a student", 9);
return arr; // 输出: 116
```
####### LowerCase
用途：进行大小写转换。
参数：
返回：字符串。
范例
```tsl
return LowerCase("万科A");
// 输出: 万科a
```
参考UpperCase
####### SetFormatLocalCode
用途：按指定格式输出结果。
参数：
返回：字符串。
范例
```tsl
SetFormatLocalCode(0);
return GetFormatLocalCode(); // 输出:0
```
参考GetFormatLocalCode Format AnsiFormat
####### Val
用途：字符串相关函数。
参数：
返回：字符串。
范例
范例一：
```tsl
Val("1.1424E+0002", v, Code);
return v; // 输出:114.24
```
范例二：
```tsl
// 返回错误信息：在转换到第6位字符时不成功。
Val("1.142aE+0002", v, Code);
return array(v, code); // 输出:array(1.142,6)
```
参考Str
####### Pos
用途：字符串相关函数。
参数：
返回：整数。
范例
```tsl
a := Pos('a', 'thank you');
return a; // 输出: 3
return Pos('fg', 'adcfgvbhj');
// 结果：4
```
参考Copy Concat
####### TrimRight
用途：去除字符串末尾空白字符。
参数：s（字符串）。
返回：字符串。
范例
```tsl
return TrimRight("Hello! \r\n Tinysoft ");
```
结果：
```text
Hello!
Tinysoft
```
参考Trim TrimLeft
####### AnsiFormat
参考GetFormatLocalCode SetFormatLocalCode Format
####### TrimLeft
用途：去除字符串开头空白字符。
参数：s（字符串）。
返回：字符串。
范例
```tsl
return TrimLeft(" Hello! \r\n Tinysoft ");
```
结果：
```text
Hello!
Tinysoft
```
参考Trim TrimRight
####### StrToIntDef
用途：将字符串转换为对应类型。
参数：
返回：转换后的数值或日期。
范例
范例01
```tsl
return StrToIntDef("12", 1); // 输出: 12
return StrToIntDef("test", 1); // 输出: 1
```
范例02：十六进制格式字符串的转换
```tsl
return StrToIntDef("0x12", 1); // 输出：18
// 输出：18
```
参考StrToInt IntToHex StrToBool IntToStr TryStrToInt StrToBoolDef TryStrToBool
BoolToStr FloatToStr CurrToStr StrToFloat StrToFloatDef TryStrToFloat StrToCurr
StrToCurrDef TryStrToCurr
####### FormatFloat
用途：按指定格式输出结果。
参数：
返回：字符串。
范例
| 格式串 | 1234 | -1234 | 0.5 | 0 |
| ------------------------- | --------- | ------------ | --------- | --------- |
| 无 | | -1234 | 0.5 | 0 |
| 0 | 1234 | -1234 | 1 | 0 |
| 0.00 | 1234.00 | -1234.00 | 0.50 | 0.00 |
| #######.## | 1234 | -1234 | .5 | |
| #######,##0.00 | 1,234.00 | 1,234.00 | 0.50 | 0.00 |
| #######,##0.00;(#,##0.00) | 1,234.00 | （1,234.00） | 0.50 | 0.00 |
| #######,##0.00;;Zero | 1,234.00 | -1,234.00 | 0.5 | Zero |
| 0.000E+00 | 1.234E+03 | -1.234E+03 | 5.000E-01 | 0.000E+00 |
| #######.###E-0 | 1.234E3 | -1.234E3 | 5E-1 | 0E0 |
```tsl
return FormatFloat('0.000E+00', 23224);
// 输出字符串："2.322E+04"
return FormatFloat('##,###.00', 123);
// 输出字符串："123.00"
return FormatFloat('00,000.00', 123);
// 输出字符串："00,123.00"
```
参考SetFormatLocalCode GetFormatLocalCode
####### StrToCurrDef
用途：将字符串转换为对应类型。
参数：
返回：转换后的数值或日期。
范例
```tsl
return StrToCurrDef('1321.233', 3);
// 输出:1321.233
```
参考IntToHex StrToInt StrToBool IntToStr StrToIntDef TryStrToInt StrToBoolDef
TryStrToBool BoolToStr FloatToStr CurrToStr StrToFloat StrToFloatDef
TryStrToFloat StrToCurr TryStrToCurr SetFormatLocalCode GetFormatLocalCode
####### Booltostr2
范例
```tsl
return booltostr2(2 > 1); // 返回’ True’
```
####### StrToFloatDef
用途：将字符串转换为对应类型。
参数：
返回：转换后的数值或日期。
范例
```tsl
return StrToFloatDef('a', 2);
// 输出:2
```
参考IntToHex StrToInt StrToBool IntToStr StrToIntDef TryStrToInt StrToBoolDef
TryStrToBool BoolToStr FloatToStr CurrToStr StrToFloat TryStrToFloat StrToCurr
StrToCurrDef TryStrToCurr SetFormatLocalCode GetFormatLocalCode
####### Tostring
####### IntToHex
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return IntToHex(43, 1);
// 输出: 2B(二进制时候为：101011)
```
参考StrToInt StrToBool IntToStr StrToIntDef TryStrToInt StrToBoolDef
TryStrToBool BoolToStr FloatToStr CurrToStr StrToFloat StrToFloatDef
TryStrToFloat StrToCurr StrToCurrDef TryStrToCurr
####### TryStrToInt
用途：字符串相关函数。
参数：
返回：字符串。
范例
范例01：转换成功
```tsl
ret := TryStrToInt("12", value);
if ret then return value;
else return "转换失败！";
// 输出: 12
```
范例02：转换失败
```tsl
ret := TryStrToInt("test", value);
if ret then return value;
else return "转换失败！";
// 输出: "转换失败！"
```
范例03：十六进制格式字符串的转换
```tsl
ret := TryStrToInt("0x12", value);
if ret then return value;
else return "转换失败！";
// 输出：18
```
参考IntToHex StrToInt StrToBool IntToStr StrToIntDef StrToBoolDef TryStrToBool
BoolToStr FloatToStr CurrToStr StrToFloat StrToFloatDef TryStrToFloat StrToCurr
StrToCurrDef TryStrToCurr
####### FloatToStr
用途：将输入值转换为字符串。
参数：
返回：字符串。
范例
```tsl
return FloatToStr(23.4);
// 输出字符串："23.4"
```
参考IntToHex StrToInt StrToBool IntToStr StrToIntDef TryStrToInt StrToBoolDef
TryStrToBool BoolToStr CurrToStr StrToFloat StrToFloatDef TryStrToFloat
StrToCurr StrToCurrDef TryStrToCurr SetFormatLocalCode GetFormatLocalCode
####### TryStrToFloat
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
TryStrToFloat('321.23', s);
return s; // 输出：321.23
```
参考IntToHex StrToInt StrToBool IntToStr StrToIntDef TryStrToInt StrToBoolDef
TryStrToBool BoolToStr FloatToStr CurrToStr StrToFloat StrToFloatDef StrToCurr
StrToCurrDef TryStrToCurr SetFormatLocalCode GetFormatLocalCode
####### FormatCurr
用途：按指定格式输出结果。
参数：
返回：字符串。
范例
```tsl
return FormatCurr('0.000E+00', 232.24);
// 输出:2.322E+02
```
参考SetFormatLocalCode GetFormatLocalCode
####### TryStrToCurr
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
TryStrToCurr('1321.2333', s);
return s;
// 输出：1321.2333
```
参考IntToHex StrToInt StrToBool IntToStr StrToIntDef TryStrToInt StrToBoolDef
TryStrToBool BoolToStr FloatToStr CurrToStr StrToFloat StrToFloatDef
TryStrToFloat StrToCurr StrToCurrDef SetFormatLocalCode GetFormatLocalCode
####### StrToInt
用途：将字符串转换为对应类型。
参数：
返回：转换后的数值或日期。
范例
范例一：
```tsl
return StrToInt("12");
// 输出: 12
```
范例二：支持16进制字符串的转换
```tsl
return StrToInt("0xC");
// 输出: 12
```
参考StrToInt IntToHex StrToBool IntToStr StrToIntDef TryStrToInt StrToBoolDef
TryStrToBool BoolToStr FloatToStr CurrToStr StrToFloat StrToFloatDef
TryStrToFloat StrToCurr StrToCurrDef TryStrToCurr
####### BoolToStr
用途：将输入值转换为字符串。
参数：
返回：字符串。
范例
```tsl
return BoolToStr(1 > 2, 0);
// 输出：0
```
参考IntToHex StrToInt StrToBool IntToStr StrToIntDef TryStrToInt StrToBoolDef
TryStrToBool FloatToStr CurrToStr StrToFloat StrToFloatDef TryStrToFloat
StrToCurr StrToCurrDef TryStrToCurr
####### CurrToStr
用途：将输入值转换为字符串。
参数：
返回：字符串。
范例
```tsl
return CurrToStr(23.24);
// 输出字符串："23.24"
```
参考IntToHex StrToInt StrToBool IntToStr StrToIntDef TryStrToInt StrToBoolDef
TryStrToBool BoolToStr FloatToStr StrToFloat StrToFloatDef TryStrToFloat
StrToCurr StrToCurrDef TryStrToCurr SetFormatLocalCode GetFormatLocalCode
####### TryStrToBool
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
TryStrToBool("12", s);
return s; // 输出: 1
```
参考IntToHex StrToInt StrToBool IntToStr StrToIntDef TryStrToInt StrToBoolDef
BoolToStr FloatToStr CurrToStr StrToFloat StrToFloatDef TryStrToFloat StrToCurr
StrToCurrDef TryStrToCurr
####### SpaceByNumber
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return write('---', SpaceByNumber(2), '---');
```
运行信息打印结果：
####### IsValidIdent
用途：判断条件是否成立。
参数：
返回：布尔值。
范例
```tsl
return IsValidIdent('a0ffh2');
// 输出: 1
```
####### StrToBool
用途：将字符串转换为对应类型。
参数：
返回：转换后的数值或日期。
范例
```tsl
return StrToBool("12"); // 输出: 1
return StrToBool("0"); // 输出: 0
```
参考IntToHex StrToInt IntToStr StrToIntDef TryStrToInt StrToBoolDef TryStrToBool
BoolToStr FloatToStr CurrToStr StrToFloat StrToFloatDef TryStrToFloat StrToCurr
StrToCurrDef TryStrToCurr
####### StrToFloat
用途：将字符串转换为对应类型。
参数：
返回：转换后的数值或日期。
范例
```tsl
return StrToFloat('3434.244');
// 输出实数:3434.24
```
参考IntToHex StrToInt StrToBool IntToStr StrToIntDef TryStrToInt StrToBoolDef
TryStrToBool BoolToStr FloatToStr CurrToStr StrToFloatDef TryStrToFloat
StrToCurr StrToCurrDef TryStrToCurr SetFormatLocalCode GetFormatLocalCode
####### StrToBoolDef
用途：将字符串转换为对应类型。
参数：
返回：转换后的数值或日期。
范例
```tsl
return StrToBoolDef("12", 3);
// 输出: 1
```
参考IntToHex StrToInt StrToBool IntToStr StrToIntDef TryStrToInt TryStrToBool
BoolToStr FloatToStr CurrToStr StrToFloat StrToFloatDef TryStrToFloat StrToCurr
StrToCurrDef TryStrToCurr
####### IntToStr
用途：将输入值转换为字符串。
参数：
返回：字符串。
范例
```tsl
return IntToStr(43);
// 输出："43"
```
参考IntToHex StrToInt StrToBool StrToIntDef TryStrToInt StrToBoolDef
TryStrToBool BoolToStr FloatToStr CurrToStr StrToFloat StrToFloatDef
TryStrToFloat StrToCurr StrToCurrDef TryStrToCurr
####### StrToCurr
用途：将字符串转换为对应类型。
参数：
返回：转换后的数值或日期。
范例
```tsl
return StrToCurr('1321.23333');
// 输出实数:1321.2333
```
参考IntToHex StrToInt StrToBool IntToStr StrToIntDef TryStrToInt StrToBoolDef
TryStrToBool BoolToStr FloatToStr CurrToStr StrToFloat StrToFloatDef
TryStrToFloat StrToCurrDef TryStrToCurr SetFormatLocalCode GetFormatLocalCode
####### AnsiStr2Array
范例
```tsl
r := ansiStr2Array("和顺电气退和顺电气", "退"); // 以中文分隔
return r; // 输出：array("和顺电气","和顺电气")
```
参考str2array
####### TryUppercase
用途：进行大小写转换。
参数：
返回：字符串。
范例
```tsl
return TryUppercase("abc");
// 结果:"ABC"
```
####### TryLowercase
范例
```tsl
return TryUppercase("ABC");
// 结果:"abc"
```
####### SysEncodecryptStr
范例
```tsl
s := "Server=127.0.0.1;Database=tsBase;Uid=TinySoft;Pwd=admin;";
encodeS := sysencodecryptstr(s, 0);
return encodeS;
```
返回字符串：\_ENCODE_3A364432572518291B2C02321C2C0233084C2D59385A3B482D10641755344722194C25417C28412F56056A0C78431364003D5C38553C5269
####### Letters
范例
```tsl
return letters(1, 0);
// 结果：a
```
####### DecToInt64
用途：字符串相关函数。
参数：
返回：字符串。
范例
范例01：
```tsl
return DecToInt64("12"); // 输出: 12L
```
范例02：十六进制格式字符串的转换
```tsl
return DecToInt64("0x12"); // 报错
return StrToInt64("0x12"); // 输出：18L
```
####### DecToInt64def
范例
范例01
```tsl
return DecToInt64Def("12", 1); // 输出: 12L
return DecToInt64Def("test", 1); // 输出: 1L
```
范例02：十六进制格式字符串的转换
```tsl
return DecToInt64Def("0x12", 1); // 输出: 1L
return StrToInt64Def("0x12", 1); // 输出：18L
```
####### TryDecToInt64
用途：字符串相关函数。
参数：
返回：字符串。
范例
范例01：转换成功
```tsl
ret := TryDecToInt64("12", value);
if ret then return value;
else return "转换失败！";
// 输出: 12L
```
范例02：转换失败
```tsl
ret := TryDecToInt64("test", value);
if ret then return value;
else return "转换失败！";
// 输出: "转换失败！"
```
范例03：十六进制格式字符串的转换
```tsl
ret := TryDecToInt64("0x12", value);
if ret then return value;
else return "转换失败！";
// 输出: "转换失败！"
ret := TryStrToInt64("0x12", value);
if ret then return value;
else return "转换失败！";
// 输出：18L
```
####### DecToInt32
用途：字符串相关函数。
参数：
返回：字符串。
范例
范例01
```tsl
return DecToInt32("12"); // 输出: 12
```
范例02：十六进制格式字符串的转换
```tsl
return DecToInt32("0x12"); // 报错
return StrToInt32("0x12"); // 输出：18
```
####### DecToInt32def
范例
范例01
```tsl
return DecToInt32Def("12", 1); // 输出: 12
return DecToInt32Def("test", 1); // 输出: 1
```
范例02：十六进制格式字符串的转换
```tsl
return DecToInt32Def("0x12", 1); // 输出: 1
return StrToInt32Def("0x12", 1); // 输出：18
```
####### TryDecToInt32
用途：字符串相关函数。
参数：
返回：字符串。
范例
范例01：转换成功
```tsl
ret := TryDecToInt32("12", value);
if ret then return value;
else return "转换失败！";
// 输出: 12
```
范例02：转换失败
```tsl
ret := TryDecToInt32("test", value);
if ret then return value;
else return "转换失败！";
// 输出: "转换失败！"
```
范例03：十六进制格式字符串的转换
```tsl
ret := TryDecToInt32("0x12", value);
if ret then return value;
else return "转换失败！";
// 输出: "转换失败！"
ret := TryStrToInt32("0x12", value);
if ret then return value;
else return "转换失败！";
// 输出：18
```
####### StrToInt64
用途：将字符串转换为对应类型。
参数：
返回：转换后的数值或日期。
范例
范例01：
```tsl
return StrToInt64("12"); // 输出: 12L
```
范例02：十六进制格式字符串的转换
```tsl
return StrToInt64("0x12"); // 输出：18L
```
####### StrToInt64Def
用途：将字符串转换为对应类型。
参数：
返回：转换后的数值或日期。
范例
范例01
```tsl
return StrToInt64Def("12", 1); // 输出: 12L
return StrToInt64Def("test", 1); // 输出: 1L
```
范例02：十六进制格式字符串的转换
```tsl
return StrToInt64Def("0x12", 1); // 输出：18L
```
####### TryStrToInt64
用途：字符串相关函数。
参数：
返回：字符串。
范例
范例01：转换成功
```tsl
ret := TryStrToInt64("12", value);
if ret then return value;
else return "转换失败！";
// 输出: 12L
```
范例02：转换失败
```tsl
ret := TryStrToInt64("test", value);
if ret then return value;
else return "转换失败！";
// 输出: "转换失败！"
```
范例03：十六进制格式字符串的转换
```tsl
ret := TryStrToInt64("0x12", value);
if ret then return value;
else return "转换失败！";
// 输出：18L
```
####### StrToInt32
用途：将字符串转换为对应类型。
参数：
返回：转换后的数值或日期。
范例
范例01：
```tsl
return StrToInt32("12"); // 输出: 12
```
范例02：十六进制格式字符串的转换
```tsl
return StrToInt32("0x12"); // 输出：18
```
####### StrToInt32Def
用途：将字符串转换为对应类型。
参数：
返回：转换后的数值或日期。
范例
范例01
```tsl
return StrToInt32Def("12", 1); // 输出: 12
return StrToInt32Def("test", 1); // 输出: 1
```
范例02：十六进制格式字符串的转换
```tsl
return StrToInt32Def("0x12", 1); // 输出：18
```
####### TryStrToInt32
用途：字符串相关函数。
参数：
返回：字符串。
范例
范例01：转换成功
```tsl
ret := TryStrToInt32("12", value);
if ret then return value;
else return "转换失败！";
// 输出: 12
```
范例02：转换失败
```tsl
ret := TryStrToInt32("test", value);
if ret then return value;
else return "转换失败！";
// 输出: "转换失败！"
```
范例03：十六进制格式字符串的转换
```tsl
ret := TryStrToInt32("0x12", value);
if ret then return value;
else return "转换失败！";
// 输出：18
```
####### DecToInt
用途：字符串相关函数。
参数：
返回：字符串。
范例
范例01
```tsl
return DecToInt("12"); // 输出: 12
```
范例02：十六进制格式字符串的转换
```tsl
return DecToInt("0x12"); // 报错
return StrToInt("0x12"); // 输出：18
```
####### DecToIntDef
用途：字符串相关函数。
参数：
返回：字符串。
范例
范例01
```tsl
return DecToIntDef("12", 1); // 输出: 12
return DecToIntDef("test", 1); // 输出: 1
```
范例02：十六进制格式字符串的转换
```tsl
return DecToIntDef("0x12", 1); // 输出: 1
return StrToIntDef("0x12", 1); // 输出：18
```
####### TryDecToInt
用途：字符串相关函数。
参数：
返回：字符串。
范例
范例01：转换成功
```tsl
ret := TryDecToInt("12", value);
if ret then return value;
else return "转换失败！";
// 输出: 12
```
范例02：转换失败
```tsl
ret := TryDecToInt("test", value);
if ret then return value;
else return "转换失败！";
// 输出: "转换失败！"
```
范例03：十六进制格式字符串的转换
```tsl
ret := TryDecToInt("0x12", value);
if ret then return value;
else return "转换失败！";
// 输出: "转换失败！"
ret := TryStrToInt("0x12", value);
if ret then return value;
else return "转换失败！";
// 输出：18
```
###### 判定函数
####### 内容
- AnsiContainsText
- AnsiStartsText
- AnsiEndsText
- AnsiMatchText
- AnsiContainsStr
- AnsiStartsStr
- AnsiEndsStr
- AnsiMatchStr
- FormatStrExt
####### AnsiContainsText
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
text := 'abcdefg';
return AnsiContainsText(text, 'Abcd');
// 输出：1，包含
```
参考AnsiContainsStr
####### AnsiStartsText
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
text := 'abcdefg';
return AnsiStartsText('Abc', text);
// 输出：1
```
参考AnsiStartsStr
差异说明对于空字符串，windows系统中判定为1，Linux中判定为0。其它表现无差别。
如：return AnsiStartsText("","A"); //windows中返回1，而Linux中返回0。
####### AnsiEndsText
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
text := 'abcdefg';
return AnsiEndsText('Efg', text);
// 输出:1
```
参考AnsiEndsStr
差异说明对于空字符串，windows系统中判定为1，Linux中判定为0。其它表现无差别。
如：return AnsiEndsText("","A"); //windows中返回1，而Linux中返回0。
####### AnsiMatchText
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
AText := 'ABZ';
AValues := array();
AValues[0] := 'abcdefg';
AValues[1] := 'abz';
return AnsiMatchText(AText, AValues);
// 输出：1
// ab不能完全匹配Avalues数组中的值
return AnsiMatchText('ab', AValues);
// 输出：0
```
参考AnsiMatchStr
####### AnsiContainsStr
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
AText := 'abcdefg';
return AnsiContainsStr(AText, 'Bcd');
// 输出：1
```
参考AnsiContainsText
####### AnsiStartsStr
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
Atext := 'abcdefg';
return AnsiStartsStr('abcd', Atext);
// 输出：1
```
参考AnsiStartsText
####### AnsiEndsStr
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
text := 'abcdefg';
return AnsiEndsStr('efg', text);
// 输出:1
```
参考AnsiEndsText
####### AnsiMatchStr
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
AText := 'ABZ';
AValues := array();
AValues[0] := 'abcdefg';
AValues[1] := 'abz';
return AnsiMatchStr(AText, AValues);
// 输出：0 ，大小写敏感
```
参考AnsiEndsText
####### FormatStrExt
用途：按指定格式输出结果。
参数：
返回：字符串。
范例
```tsl
return FormatStrExt('aaaaa');
// 结果：’aaaaa’
return FormatStrExt(123);
// 结果：’-’
```
###### 替换以及处理函数
####### 内容
- StuffString
- AnsiReplaceText
- AnsiReplaceStr
- ReplaceText
- ReplaceStr
- WrapText
- AdjustLineBreaks
- ReverseString
- SeprateStrToTotal
- TotalStrToSeprate
- DateStrToArr
- RdateStrToArr
####### StuffString
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
Atext := "Here will be instead by \'HERE\'";
ASubText := "HERE";
return StuffString(Atext, 1, 4, ASubText);
// 输出：HERE will be instead by ‘HERE’
```
####### AnsiReplaceText
用途：进行字符串提取或替换处理。
参数：
返回：字符串。
范例
```tsl
AText := "First will be instead by \'Final\'";
AFromText := "First";
AToText := "FINAL";
return AnsiReplaceText(AText, AFromText, AToText);
// 输出字符串：FINALwill be instead by 'Final'
```
输出：Final will be instead by F参考AnsiReplaceStr
####### AnsiReplaceStr
用途：进行字符串提取或替换处理。
参数：
返回：字符串。
范例
```tsl
AText := "Big will be replaced by \'BIG\', but big won\'t be replaced by \'BIG\'.";
AFromText := "Big";
AToText := "BIG";
return AnsiReplaceStr(AText, AFromText, AToText);
// 输出：BIG will be replaced by 'BIG', but big won't be replaced by 'BIG'.
```
参考AnsiReplaceText
####### ReplaceText
用途：进行字符串提取或替换处理。
参数：
返回：字符串。
范例
```tsl
AText := "The first letter will be replaced by \'one\', but the second letter won't.";
AFromText := "letter";
AToText := "one";
return ReplaceText(AText, AFromText, AToText);
// 输出：The first one will be replaced by 'one', but the second one won't.n
```
####### ReplaceStr
用途：进行字符串提取或替换处理。
参数：
返回：字符串。
范例
```tsl
AText := "The First LETTER in uppercase won\'t be replaced by \'one\', but the Second letter in lowercase will.";
AFromText := "letter";
AToText := "one";
return ReplaceStr(AText, AFromText, AToText);
// 输出：The First LETTER in uppercase won't be replaced by 'one', but the Second one in lowercase will.
```
####### WrapText
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
ConstLine := "Separate this sentence to two lines.";
return WrapText(ConstLine, 20);
{输出：
(自动换行时考虑字词的完整性）
Separate this
sentence to two
lines.
}
```
####### AdjustLineBreaks
用途：字符串相关函数。
参数：
返回：字符串。
范例
范例01：调整字符串的换行模式
```tsl
r := AdjustLineBreaks("Tinysoft \r\n Statistical \r\nanalysis Language", 1);
return r;
{输出字符串：
Tinysoft
Statistical
analysis Language
}
```
范例02：数组中的应用-批量操作
```tsl
r := adjustlinebreaks(array("Tinysoft \n Statistical \nanalysis Language", "aa\r\nbb"), 1);
return r;
```
输出结果：字符串中的换行符统一转换成\r\n
####### ReverseString
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return ReverseString('abcde1234');
// 返回字符串：4321edcba
```
ho tostn(r);//输出："Tinysoft\n Statistical \nanalysis Language"
####### SeprateStrToTotal
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return SeprateStrToTotal('债券型;现金型;配置型;股票型;保本型');
// 结果：’债券型#现金型#配置型#股票型#保本型’
```
####### TotalStrToSeprate
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return TotalStrToSeprate ('债券型#现金型#配置型#股票型#保本型');
// 结果：’债券型;现金型;配置型;股票型;保本型’
```
####### DateStrToArr
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
return DateStrToArr('2007-9-10;2007-9-10', '$', ';'); // '$'表示结束位置
```
####### RdateStrToArr
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
return RDateStrToArr('20070331;20070630');
```
###### 字符串数组相关函数
####### 内容
- AnsiIndexText
- AnsiIndexStr
####### AnsiIndexText
用途：字符串相关函数。
参数：
返回：整数。
范例
```tsl
egStr := "ansiIndexText";
strArr := array("Tinysoft", "Statistical", "analysis", "Language", "ansiIndexText");
result := ansiIndexText(egStr, strArr);
return result;
// 4
```
参考AnsiIndexStr
####### AnsiIndexStr
用途：字符串相关函数。
参数：
返回：整数。
范例
```tsl
// 大小写敏感，没有找到相应的字符串，返回-1
egStr := "ansiIndexstr";
strArr := array("Tinysoft", "Statistical", "analysis", "Language", "ansiIndexStr");
result := ansiIndexStr(egStr, strArr);
return result;
// 输出：-1
```
参考AnsiIndexText
###### 重复函数
####### 内容
- DupeString
####### DupeString
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
S := DupeString('Ha', 5);
return s;
// 输出：表示将S的值变为'HaHaHaHaHa'
```
###### 多字节语言支持函数
####### 内容
- LengthW
- MidStr
####### LengthW
用途：字符串相关函数。
参数：
返回：整数。
范例
```tsl
testStr := "Tinysoft lengthW:汉字当成一个字符";
return lengthW(testStr);
// 输出：25（包括空格和:）
```
参考LeftStr RightStr MidStr
####### MidStr
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
testStr := "Tinysoft midStr:支持多字节语言，汉字当成一个字符";
return midStr(testStr, 10, 30);
// 输出字符串：“midStr:支持多字节语言，汉字当成一个字符”
```
参考LeftStr RightStr LengthW
###### 字节函数
字节函数，处理非MBCS的原始字符串，本身存在非B或者ANSI版本。
####### 内容
- ContainsText
- StartsText
- EndsText
- ContainsStr
- StartsStr
- EndsStr
- StuffbString
- ReversebString
####### ContainsText
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
a := L'2020Tinysoft 天软';
b := L'tinysoft';
return ContainsText(a, b); // 返回1，包含
```
####### StartsText
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
text := 'abcdefg';
return StartsText('Abc', text);
// 输出：1
```
差异说明对于空字符串，windows系统中判定为1，Linux中判定为0。其它表现无差别。
如：return StartsText("","A"); //windows中返回1，而Linux中返回0。
####### EndsText
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
text := 'abcdefg';
return EndsText('Efg', text);
// 输出:1
```
差异说明对于空字符串，windows系统中判定为1，Linux中判定为0。其它表现无差别。
如：return EndsText("","A"); //windows中返回1，而Linux中返回0。
####### ContainsStr
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
a := '2020Tinysoft 天软';
b := 'tinysoft';
c := 'Tinysoft';
return array(ContainsStr(a, b), ContainsStr(a, c));
// 输出：array(0,1)
```
####### StartsStr
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
Atext := 'abcdefg';
return StartsStr('abcd', Atext);
// 输出：1
```
####### EndsStr
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
text := 'abcdefg';
return EndsStr('efg', text);
// 输出:1
```
####### StuffbString
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
Atext := "Here will be instead by \'HERE\'";
ASubText := "HERE";
return StuffbString(Atext, 1, 4, ASubText);
// 输出：HERE will be instead by ‘HERE’
```
####### ReversebString
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
a := L'2020Tinysoft 天软'; // 宽字节字符串的表达方式
return ReversebString(a);
// 返回字符串：软天 tfosyniT0202
```
###### 发音相关函数
####### 内容
- SoundEx
- SoundexInt
- DecodeSoundexInt
- SoundexWord
- DecodeSoundexWord
- SoundexSimilar
- SoundexCompare
- SoundexProc
- AnsiResemblesText
####### SoundEx
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
testStr1 := "sun";
s1 := SoundEx(testStr1, 4);
testStr2 := "sum";
s2 := SoundEx(testStr2, 4);
testStr3 := "test";
s3 := SoundEx(testStr3, 4);
return array(s1, s2, s3);
// 输出：array("S500","S500","T230")
```
####### SoundexInt
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
testStr1 := "sun";
s1 := SoundexInt(testStr1, 4);
testStr2 := "sum";
s2 := SoundexInt(testStr2, 4);
testStr3 := "test";
s3 := SoundexInt(testStr3, 4);
return array(s1, s2, s3);
// 输出：array(208597,208597,218929)
```
参考DecodeSoundexInt
####### DecodeSoundexInt
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
testStr := "Tinysoft SoundexInt:返回表示AText的发音的整数";
testStr := DecodeSoundexInt(SoundexInt(testStr, 4));
return testStr;
// T521
```
参考SoundexInt
####### SoundexWord
范例
```tsl
testStr := "Tinysoft SoundexInt:返回表示AText的发音的整数";
testStr := soundexWord(SoundEx(testStr, 4));
return testStr;
// 24206
```
参考DecodeSoundexWord
####### DecodeSoundexWord
范例
```tsl
testStr := "Tinysoft SoundexInt:返回表示AText的发音的整数";
testStr := decodesoundexWord(soundexWord(SoundEx(testStr, 4))); // 24206
return testStr;
// T000
```
参考SoundexWord
####### SoundexSimilar
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return SoundexSimilar("sun", "sum");
// 输出：1
return SoundexSimilar("sun", "fun");
// 输出：0
return SoundexSimilar("return ", "result");
// 输出：0
```
####### SoundexCompare
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return SoundexCompare("sun", "sum");
// 输出：0
return SoundexCompare("sun", "fun");
// 输出：1
return SoundexCompare("result", "return ");
// 输出：-1
```
####### SoundexProc
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return SoundexProc("sun", "sum");
// 输出：1
return SoundexProc("sun", "fun");
// 输出：0
return SoundexProc("transaction", "transact");
// 输出：1
```
####### AnsiResemblesText
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return AnsiResemblesText("sun", "sum");
// 输出：1
return AnsiResemblesText("sun", "fun");
// 输出：0
return AnsiResemblesText("transaction", "transact");
// 输出：1
```
###### 正则表达式函数
####### 内容
- ParseRegExpr
- ParseRegExpr：替换功能
- GetLikeFlag
- SetLikeFlag
- ReplaceStrByReg
- ReplaceTextByReg
- ParseRegExpr3
####### ParseRegExpr
范例
范例01：匹配数字、指定字符串
```tsl
source := "ParseRegExpr 2011 ShenZhenTinysoft (TSL)";
ParseRegExpr("(\\d+).*(Tinysoft)", source, "", result, MPos, Mlen);
return result;
// 输出：array(("2011 ShenZhenTinysoft","2011","Tinysoft"))
```
说明：
结果中返回匹配的源串"2011 ShenZhenTinysoft"以及匹配出来的串"2011"和"Tinysoft"
1、在匹配串中加中括号()是表示将匹配的结果返回，下面的例子中，要返回的匹配串的内容是(\\d+)和(tinysoft)匹配出来的结果。
2、\本身就是转义字符，所以要用\\d来表示\d是一个元字符（表示匹配一个数字字符）。\\d+表示匹配多个数字字符。
3、.表示匹配任意单个字符，除'\n'外。.*表示匹配任意多个单个字符。由于.*没有中括号()，所以匹配的字符不返回。
4、(Tinysoft)匹配字符串Tinysoft，并将匹配的字符返回。注意，字符大小写敏感。
范例02：匹配数字、字符串、带括号的字符串
```tsl
source := "ParseRegExpr 2011 ShenZhenTinysoft (TSL)";
ParseRegExpr("(\\d+).*(Tinysoft) (\\(\\w+\\))", source, "", result, MPos, Mlen);
return result;
// 输出：array(("2011 ShenZhenTinysoft (TSL)","2011","Tinysoft","(TSL)"))
```
说明：
与范例01相比，新增了对()的匹配。
结果中返回匹配的源串"2011 ShenZhenTinysoft
(TSL)"以及匹配出来的串"2011"、"Tinysoft"和"(TSL)"。
1、\\(和\\)是对中括号()的匹配。
2、\\w表示\w是一个元字符，匹配包括下划线的任何单词字符。\\w+表示匹配多个任意单词字符。
范例03：处理Unicode串-匹配汉字
```tsl
source := L"hello 你好！123"; // unicode串
reg := L"[\u4E00-\u9FA5]+"; // 匹配汉字的正则表达式->也是unicode串
ret := ParseRegExpr(reg, source, "", result, MPos, Mlen);
return result;
```
返回结果：array((L"你好"))
范例04：通过控制符"u"设置为非贪婪模式
```tsl
source := "hello tiny tiny tiny tiny tiny";
reg := "hello.*(tiny)";
ret := ParseRegExpr(reg, source, "u", result, MPos, Mlen);
return result;
```
返回：array(("hello tiny","tiny"))
####### ParseRegExpr：替换功能
范例
范例三：求值宏
```tsl
// 求值宏，将数字后的字母替换到数字前
source := "ddd2011a uuuu 2012b zzzz 2013c xxx";
ParseRegExpr("(\\d+)(\\w+)", source, "r", "$2$1", s );
return s;
```
ddda2011 uuuu b2012 zzzz c2013 xxx
范例四：回调函数
```tsl
// 回调函数，替换匹配串第1位+匹配串+匹配串第二位
Source := "ParseRegExpr 2011 ShenZhenTinysoft (TSL)";
ParseRegExpr("(\\d+).*(Tinysoft)", source, "r", function(a) begin return a[1] + a[0] + a[2];end, s);
return s;
```
参考正则表达式
####### GetLikeFlag
范例
```tsl
s := "ParseRegExpr 2011 \r\n ShenZhenTinysoft (TSL)";
reg := "(\\d+).*(tinysoft)";
SetLikeFlag(0b0001 + 0x0010); // 大小写无关+使 '.' 特殊字符匹配任意字符
r := s like reg;
return getlikeflag(); // 获取当前正则控制符状态
// 返回17
```
####### SetLikeFlag
范例
```tsl
s := "ParseRegExpr 2011 \r\n ShenZhenTinysoft (TSL)";
reg := "(\\d+).*(tinysoft)";
SetLikeFlag(0b0001 + 0x0010); // 大小写无关+使 '.' 特殊字符匹配任意字符
return s like reg;
```
返回：1
####### ReplaceStrByReg
用途：进行字符串提取或替换处理。
参数：
返回：字符串。
范例
```tsl
return ReplaceStrByReg("abcdeak", "A", "kkkk");
// 结果：abcdeak
```
####### ReplaceTextByReg
用途：进行字符串提取或替换处理。
参数：
返回：字符串。
范例
```tsl
return ReplaceTextByReg("abcdeak", "a", "kkkk");
// 结果：kkkkbcdekkkkk
```
####### ParseRegExpr3
用途：解析输入并返回结果。
参数：
返回：字符串。
范例
```tsl
return ParseRegExpr3("abcdeak", "ab", "kkkk", "ir");
// 结果：kkkkcdeak
```
###### 正则表达式
####### 内容
- 什么是正则表达式
- 正则表达式基础
- 正则表达式中的元字符
####### 什么是正则表达式
一个正则表达式，就是用某种模式去匹配一类字符串的一个公式。很多人因为它们看上去比较古怪而且复杂所以不敢去使用，不过，经过学习之后这些复杂的表达式其实相当简单，而且，一旦弄懂了，你就能把难处理而且容易出错的文本处理工作压缩在几分钟（甚至几秒钟）内完成。正则表达式被各种语言、编辑工具、脚本工具广泛的支持，TSL语言也支持它。
但是，由于正则表达式本身缺少一个规范，因此，各个系统对正则表达式的实现也不同，TSL语言中采用了PERL兼容的正则表达式。
####### 正则表达式基础
正则表达式由一些普通字符和一些元字符组成。普通字符包括大小写的字母和数字，而元字符则具有特殊的含义，我们下面会给予解释。
在最简单的情况下，一个正则表达式看上去就是一个普通的查找串。例如，正则表达式"testing"中没有包含任何元字符，，它可以匹配"testing"和"123testing"等字符串，但是不能匹配"Testing"。
####### 正则表达式中的元字符
要想真正的用好正则表达式，正确的理解元字符是最重要的事情。下表列出了所有的元字符和对它们的一个简短的描述。
注：由于TSL语言的字符串常量中\本身就是转义字符，因此，只要牵涉到\的，就要用\\来描述，因而象\s的TSL常量表述则为’\\s’。
| 字符 | 描述 |
| ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| \ | 将下一个字符标记为一个特殊字符、或一个原义字符、或一个后向引用、或一个八进制转义符。例如，'n' 匹配字符 "n"。'\n' 匹配一个换行符。序列 '\' 匹配 "" 而 "\(" 则匹配 "("。 |
| ^ | 匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 '\n' 或 '\r' 之后的位置。 |
| $ | 匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 '\n' 或 '\r' 之前的位置。 |
| \* | 匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。 *
等价于{0,}。 |
| + | 匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。 |
| | 匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。? 等价于 {0,1}。 |
| {n} | n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。 |
| {n,} | n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o\*'。 |
| {n,m} | m 和 n 均为非负整数，其中n <=
m。最少匹配 n 次且最多匹配 m 次。如："o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。 |
| | 当该字符紧跟在任何一个其他限制符 (\*, +, ?, {n}, {n,},
{n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 "oooo"，'o+?' 将匹配单个 "o"，而 'o+' 将匹配所有 'o'。 |
| . | 匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。 |
| (pattern) | 匹配pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到。要匹配圆括号字符，请使用 '\(' 或 '\)'。 |
| (?:pattern) | 匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 "或" 字符 (\|) 来组合一个模式的各个部分是很有用。例如， 'industr(?:y\|ies) 就是一个比 'industry\|industries' 更简略的表达式。 |
| (?=pattern) | 正向预查，在任何未来符合匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如， 'Windows
(?=95\|98\|NT\|2000)' 能匹配 "Windows 2000" 中的 "Windows" ，但不能匹配 "Windows
3.1" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。 |
| (?!pattern) | 负向预查，在任何不匹配未来符合匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如'Windows
(?!95\|98\|NT\|2000)' 能匹配 "Windows 3.1" 中的 "Windows"，但不能匹配 "Windows
2000" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始 |
| x\|y | 匹配 x 或 y。例如，'z\|food' 能匹配 "z" 或 "food"。'(z\|f)ood' 则匹配 "zood" 或"food"。 |
| [xyz] | 字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。 |
| [^xyz] | 负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的'p'。 |
| [a-z] | 字符范围。匹配指定范围内的任意字符。例如，'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。 |
| [^a-z] | 负值字符范围。匹配任何不在指定范围内的任意字符。例如，'[^a-z]' 可以匹配任何不在 'a' 到 'z' 范围内的任意字符。 |
| \b | 匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。 |
| \B | 匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。 |
| \cx | 匹配由x指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。 x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。 |
| \d | 匹配一个数字字符。等价于 [0-9]。 |
| \D | 匹配一个非数字字符。等价于 [^0-9]。 |
| \f | 匹配一个换页符。等价于 \x0c和 \cL。 |
| \n | 匹配一个换行符。等价于 \x0a和 \cJ。 |
| \r | 匹配一个回车符。等价于 \x0d 和 \cM。 |
| \s | 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。 |
| \S | 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。 |
| \t | 匹配一个制表符。等价于 \x09 和 \cI。 |
| \v | 匹配一个垂直制表符。等价于 \x0b 和 \cK。 |
| \w | 匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。 |
| \W | 匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。 |
| \xn | 匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如， '\x41' 匹配 "A"。'\x041' 则等价于 '\x04'
& "1"。正则表达式中可以使用ASCII 编码。. |
| \num | 匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，'(.)' 匹配两个连续的相同字符。 |
| \n | 标识一个八进制转义值或一个后向引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为后向引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。 |
| \nm | 标识一个八进制转义值或一个后向引用。如果 \nm 之前至少有is preceded by at least
nm 个获取得子表达式，则 nm 为后向引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的后向引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。 |
| \nml | 如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。 |
| \un | 匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如，\u00A9 匹配版权符号 (?)。 |
###### 多语言支持函数
####### 内容
- NextCharIndex
- AnsiToUTF8
- UTF8ToAnsi
- CharToByteIndex
- ByteToCharLen
- AnsiQuotedStr
- AnsiPos
- AnsiDequotedStr
- CharToByteLen
- CharLength
- ByteToCharIndex
- ByteType
- Booltostrw
- UnicodeESC
- unUnicodeESC2
- UnicodeToMultiByte
- FloattoStrw
- UnicodeESC2
- unUnicodeESCw
- UnicodetoUTF8
- CurrtoStrw
- Inttostrw
- MultibyteToUnicode
- Booltostrw2
- Strw
- Inttohexw
- LCMapString
- MultibytetoUnicodew
- UTF8toUnicode
- Exportjsonstring
- unUnicodeESC2w
- unUnicodeESC
- Ifwstring
- MakeLCID
- Importjsonstring
- ExportJsonStringUTF8
- ExportJSONStringMBCS
####### NextCharIndex
范例
```tsl
// ‘软’的开始字节是3，下一个字符是‘T’，‘T’的开始字节位置是5
S := "天软Tinysoft Statistical analysis Language";
return nextCharIndex(s, 3);
// 返回：5
```
####### AnsiToUTF8
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return AnsiToUTF8('2011 tinysoft天软科技');
// 返回字符串：2011 tinysoft澶╄蒋绉戞妧
```
####### UTF8ToAnsi
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return UTF8ToAnsi ('2011 tinysoft澶╄蒋绉戞妧');
// 返回字符串：2011 tinysoft天软科技
```
####### CharToByteIndex
用途：字符串相关函数。
参数：
返回：整数。
范例
```tsl
// 返回第30字符对应的字节位置
// 其中‘天软’占有4个字节，其余每个字符占1个字节
S := "天软Tinysoft Statistical analysis Language";
return CharToByteIndex(s, 30);
// 返回：32
```
####### ByteToCharLen
用途：字符串相关函数。
参数：
返回：整数。
范例
```tsl
// 指定最多字节为30后，查找S中30个字节中有多少个字符，
// 其中‘天软’占有4个字节，所以30个字节中，S有28个字符。
S := "天软Tinysoft Statistical analysis Language";
b1 := ByteToCharLen(S, 30);
return b1;
// 返回：28
```
####### AnsiQuotedStr
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
S := "天软Tinysoft Statistical analysis Language";
return AnsiQuotedStr(s, "'");
// 返回字符串：'天软Tinysoft Statistical analysis Language'
```
####### AnsiPos
用途：字符串相关函数。
参数：
返回：整数。
范例
```tsl
return AnsiPos("tinysoft", "2011 tinysoft");
// 6
```
####### AnsiDequotedStr
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
S := "'天软Tinysoft Statistical analysis Language'";
return AnsiDequotedStr(s, "'");
// 返回字符串：天软Tinysoft Statistical analysis Language
```
####### CharToByteLen
用途：字符串相关函数。
参数：
返回：整数。
范例
```tsl
// 在S字符串中取30个字符，统计其所占的字节数。
// 其中‘天软’占有4个字节，其余每个字符占1个字节，由此，30个字符占有32个字节
S := "天软Tinysoft Statistical analysis Language";
b1 := CharToByteLen(S, 30);
return b1;
// 返回：32
```
####### CharLength
用途：字符串相关函数。
参数：
返回：整数。
范例
```tsl
// 第2个字符‘软’的字节数
S := "天软Tinysoft Statistical analysis Language";
return CharLength(s, 2);
// 返回：2
```
####### ByteToCharIndex
用途：字符串相关函数。
参数：
返回：整数。
范例
```tsl
// 返回第30字节位置时，是第几个字符位置
// 其中‘天软’占有4个字节，其余每个字符占1个字节
S := "天软Tinysoft Statistical analysis Language";
return ByteToCharIndex(s, 30);
// 返回：28
```
####### ByteType
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
// 单字节字符‘t’
return ByteType("2011 tinysoft", 6);
// 0
// 多字节字符‘天’
return ByteType("2011 tinysoft天软", 14);
// 1
// 多字节字符‘软’，且为最后一个字符
return ByteType("2011 tinysoft天软", 15);
// 2
// 单字节字符‘1’，最后一个字符
return ByteType("2011 ", 4);
// 0
```
####### Booltostrw
范例
```tsl
return booltostrw(2 > 1);
// 返回宽字节字符串：-1
```
####### UnicodeESC
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return echo UnicodeESC('2011 tinysoft天软科技');
// 返回字符串：2011%20tinysoft%u5929%u8F6F%u79D1%u6280
```
####### unUnicodeESC2
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return unUnicodeESC2(%%g 2011 tinysoft\u5929\u8F6F\u79D1\u6280%%g);
// 返回字符串：2011 tinysoft天软科技
// 注：其中\uxxxx编码方式中的\是一个转义字符，所以需要用非转义字符串%%方式进行表达。
```
####### UnicodeToMultiByte
####### FloattoStrw
范例
```tsl
return floattostrw(1234.1234);
// 输出宽字节字符串：“1234.1234”
```
####### UnicodeESC2
范例
```tsl
return UnicodeESC('2011 tinysoft天软科技');
// 返回字符串：2011 tinysoft\u5929\u8F6F\u79D1\u6280
```
####### unUnicodeESCw
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return unUnicodeESCw('2011%20tinysoft%u5929%u8F6F%u79D1%u6280');
// ’ 2011 tinysoft天软科技’
```
####### UnicodetoUTF8
范例
```tsl
return unicodetoutf8(L'2020 Tinysoft 天软科技');
// 返回：2020 Tinysoft 澶╄蒋绉戞妧
```
####### CurrtoStrw
范例
```tsl
return CurrToStrw(23.24);
// 输出字符串："23.24"
```
####### Inttostrw
范例
```tsl
s := inttostrw(2);
return array(ifstring(s), ifwstring(s));
// 返回：array(0,1) 说明返回结果串s为宽字节串，而非多字节字符串。
```
####### MultibyteToUnicode
####### Booltostrw2
范例
```tsl
return booltostrw2(2 > 1);
// 返回宽字节字符串：True
```
####### Strw
范例
```tsl
v := strw(123.123, s);
return s;
// 返回宽字节字符串：1.23123000000000E+0002
```
####### Inttohexw
范例
```tsl
return inttohexw(43, 5);
// 返回宽字符串字符串：0002B
```
####### LCMapString
范例
lcmapstring(s,0x0804,0x2000000);//可以把繁体转换为简体字符集
```tsl
return lcmapstring("亞洲", 0x0804, 0x2000000);
```
返回:亚洲
差异说明由于根据windowsAPI的开发，所以Linux中不支持。
####### MultibytetoUnicodew
范例
```tsl
return multibytetounicodew('2020 Tinysoft 天软科技', 936);
// 返回宽字节字符串：2020 Tinysoft 天软科技 即L’ 2020 Tinysoft 天软科技’
```
####### UTF8toUnicode
范例
```tsl
return UTF8ToUnicode ('2011 tinysoft澶╄蒋绉戞妧');
// 返回双字节字符串：2011 tinysoft天软科技
```
####### Exportjsonstring
范例
范例01：将天软含中文的字符串转化为json串
```tsl
s := stockname('SZ000002'); // 万 科Ａ
return exportjsonstring(s);
// 返回字符串："\u4E07 \u79D1\uFF21"
```
范例02：将数组转化为json串
```tsl
s := array((1, 'a'), ('Tinysoft天软', '天软科技'));
return exportjsonstring(s);
// 返回字符串：[[1,"a"],["Tinysoft\u5929\u8F6F","\u5929\u8F6F\u79D1\u6280"]]
```
####### unUnicodeESC2w
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return unUnicodeESC2w(%%g 2011 tinysoft\u5929\u8F6F\u79D1\u6280%%g);
// 返回宽字节字符串：2011 tinysoft天软科技
// 注：其中\uxxxx编码方式中的\是一个转义字符，所以需要用非转义字符串%%方式进行表达。
```
####### unUnicodeESC
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return unUnicodeESC('2011%20tinysoft%u5929%u8F6F%u79D1%u6280');
// ’ 2011 tinysoft天软科技'‘
```
####### Ifwstring
范例
范例一：
```tsl
// 判断是否为宽字节字符串类型
r1 := IfWString(1);
r2 := IfWString("A");
r3 := IfWString(L"C");
r4 := IfWString(array(1, "A", L"C"));
return array(r1, r2, r3, r4);
// 结果：array(0,0,1,0)
```
范例二：
```tsl
// 对数组第一维度数据进行类型判断
t := array(L"C", 3.56, "A", (1, L"C", 3), nil);
return IfWString(t, -1);
// 结果：array(1,0,0,0,0)
```
范例三：
```tsl
// 对数组中每一数据进行类型判断
t := array(L"C", 3.56, "A", (nan, 2.14, L"C"), nil);
return IfWString(t, 1);
// 结果：array(1,0,0,(0,0,1),0)
```
####### MakeLCID
####### Importjsonstring
范例
范例01：将json串转换成天软字符串
```tsl
json := %%g"\u4E07 \u79D1\uFF21"%%g;
// 注：在上述语句中，原串存在转义字符，需要用到非转义字符串%%表示该字符串，不能用引号进行表示。
return importjsonstring(json);
// 返回字符串：万 科Ａ
```
范例02：将exportjsonstring转化的json串转为天软数据结构
```tsl
s := array((1, 'a'), ('Tinysoft天软', '天软科技'));
json := exportjsonstring(s);
return importjsonstring(json);
// 返回
0
1
1
a
Tinysoft天软
// 天软科技
```
范例03：
```tsl
arr := array(("code":"PFTSDEMO0004", "name":"商品跨期"),
("代码":"PFTSDEMO0003", "name":"债券组合"));
return importJsonString(Utf8toAnsi(exportJsonStringUTF8(arr)));
```
返回
| code | name | 代码 |
| ------------ | -------- | ------------ |
| PFTSDEMO0004 | 商品跨期 | |
| | 债券组合 | PFTSDEMO0003 |
范例04：将大的无符号数字转为int64
```tsl
json := %%g 4611686018427387904 %%g;
return importjsonstring(json);
```
####### ExportJsonStringUTF8
范例
范例01：
```tsl
a := select ['StockID'], ['StockName'], datetostr(['date']) as'date', ['close']
from markettable datekey 20200901T
to 20200902T of'SZ000002'end;
return exportjsonstringutf8(a);
```
返回字符串
[{"StockID":"SZ000002","StockName":"涓
绉戯肌","date":"2020-09-01","close":27.22},{"StockID":"SZ000002","StockName":"涓
绉戯肌","date":"2020-09-02","close":27.52}]
范例02：与python交互中的应用
pythonCode
```tsl
import sys
sys.path.append('C:\Program Files\Tinysoft\Analyse.NET')
import TSLPy3
s := """
a := select ['StockID'], ['StockName'], datetostr(['date']) as'date', ['close']
from markettable datekey 20200901T
to 20200902T of'SZ000002'end;
return exportjsonstringutf8(a);
"""
data := TSLPy3.RemoteExecute(s, {})
print(data[1].decode('utf8'))
```
python中返回：
[{"StockID":"SZ000002","StockName":"万
科Ａ","date":"2020-09-01","close":27.22},{"StockID":"SZ000002","StockName":"万
科Ａ","date":"2020-09-02","close":27.52}]
####### ExportJSONStringMBCS
用途：将字符串或数组序列化为 JSON 字符串，保留中文原码（MBCS），不转义为 \\uXXXX。
参数：
返回：JSON 字符串。
范例
范例01：将天软含中文的字符串转化为json串
```tsl
s := stockname('SZ000002'); // 万 科Ａ
return ExportJSONStringMBCS(s);
// 返回字符串："\"万 科Ａ\""
```
范例02：将数组转化为json串
```tsl
s := array((1, 'a'), ('Tinysoft天软', '天软科技'));
return ExportJSONStringMBCS(s);
// 返回字符串："[[1,\"a\"],[\"Tinysoft天软\",\"天软科技\"]]"
```
###### 文件名以及目录名相关处理函数
文件相关处理函数包括了对文件名、目录以及扩展名等等相关处理函数，以及文件时间以及和TDatetime之间的转换函数。
####### 内容
- ChangeFileExt
- ExtractFilePath
- ExtractFileDir
- ExtractFileDrive
- ExtractFileName
- ExtractFileExt
- ExtractRelativePath
- IsPathDelimiter
- IsDelimiter
- IncludeTrailingPathDelimiter
- IncludeTrailingBackslash
- ExcludeTrailingPathDelimiter
- ExcludeTrailingBackslash
- LastDelimiter
- AnsiCompareFileName
- SameFileName
- AnsiLowerCaseFileName
- AnsiUpperCaseFileName
####### ChangeFileExt
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
// 实际D盘的test.tsl没有改变
return ChangeFileExt("D:\\test.tsl", ".txt");
// D:\test.txt
```
####### ExtractFilePath
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return ExtractFilePath("D:\\Tinysoft\\tslweb\\web\\test.tsl");
// D:\Tinysoft\tslweb\web\
```
####### ExtractFileDir
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return ExtractFileDir("D:\\Tinysoft\\tslweb\\web\\test.tsl");
// D:\Tinysoft\tslweb\web
```
差异说明对于路径的处理，在不同系统中存在差异。如Linux中就没有驱动的概念，因此，在处理带驱动的路径时：
如对于根目录的处理extractfiledir("C:\\abc.txt")，Windows中返回”C:\”而Linux中返回”C:”
####### ExtractFileDrive
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return ExtractFileDrive("D:\\Tinysoft\\tslweb\\web\\test.tsl");
// 输出：D:
```
####### ExtractFileName
用途：字符串相关函数。
参数：
返回：整数。
范例
```tsl
return ExtractFileName("D:\\Tinysoft\\tslweb\\web\\test.tsl");
// 输出：test.tsl
```
####### ExtractFileExt
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return ExtractFileExt("D:\\Tinysoft\\tslweb\\web\\test.tsl");
// 输出：.tsl
```
####### ExtractRelativePath
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return ExtractRelativePath("D:\\test.tsl", "D:\\Tinysoft\\tslweb\\web\\test.tsl");
// 输出：Tinysoft\tslweb\web\test.tsl
```
差异说明由于Linux系统中无盘符概念，所以不支持该功能。
####### IsPathDelimiter
用途：判断条件是否成立。
参数：
返回：布尔值。
范例
```tsl
return IsPathDelimiter("D:\\Tinysoft\\tslweb\\web\\test.tsl", 3);
// 输出：1
```
####### IsDelimiter
用途：判断条件是否成立。
参数：
返回：布尔值。
范例
```tsl
return IsDelimiter("tinysoft", "2011 tinysoft", 6);
// 输出：1
```
####### IncludeTrailingPathDelimiter
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return IncludeTrailingPathDelimiter("D:\\Tinysoft\\tslweb\\web");
// 输出： D:\Tinysoft\tslweb\web\
```
差异说明与路径中存在的路径分割符保持一致，当路径中不存在分割符时，则Windows中默认增加"\"，在Linux中，则默认结路径路径加上”/”结尾。
如在Linux中：return IncludeTrailingPathDelimiter("/Tinysoft");
则返回字符串：/Tinysoft/
####### IncludeTrailingBackslash
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return IncludeTrailingBackslash ("D:\\Tinysoft\\tslweb\\web");
// 输出： D:\Tinysoft\tslweb\web\
```
差异说明与路径中存在的路径分割符保持一致，当路径中不存在分割符时，则Windows中默认增加"\"，在Linux中，则默认结路径路径加上”/”结尾。
如在Linux中：return IncludeTrailingBackslash ("/Tinysoft");
则返回字符串：/Tinysoft/
####### ExcludeTrailingPathDelimiter
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return ExcludeTrailingPathDelimiter("D:\\Tinysoft\\tslweb\\web\\");
// 输出： D:\Tinysoft\tslweb\web
```
####### ExcludeTrailingBackslash
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return ExcludeTrailingBackslash("D:\\Tinysoft\\tslweb\\web\\");
// 输出： D:\Tinysoft\tslweb\web
```
####### LastDelimiter
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return LastDelimiter('\\', "D:\\Tinysoft\\tslweb\\web\\test.tsl");
// 输出：23
```
####### AnsiCompareFileName
用途：字符串相关函数。
参数：
返回：整数。
范例
```tsl
return AnsiCompareFileName('index.tsl', "test.tsl");
// 输出：-11
```
差异说明返回值的绝对值大小无实际意义，在不同操作系统中，其结果也表现不一。
在Linux中，由于文件名会区分大小写，而Windows中文件名不区分大小写，所以对比结果会有差异。
如：
在Windows中：
return AnsiCompareFileName("D:\\test\\file1.txt","D:\\Test\\File1.txt");
结果为0，因为不区分大小写，两文件名一致。
在Linux中：
return AnsiCompareFileName("/tinysoft/file1.txt","/Tinysoft/File1.txt");
结果为32，因为区分大小写，两文件名不相等。
####### SameFileName
用途：字符串相关函数。
参数：
返回：整数。
范例
```tsl
return SameFileName('index.tsl', "test.tsl");
// 输出：0
```
####### AnsiLowerCaseFileName
用途：进行大小写转换。
参数：
返回：整数。
范例
```tsl
return AnsiLowerCaseFileName("TEST.tsl");
// 输出：test.tsl
```
####### AnsiUpperCaseFileName
用途：进行大小写转换。
参数：
返回：整数。
范例
```tsl
return AnsiUpperCaseFileName("test.tsl");
// 输出：TEST.TSL
```
###### 其它
####### 内容
- GetPYStringList
- HztoPY
- DataUnitConversion
####### GetPYStringList
用途：字符串相关函数。
参数：无。
返回：字符串。
范例
```tsl
sl := GetPYStringList();
return sl.values("明");
// 返回：M
```
####### HztoPY
用途：字符串相关函数。
参数：
返回：字符串。
范例
```tsl
return HztoPY("华夏优势"); // HXYS
return HztoPY("华夏盛势"); // HXCS HXSS
```
####### DataUnitConversion
- GetPYStringList
- HztoPY
- DataUnitConversion
##### 数组
###### 内容
- 基本
- 数组下标以及长度相关函数
- 排序函数
- 增删改查
- 数组操作
- 数组取值
- 集合运算
- 统计函数
- 重构函数
- 稀疏矩阵
- 数据比较
- 表格显示
- 数组下标
###### 基本
####### 内容
- FieldCount
- FieldExist
- FieldNames
- FieldName
- IsTable
- MagicSetArray
- NoRecordTable
- MagicGetArray
- RecordExist
- RecordExist2
- RecordExist3
- FieldNamesOfStrSubscript
- StrSubscriptTableToNormal
- FieldCountOfStrSubscript
- argmax
- Argmin
- PasswordGen
####### FieldCount
用途：数组相关函数。
参数：
返回：整数。
范例
```tsl
t1 := array(('a':1, 'b':4), ('a':7, 'b':8), ('a':2, 'b':3));
return FieldCount(t1);
// 结果：2
```
####### FieldExist
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t1 := array(('a':1, 'b':4), ('a':7, 'b':8), ('a':2, 'b':3));
return FieldExist(t1, 'b');
// 结果：1
```
####### FieldNames
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t1 := array(('a':1, 'b':4), ('a':7, 'b':8), ('a':2, 'b':3));return FieldNames(t1);
```
####### FieldName
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t1 := array(('a':1, 'b':4), ('a':7, 'b':8), ('a':2, 'b':3));
return FieldName(t1, 0);
// 结果：’a’
```
####### IsTable
用途：判断条件是否成立。
参数：
返回：布尔值。
范例
```tsl
t1 := array(('a':1, 'b':4), ('a':7, 'b':8), ('a':2, 'b':3));
return IsTable(t1);
// 结果：1
```
####### MagicSetArray
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
范例01：
```tsl
a := array((1, 2, 3), (4, 5, 6));
MagicsetArray(a, 1, 2, 10); // a[1][2] := 10
return a;
```
范例02：
```tsl
a := array((1, 2, 3), (4, 5, 6));
MagicSetArray(a, array(1, 2), "b"); // a[1][2] := "b"
return a;
```
参考MagicGetArray
####### NoRecordTable
用途：数组相关函数。
参数：无。
返回：处理后的结果值。
范例
```tsl
return NoRecordTable();
// 结果：Array()
```
####### MagicGetArray
范例
范例01：
```tsl
a := array((1, 2, 3), (4, 5, 6));
return MagicgetArray(a, 1, 2); // 返回a[1][2]的数据
```
结果：6
范例02：
```tsl
a := array((1, 2, 3), (4, 5, array(3, 4)));
return MagicgetArray(a, array(1, 2)); // 返回a[1][2]的数据
```
参考MagicSetArray
####### RecordExist
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t := array(1, 2, 12, 3, 14);
return RecordExist(t, 12);
// 结果：2
```
####### RecordExist2
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t1 := array(('a':1, 'b':4), ('a':7, 'b':8), ('a':2, 'b':3));
return RecordExist2(t1, 'b', 3);
// 结果：2
```
####### RecordExist3
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t := array(1, 2, 12, 3, 14);
return RecordExist3(t, 3);
// 结果：1
```
####### FieldNamesOfStrSubscript
用途：进行字符串提取或替换处理。
参数：
返回：处理后的结果值。
范例
```tsl
s := `array('a':(1, 2, 3, 4, 5), 'b': (2, 3, 4, 5, 6), 'c': (3, 4, 5, 6, 7), 'd': (4, 5, 6, 7, 8));
return FieldNamesOfStrSubscript(s);
```
返回:
####### StrSubscriptTableToNormal
用途：进行字符串提取或替换处理。
参数：
返回：处理后的结果值。
范例
```tsl
// 把字符串行标变成自然数序列的行标
t := array("a":(1, 2, 3), "b":(4, 5, 6), "c":(7, 8, 9));
return StrSubscriptTableToNormal(t, '序号');
```
把字符串行标
变成自然数序列行标，原行标值放在fn对应的列中:
####### FieldCountOfStrSubscript
用途：进行字符串提取或替换处理。
参数：
返回：整数。
范例
```tsl
s := `array('a':(1, 2, 3, 4, 5), 'b':(2, 3, 4, 5, 6), 'c':(3, 4, 5, 6, 7), 'd':(4, 5, 6, 7, 8));
return FieldCountOfStrSubscript(s);
// 返回：4
```
####### argmax
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
x := array(9, 8, 10);
return argmax(x); // 2
```
####### Argmin
范例
```tsl
x := array(3, 1, 9, 2);
return argmin(x); // 1
```
####### PasswordGen
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
return rdo2 PasswordGen(8, 5, 'ts', 3);
```
返回:
###### 数组下标以及长度相关函数
####### 内容
- GetStrIndexNum
- GetStrIndexs
- GetIntIndexs
- GetAllIndexs
- DeleteIndex
- DeleteField
- Length
####### GetStrIndexNum
用途：数组相关函数。
参数：
返回：整数。
范例
```tsl
arr := array("a1":1, "a2":2, 1:3);
return GetStrIndexNum(arr);
// 输出：2
```
####### GetStrIndexs
用途：数组相关函数。
参数：
返回：整数。
范例
```tsl
arr := array("a1":1, "a2":2, "a3":3);
return GetStrIndexs(arr);
// 输出：array(“a1”,”a2”,”a3”)。
```
参考GetIntIndexs GetAllIndexs
####### GetIntIndexs
范例
```tsl
arr := array(1:"p1", 2:"p2", 3:"p3", "a4":"p4");
return Getintindexs(arr);
// 输出:array(1,2,3)
```
参考GetStrIndexs GetAllIndexs
####### GetAllIndexs
用途：数组相关函数。
参数：
返回：整数。
范例
```tsl
arr := array("p1":1, "p2":2, "p3":3);
return GetAllIndexs(arr); // 输出：array(“p1”,”p2”,”p3”)
```
参考GetStrIndexs GetIntIndexs
####### DeleteIndex
用途：数组相关函数。
参数：
返回：整数。
范例
```tsl
arr := array("p1":1, "p2":2, "p3":3);
result := DeleteIndex(arr, "p2", 1);
return result; // true
return arr;
// array(“p1”:1,”p3”:3)
```
参考DeleteField
####### DeleteField
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
arr := array(("p1":1, "p2":2, "p3":3), ("p1":4, "p2":5, "p3":6));
result := DeleteField(arr, "p2", 1);
return arr; // array(("p1":1,"p3":3), ("p1":4"p3":6))
```
参考DeleteIndex
####### Length
用途：数组相关函数。
参数：
返回：整数。
范例
```tsl
arr := array(("p1":1, "p2":2, "p3":3), ("p1":4, "p2":5, "p3":6));
return length(arr);
// 2
```
###### 排序函数
####### 内容
- RankIt
- RankIt2
- RPSIt
- SortTableByFieldExt
- RankValue
- SortArray
- SortTableByField
- argsort
####### RankIt
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33));
RankIt(t2, 'c', 1);
return t2;
```
####### RankIt2
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33));
RankIt2(t2, 'c', '名次', 1);
return t2;
```
####### RPSIt
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
获得沪深300的成分股，并计算EndT的涨幅，对涨幅排序后返回其排序百分比。
```tsl
Endt := inttodate(20140401);
SetSysParam(PN_Date(), EndT);
stockArr := GetBKByDate('SH000300', EndT);
r := array();
n := 0;
for nI := 0 to length(StockArr) - 1 do
begin
stockID := StockArr[nI];
setsysparam(pn_stock(), StockID);
if not istradeday(EndT) then continue;
r[n]['StockID'] := StockID;
r[n]['StockName'] := StockName(StockID);
r[n]['StockZF'] := stockzf3();
n++;
end;
return RPSIt(r, 'StockZF', 1);
```
部分结果截图：
####### SortTableByFieldExt
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
s := `array('a':(1, 2, 3, 4, 5), 'b':(-2, -3, -4, 5, 6), 'c':(3, 4, 5, 6, 7), 'd':(4, 5, 6, 7, 8));
return SortTableByFieldExt(s, 'b');
```
返回:
####### RankValue
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例取上证50的成分股，获得涨幅之后，对涨幅进行排名
```tsl
stockArr := getbkbydate('SH000016', 20190201T);
s := select ['StockID'] as'代码',
["StockName"] as"名称",
['price'] as'收盘',
stockzf(['date'], ['date']) as'涨幅(%)'
from markettable datekey 20190201T to 20190201T of stockArr end;
RankValue(s, '涨幅(%)');
return s;
```
结果:
####### SortArray
范例
```tsl
arr := array(1, 6, 3);
sortArray(arr);
return arr;
// array(1,3,6)
```
参考SortTableByField
####### SortTableByField
范例
```tsl
arr := array(("p1":1, "p2":2, "p3":3),
("p1":4, "p2":5, "p3":6),
("p1":66, "p2":200, "p3":36),
("p1":30, "p2":500, "p3":40));
sortTableByField(arr, "p1", 1);
// sortdi=1按”p1”正序，sortdi=0反序
return arr;
// 结果如图所示
```
参考SortArray
####### argsort
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
value := array(4, 8, 2, 3, 9);
return argsort(value); // 返回：array(2,3,0,1,4)
```
###### 增删改查
####### 内容
- AppendArray
- SeekPosInArray
- StockAmount
- DeleteNILValueByField
- FilterIn
- FilterNotIn
- IN1
- searchsorted
- argconfirst
- DeleteColumnByField
- Inserttablebyrno
- GetValuesByFieldValue
- Arrayextend
- Arrayinsert
- Frameinsert
####### AppendArray
范例
```tsl
a := array(1, 2, 3);
AppendArray(a, 4);
return a;
```
返回:
####### SeekPosInArray
算法
确定查找范围L=0,H=N-1，计算中项J=(L+H)/2。
若arr[mid]=r或L>=H,则结束查找；否则，向下继续。
若arr[mid]r，说明待查找的元素值只可能在比中项元素小的范围内，则把mid-1的值赋给H，并重新计算mid，转去执行步骤2。范例
```tsl
return SeekPosInArray(4, array(1, 2, 3, 4, 5));
// 返回：3
```
####### StockAmount
范例
```tsl
// 平安银行2011年6月30日流通A股发生变动
SetSysParam(PN_Stock(), 'SZ000001');
t := InfoArray(16); // 股票.股本结构表
r1 := StockAmount(t, 20110630, 0, '变动日', '流通A股'); // Date当天
r2 := StockAmount(t, 20110630, 1, '变动日', '流通A股'); // Date之前
return array(r1, r2);
```
结果：array(3105358672.0,3105358511.0)
####### DeleteNILValueByField
算法对数组T字段fields的值进行遍历，如果检索到nil值，删除该行数据。范例
```tsl
Tdata := array(array('time':1, 'price':7.78), array('time':2));
DeleteNILValueByField(Tdata, 'price');
return tdata;
```
返回:
####### FilterIn
范例
范例01：
```tsl
// 过滤表a中列’a’的值在array(1,2,5)集中的结果
a := array(
("a":0, "b":0, "c":0),
("a":1, "b":0, "c":2),
("a":2, "b":1, "c":4),
("a":3, "b":1, "c":6),
("a":4, "b":2, "c":8),
("a":5, "b":2, "c":10),
("a":6, "b":3, "c":12));
return filterin(a, array(1, 2, 5), 'a');
```
范例02：
```tsl
// 筛选满足过滤集中整行数据的子集
a := array();
for i := 0 to 15 do
begin
a[i]["a"] := i;
a[i]["b"] := i div 2;
a[i]["c"] := i * 2;
end;
return filterin(a, array(("a":2, "b":1, "c":4), ("a":3, "b":1, "c":4)), nil);
```
范例03：
```tsl
// 筛选满足过滤集中指定列数据的子集
a := array();
for i := 0 to 15 do
begin
a[i]["a"] := i;
a[i]["b"] := i div 2;
a[i]["c"] := i * 2;
end;
return filterin(a, array(("a":2, "b":1), ("a":3, "b":1)), array('a', 'b'));
```
范例04：
```tsl
// 返回符合过滤集中指定列数据的行下标
a := array();
for i := 0 to 15 do
begin
a[i]["a"] := i;
a[i]["b"] := i div 2;
a[i]["c"] := i * 2;
end;
return filterin(a, array(("a":2, "b":1), ("a":3, "b":1)), array('a', 'b'), false);
```
范例05：
一维数组的过滤：
```tsl
return FilterIn(array(1, -5, 10, 2, 10, 14, -5), array(2, 3, 10), nil);
```
返回结果：array(10,2,10)
####### FilterNotIn
范例用法同FilterIn
```tsl
a := array();
for i := 0 to 5 do
begin
a[i]["a"] := i;
a[i]["b"] := i div 2;
a[i]["c"] := i * 2;
end;
b := array(1, 3, 5);
c1 := FilterNotIn(a, b, "a"); // 过滤结果
c2 := FilterNotIn(a, b, "a", false); // 过滤仅返回下标
return array(c1, c2);
```
c1结果：
c2结果：
二维数组中，过滤行运算示例：
```tsl
t := array(
("a":0, "b":0, "c":0),
("a":1, "b":0, "c":2),
("a":2, "b":1, "c":4),
("a":2, "b":1, "c":4),
("a":4, "b":2, "c":8),
("a":4, "b":2, "c":8),
("a":6, "b":3, "c":12));
return filternotin(t, array(("a":2, "b":1, "c":4)), nil);
```
返回结果：过滤后保留重复行。
一维数组的过滤：
```tsl
return FilterNotIn(array(1, -5, 10, 2, 10, 14, -5), array(2, 3, 10), nil);
```
返回结果：array(1,-5,14,-5)
####### IN1
范例
```tsl
a := array(1, 2, 3, 4);
return in1(a, 3);
// 结果：1
```
####### searchsorted
范例
```tsl
// 数字插入
v := array(1, 2, 3, 4, 5, 6);
return searchsorted(v, 3.5); // 返回：3
// 字符串插入
v := array("SH600001", "SH600004", "SH600050", "SH600305");
return searchsorted(v, "SH600049"); // 返回：2
```
####### argconfirst
范例
```tsl
// 实数对比
a := 0 - > 9;
return argconfirst(a, 3.5, 1); // 返回：4
// 数组对比
a := array(("a", "A"), ("b", "B"), ("c", "C"), ("d", "D"));
v := array("b", "B");
return argconfirst(a, v, 6); // 返回：1
```
####### DeleteColumnByField
范例
```tsl
t1 := array(('a':1, 'b':4, 'c':9), ('a':7, 'b':8, 'c':5));
return DeleteColumnByField(t1, 'a;b');
```
####### Inserttablebyrno
范例
范例1：
```tsl
// 向一维数组指定位置插入一个字符串’aaa’
t := 43456 - > 43460;
Index := 2;
rData := 'aaa';
return InsertTablebyRno(t, Index, rData);
// 结果：array(43456,43457,"aaa",43458,43459,43460)
```
范例2：
```tsl
// 向一维数组第3行插入多行的数据
t := 44000 - > 44004;
Index := 3;
rData := array('a', 'b', 'c');
return InsertTablebyRno(t, Index, rData);
// 结果：
array(44000, 44001, 44002, "a", "b", "c", 44003, 44004)
```
范例3：
```tsl
// 向二维数组第3行插入多行的数据
t := array(('a':10, 'b':'i', 'c':datetostr(20200319T)),
('a':50, 'b':'i', 'c':datetostr(20200318T)),
('a':60, 'b':'i', 'c':datetostr(20200317T)),
('a':40, 'b':'o', 'c':datetostr(20200316T)),
('a':20, 'b':'o', 'c':datetostr(20200313T)));
Index := 3;
rData := array(('c':0, 'b':44000, 'a':'2020-03-20'));
return InsertTablebyRno(t, Index, rData);
// 结果：
```
范例4：
```tsl
// 向二维数组第1行插入多行的数据
t := array(('a':10, 'b':'i', 'c':datetostr(20200319T)),
('a':50, 'b':'i', 'c':datetostr(20200318T)),
('a':60, 'b':'i', 'c':datetostr(20200317T)),
('a':40, 'b':'o', 'c':datetostr(20200316T)),
('a':20, 'b':'o', 'c':datetostr(20200313T)));
Index := 1;
rData := array(('c':'2020', 'b':'AAA', 'a':44456),
('c':'2020', 'b':'BBB', 'a':44566));
return InsertTablebyRno(t, Index, rData);
// 结果：
```
####### GetValuesByFieldValue
范例
```tsl
t := array(('a':1, 'b':4), ('a':7, 'b':8), ('a':2, 'b':4));
return GetValuesByFieldValue(t, 'b', 4); // 返’b’列值为4的所有记录
```
####### Arrayextend
范例
```tsl
a := Letters(1 - > 6);
return arrayextend(a, 2, array('d', 'e'));
```
返回：array("A","B","d","e","C","D","E","F")
####### Arrayinsert
范例
```tsl
a := Letters(1 - > 6);
return Arrayinsert(a, 2, 3);
```
返回：array("A","B",3,"C","D","E","F")
####### Frameinsert
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
data := load_dataset_iris();
return frameInsert(data, 1, '新列', 0);
```
###### 数组操作
####### 内容
- OutPutTableToCanBeUnderstood
- SeperateTable
- Unitary
- Reverse
- DescartesJoin
- TableVectorizeArray
- DataProcess_MF
- AbnormalData
- QKsplit_Trailing
- QKsplit_Resampling
- WebFormatToRung
- RPSValue
- ZValue
- QKsplit_ToDate
- GroupByFieldValue
- FilterOneDimEx2
- GroupRankIt
- ElementWhere
- Histogram
- FrameGetSubByReg
- Factorize
- GroupPercentrankIt
- SparseMatFill
- ArrayAddGap
- dumies_decode
- GroupTransformByFunc
- Framedrop_duplicates
- Field_ReSortCols
- Framedrop_na
- Framemerge
- Frameqcut
- Frameupdate
- GroupZscoreIt
- get_dummies
- get_dummies2
- framePivot_table
- framecut
- frameMelt
- GroupDemeanIt
- ArrDropDuplicate
####### OutPutTableToCanBeUnderstood
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
return OutPutTableToCanBeUnderstood(array(1, 2, 3));
```
返回:
####### SeperateTable
用途：数组相关函数。
参数：
返回：处理后的结果值。
算法
依据字段SepField排序，若字段不存在则返回空数组。
若分割数大于行数，则每行单独生产一个子表；若分割数小于行数，则按int(行数/分割数)去合并表行数，超出部分单作为一个子表。范例
```tsl
t := `array('a':(1, 2, 3, 4), 'b':(2, 3, 4, 5), 'c':(3, 4, 5, 6), 'd':(4, 5, 6, 7), 'e':(5, 6, 7, 8), 'f':(7, 8, 9, 10));
return SeperateTable(t, 'a', 2);
```
返回:
####### Unitary
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t := `array('a':(1, 2, 3, 4), 'b':(2, 3, 4, 5), 'c':(3, 4, 5, 6), 'd':(4, 5, 6, 7), 'e':(5, 6, 7, 8), 'f':(7, 8, 9, 10));
Unitary(t, 'b', 0, 10);
return t;
```
返回:
####### Reverse
范例
```tsl
// 倒置数组
setsysparam(pn_stock(), "SZ000002");
setsysparam(pn_date(), 20210601t);
arr := nday(10, "date", datetostr(sp_time()), "close", close());
return reverse(arr);
```
####### DescartesJoin
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
return DescartesJoin(1 - > 3, 21 - > 22, 3);
```
####### TableVectorizeArray
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t := ones(10, 3);
s := array(1, 2, 3);
return TableVectorizeArray(t, s, '-');
```
####### DataProcess_MF
用途：数组相关函数。
参数：
返回：处理后的结果值。
算法
四分位法:上边界=中位数+5.2*medianof(abs(yi-中位数))，下边界=中位数-5.2*medianof(abs(yi-中位数))，其中medianof表示求序列中位数。超出上边界的数改为上边界，低于下边界的数改为下边界。
3倍标准差法:上边界=μ+3σ，下边界=μ-3σ，其中u表示均值，σ表示标准差。超出上边界的数改为上边界，低于下边界的数改为下边界。范例
```tsl
t := `array(array(1, 100, 101, 102, 103, 1000), array(2, 200, 201, 202, 203, 2000));
return DataProcess_MF(t, 'median');
```
返回:
####### AbnormalData
用途：数组相关函数。
参数：
返回：处理后的结果值。
算法
中位数法:上边界=中位数+5.2*medianof(abs(yi-中位数))，下边界=中位数-5.2*medianof(abs(yi-中位数))，其中medianof表示求序列中位数。超出上边界的数改为上边界，低于下边界的数改为下边界。
3倍标准差法:上边界=μ+3σ，下边界=μ-3σ，其中u表示均值，σ表示标准差。超出上边界的数改为上边界，低于下边界的数改为下边界。
四分位法:左边界=14位数-1.5*(中位数-14位数)，下边界=34位数+1.5*(34位数-中位数)，。超出右边界的数改为右边界，低于左边界的数改为左边界。
范例
范例01：返回奇异值的位置及处理后的结果。
```tsl
t := array(1, 100, 101, 102, 103, 1000);
AbnormalData(t, "median", r);
return r;
```
返回:
其中，0和5为修改的行，1和1000是对应的原值，93.7和109.3是修改后的值
范例02：对源数据列增加一列奇异值处理后的结果
```tsl
col := 'SH000001';
setsysparam(pn_stock(), col);
setsysparam(pn_date(), 20240930T);
setsysparam(pn_cycle(), cy_day());
days := 100;
// SH000001在20240930最近100天的行情数据中设置三个奇异值
t := Nday(days, '日期', datetostr(sp_time()), col, close());
t[29, col] := 1500;
t[59, col] := 4500;
t[79, col] := 6000;
// 找到数组指定列奇异值，以中位数法为例
tyc := AbnormalData(t[:, col], "median", abn);
t[:, col$"_奇异值处理"] := tyc;
return t;
```
返回结果：增加列"SH000001\_奇异值处理"
####### QKsplit_Trailing
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
return QKsplit_Trailing(20100101T, 20110101T);
```
####### QKsplit_Resampling
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
return QKsplit_Resampling(20100101T, 20110101T, cy_year());
```
####### WebFormatToRung
用途：按指定格式输出结果。
参数：
返回：处理后的结果值。
范例
```tsl
a := array('a':('b':('c':(nil, nan, 3), 'd':2), 'e':nan));
return WebFormatToRung(a); // array("a":("b":("c":("-","-",3),"d":2),"e":"-"))
```
####### RPSValue
用途：数组相关函数。
参数：
返回：处理后的结果值。
算法
指定字段从大到小排序。
RPS=100-100/(数据总数量-1)\*所在行标。范例
```tsl
stockArr := getbkbydate('SH000016', 20190201T);
s := select ['StockID'] as'代码',
["StockName"] as"名称",
['price'] as'收盘',
stockzf(['date'], ['date']) as'涨幅(%)'
from markettable datekey 20190201T to 20190201T of stockArr end;
RPSValue(s, '涨幅(%)');
return s;
```
返回:
####### ZValue
用途：数组相关函数。
参数：
返回：处理后的结果值。
算法
z=(x-μ)/σ;其中z为标准分数；x为某一具体分数，μ为平均数，σ为标准差。范例
```tsl
stockArr := getbkbydate('SH000016', 20190201T);
s := select ['StockID'] as'代码',
["StockName"] as"名称",
['price'] as'收盘',
stockzf(['date'], ['date']) as'涨幅(%)'
from markettable datekey 20190201T to 20190201T of stockArr end;
ZValue(s, '涨幅(%)');
return s
```
返回:
####### QKsplit_ToDate
用途：日期时间处理函数。
参数：
返回：日期或时间值。
范例
```tsl
return QKsplit_ToDate(20220704T);
```
####### GroupByFieldValue
用途：数组相关函数。
参数：
返回：处理后的结果值。
算法
依据字段GroupField值进行排序
划分四个区间，小于等于最小值，最小值到最大值之间的每一个步长区间(包括步长末值)，临近最大值不足一个步长的区间(包括最大值)，大于最大值区间。用FilterTableEx函数来统计指定区间的数量。范例
```tsl
data := select * from tradetable datekey 20180903t to 20180904T of'sz000001'end;
return GroupByFieldValue(data, 'close', 1, 20, 0.1);
```
返回:
####### FilterOneDimEx2
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
s := array(1, 2, 3, 4, 5, 6);
return FilterOneDimEx2(s, 4);
// 返回：4
```
####### GroupRankIt
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
T := array(
("G":1, "V1":1, "V2":11, "V3":21),
("G":0, "V1":2, "V2":12, "V3":22),
("G":1, "V1":3, "V2":13, "V3":23),
("G":0, "V1":4, "V2":14, "V3":24),
("G":1, "V1":5, "V2":15, "V3":25),
("G":0, "V1":6, "V2":16, "V3":26));
return GroupRankIt(T, 'G', 'V1'); // array(1,1,2,2,3,3)
```
####### ElementWhere
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
con := array(1, 0, 1, 1, 1, 0);
x := array(1, 2, 3, 4, 5, 6);
y := array(11, 12, 13, 14, 15, 16);
return ElementWhere(con, x, y); // array(1,12,3,4,5,16)
```
####### Histogram
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
范例一：
```tsl
return Histogram(Randn(0, 1, 1000), array(-3, 0.5) - > 3, '0.00');
```
范例二：
```tsl
data := randn(0, 1, 1000, array('a', 'b'));
return Histogram(data, array(-3, 0.5) - > 3, '0.00');
```
####### FrameGetSubByReg
范例
```tsl
T := array((13:1, "V1":1, "V2":11, 12:21, 'R1w':1),
(13:0, "V1":2, "V2":12, 12:22, 'R1w':1),
(13:1, "V1":3, "V2":13, 12:23, 'R1w':1),
(13:0, "V1":4, "V2":14, 12:24, 'R1w':1),
(13:1, "V1":5, "V2":15, 12:25, 'R1w':1),
(13:0, "V1":6, "V2":16, 12:26, 'R1w':1));
return frameGetSubByReg(T, '1');
```
array(
(21,1,"V1":1,"R1w":1),
(22,0,"V1":2,"R1w":1),
(23,1,"V1":3,"R1w":1),
(24,0,"V1":4,"R1w":1),
(25,1,"V1":5,"R1w":1),
(26,0,"V1":6,"R1w":1))
####### Factorize
范例
```tsl
value := array('a', 'd', 'c', 'a', 'b');
labels := factorize(value, true, -1, uniques);
echo uniques; // array("a","b","c","d")
return labels; // array(0,3,2,0,1);
```
####### GroupPercentrankIt
用途：进行大小写转换。
参数：
返回：处理后的结果值。
范例
```tsl
T := array(("G":1, "V1":1, "V2":11, "V3":21),
("G":0, "V1":2, "V2":12, "V3":22),
("G":1, "V1":3, "V2":13, "V3":23),
("G":0, "V1":4, "V2":14, "V3":24),
("G":1, "V1":5, "V2":15, "V3":25),
("G":0, "V1":6, "V2":16, "V3":26));
return GroupPercentrankIt(T, 'G', 'V1'); // array(0.0,0.0,0.5,0.5,1.0,1.0)
```
####### SparseMatFill
用途：解析输入并返回结果。
参数：
返回：处理后的结果值。
范例
```tsl
a := array((3:4), ('A':2));
SparseMatFill(a, -1);
return a; // array((3:4,"A":-1),(3:-1,"A":2))
```
####### ArrayAddGap
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
a := array('alpha(%)':3);
ArrayAddGap(a, '风险');
a['beta'] := 3;
return a; // array("alpha(%)":3,"-----风险-----":"----------","beta":3)
```
####### dumies_decode
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
data := array(
("申万房地产":1, "申万有色金属":0, "申万银行":0),
("申万房地产":1, "申万有色金属":0, "申万银行":0),
("申万房地产":0, "申万有色金属":1, "申万银行":0),
("申万房地产":0, "申万有色金属":0, "申万银行":1),
("申万房地产":0, "申万有色金属":1, "申万银行":0));
return dumies_decode(data);
// array("申万房地产","申万房地产","申万有色金属","申万银行","申万有色金属")
```
####### GroupTransformByFunc
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
T := array(("G":1, "V1":1, "V2":11, "V3":21),
("G":0, "V1":2, "V2":12, "V3":22),
("G":1, "V1":3, "V2":13, "V3":23),
("G":0, "V1":4, "V2":14, "V3":24),
("G":1, "V1":5, "V2":15, "V3":25),
("G":0, "V1":6, "V2":16, "V3":26));
fp := function (v, g);
begin
return rankof([v], [v]);
end;
return GroupTransformByFunc(T, 'G', 'V1', fp); // array(3,3,2,2,1,1)
```
####### Framedrop_duplicates
范例
```tsl
data := load_dataset_iris();
return frameDrop_duplicates(data, 'Species', 'f', '原下标');
```
####### Field_ReSortCols
范例
范例01
```tsl
data := TSUT_Data_ZSZF();
colpriority := array('截止日':-1, "中证500":100);
return field_resortcols(data, colpriority);
```
####### Framedrop_na
范例
```tsl
data := array((nan, 8), (1, 3, 3));
return frameDrop_Na(data, 1, 0);
```
####### Framemerge
范例
范例1：
```tsl
left := `array('a':3 - > 5, 'b':rand(3));
right := `array('a':1 - > 4, 'b':rand(4), 'c':rand(4) * 10);
return frameMerge(left, right, 'a');
```
范例2
```tsl
// 多字段merge
left := `array('a':3 - > 5, 'b':rand(3));
left[:, 'c'] := left[:, 'a'];
right := `array('a':1 - > 4, 'b':rand(4), 'c':rand(4) * 10);
right[:, 'c'] := right[:, 'a'];
names := array('a', 'c');
return frameMerge(left, right, name, 'lfet', nil, true);
```
范例3
```tsl
// 只更名right
left := `array('a':3 - > 5, 'b':rand(3));
right := `array('a':1 - > 4, 'b':rand(4), 'c':rand(4) * 10);
return frameMerge(left, right, 'a', 'full', array(nil, '_x'));
```
####### Frameqcut
- OutPutTableToCanBeUnderstood
- SeperateTable
- Unitary
- Reverse
- DescartesJoin
- TableVectorizeArray
- AbnormalData
- DataProcess_MF
- ZValue
- RPSValue
- FilterOneDimEx2
- GroupByFieldValue
- WebFormatToRung
- QKsplit_Trailing
- QKsplit_ToDate
- QKsplit_Resampling
- Factorize
- dumies_decode
- SparseMatFill
- ElementWhere
- ArrayAddGap
- GroupPercentrankIt
- GroupRankIt
- GroupTransformByFunc
- FrameGetSubByReg
- Histogram
- Framedrop_duplicates
- Field_ReSortCols
- Framedrop_na
- Framemerge
- Frameqcut
- Frameupdate
- GroupZscoreIt
- get_dummies
- get_dummies2
- framePivot_table
- framecut
- frameMelt
- GroupDemeanIt
- ArrDropDuplicate
####### Frameupdate
范例
```tsl
left := `array('a':3 - > 5, 'b':rand(3));
right := `array('a':1 - > 4, 'b':rand(4), 'c':rand(4) * 10);
return frameUpdate(left, right, 'a');
```
####### GroupZscoreIt
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
T := array(
("G":1, "V1":1, "V2":11, "V3":21),
("G":0, "V1":2, "V2":12, "V3":22),
("G":1, "V1":3, "V2":13, "V3":23),
("G":0, "V1":4, "V2":14, "V3":24),
("G":1, "V1":5, "V2":15, "V3":25),
("G":0, "V1":6, "V2":16, "V3":26));
return GroupZscoreIt(T, 'G', 'V1');?// array(-1.0,-1.0,0.0,0.0,1.0,1.0)
```
####### get_dummies
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
a := array('a', 'b', 'c', 'a', nan, nil);
t := get_dummies(a, uniques);
echo tostn(uniques); // array(NIL,"a","b","c",NAN)
return t;
```
####### get_dummies2
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
b := array("申万房地产", "申万房地产", "申万有色金属", "申万银行", "申万有色金属");
return get_dummies2(b);
```
####### framePivot_table
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
// 指定条件，首列为申万行业，后续列标为日期，按平均值汇总值为涨幅、振幅的的数据透视表数据
stocks := GetBKByDate("SH000010", 20210525t);
begt := 20210515T;
endt := 20210525T;
t := select ['StockID'] as"代码",
["StockName"] as"名称",
datetostr(['date']) as"日期",
["close"] as"收盘价",
spec(specdate(stockzf3(), ['date']), ['StockID']) as"涨幅",
spec(specdate(stockzdf3(), ['date']), ['StockID']) as"振幅",
spec(base(10029), ['StockID']) as"申万行业"
from markettable datekey begt to endt of stocks end;
index := "申万行业";
colunms := "日期";
vals := array("涨幅", "振幅");
aggfunc := "avg";
return framePivot_table(t, index, colunms, vals, aggfunc);
```
####### framecut
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
范例1：
```tsl
a := array(0, 59, 60, 70, 80, 99, 100);
bins := array(60, 80);
return framecut(a, bins, 0);
// array(0,0,1,1,2,2,2)
```
范例2
```tsl
a := array(0, 59, 60, 70, 80, 99, 100);
bins := 5;
return framecut(a, bins, 0);
// array(0,2,3,3,4,4,4)
```
####### frameMelt
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t := array(
('截止日':20210101, 'SH000300':1, 'SH000301':3),
('截止日':20210102, 'SH000300':9, 'SH000301':2),
);
ID_names := array('截止日');
return frameMelt(t, '截止日', nil, '代码', '得分');
```
####### GroupDemeanIt
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
范例1：
```tsl
T :=
array(
("G":1, "V1":1, "V2":11, "V3":21),
("G":0, "V1":2, "V2":12, "V3":22),
("G":1, "V1":3, "V2":13, "V3":23),
("G":0, "V1":4, "V2":14, "V3":24),
("G":1, "V1":5, "V2":15, "V3":25),
("G":0, "V1":6, "V2":16, "V3":26));
return GroupDemeanIt(T, 'G', 'V1'); // array(-2.0,-2.0,0.0,0.0,2.0,2.0)
```
范例2
```tsl
T := array(
("G":1, "V1":1, "V2":11, "V3":21),
("G":0, "V1":2, "V2":12, "V3":22),
("G":1, "V1":3, "V2":13, "V3":23),
("G":0, "V1":4, "V2":14, "V3":24),
("G":1, "V1":5, "V2":15, "V3":25),
("G":0, "V1":6, "V2":16, "V3":26));
return GroupDemeanIt(T, 'G', array('V1', 'V2'));
```
####### ArrDropDuplicate
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
data := array(("A":1, "B":NAN), ("A":1, "B":2), ("A":1, "B":NAN), ("A":1, "B":2));
return ArrDropDuplicate(data);
// 结果：array(("A":1,"B":NAN),("A":1,"B":2))
```
###### 数组取值
####### 内容
- ColumnValue
- GetSubTableByField
- GetTopN
- FilterTableEx
- ColumnValue2
- GetBottomN
- FilterOneDimEx
- GetDistinctValue
- GetMiddleN
- FilterTable
- GetSubField
- GetSubTable
- Arraygetdefault
- Arraysetdefault
- Arraysetdefault2
- Randomchoice
####### ColumnValue
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
s := select ['StockID'] as'代码',
["StockName"] as"名称",
['price'] as'收盘'
from markettable datekey 20190101T to 20190201T of'SZ000001'end;
return ColumnValue(s, '收盘');
```
返回:
####### GetSubTableByField
用途：进行字符串提取或替换处理。
参数：
返回：处理后的结果值。
范例
```tsl
setsysparam(pn_stock(), 'SZ000001');
r := nday(10, 'time', datetostr(sp_time()), 'close', close(), 'open', open(), 'high', high());
return GetSubTableByField(r, 'time;close');
// 功能相当于使用子矩阵取数
return r[:, array('time', 'close')];
```
返回:
####### GetTopN
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33), ('a':3, 'c':33));
return GettopN(t2, 2);
```
####### FilterTableEx
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33));
return FilterTableEx(t2, 'c', 'IN', 13, 30); // 取13<=[ 'c']<=30
```
####### ColumnValue2
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t2 := array(('a':2, 'b':2, 'c':13), ('a':3, 'c':33, 'b':3), ('a':3, 'b':6, 'c':43), ('a':5, 'c':53, 'b':5));
return ColumnValue2(t2, 'a;c');
```
####### GetBottomN
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33), ('a':3, 'c':33));
return GetBottomN(t2, 2);
```
####### FilterOneDimEx
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t := array(1, 2, 12, 3.7, 14);
return FilterOneDimEx(t, 'IN', 2, 7);
```
####### GetDistinctValue
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33), ('a':3, 'c':43), ('a':5, 'c':53));
return GetDistinctValue(t2, 'a');
```
####### GetMiddleN
用途：数组相关函数。
参数：
返回：整数。
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33), ('a':4, 'c':33), ('a':5, 'c':33));
return GetMiddleN(t2, 2, 3);
```
####### FilterTable
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
// 'SZ002664'在20211231时的分红送股数据
setsysparam(pn_stock(), 'SZ002664');
return FilterTable(Infoarray(18), 20211231);
```
####### GetSubField
用途：进行字符串提取或替换处理。
参数：
返回：处理后的结果值。
范例
```tsl
a := array(('a':8, 'b':7), ('a':6, 'b':9));
return GetSubField(a, 'a'); // 从a表中取第’a列’
```
####### GetSubTable
用途：进行字符串提取或替换处理。
参数：
返回：处理后的结果值。
范例
```tsl
a := array((1, 2, 4), (11, 12, 14));
b := array(0, 2);
return GetSubTable(a, b);
```
####### Arraygetdefault
- ColumnValue
- GetSubTableByField
- FilterTableEx
- GetBottomN
- GetMiddleN
- GetTopN
- FilterOneDimEx
- GetDistinctValue
- ColumnValue2
- FilterTable
- GetSubField
- GetSubTable
- Arraygetdefault
- Arraysetdefault
- Arraysetdefault2
- Randomchoice
####### Arraysetdefault
- ColumnValue
- GetSubTableByField
- FilterTableEx
- GetBottomN
- GetMiddleN
- GetTopN
- FilterOneDimEx
- GetDistinctValue
- ColumnValue2
- FilterTable
- GetSubField
- GetSubTable
- Arraygetdefault
- Arraysetdefault
- Arraysetdefault2
- Randomchoice
####### Arraysetdefault2
- ColumnValue
- GetSubTableByField
- FilterTableEx
- GetBottomN
- GetMiddleN
- GetTopN
- FilterOneDimEx
- GetDistinctValue
- ColumnValue2
- FilterTable
- GetSubField
- GetSubTable
- Arraygetdefault
- Arraysetdefault
- Arraysetdefault2
- Randomchoice
####### Randomchoice
- ColumnValue
- GetSubTableByField
- FilterTableEx
- GetBottomN
- GetMiddleN
- GetTopN
- FilterOneDimEx
- GetDistinctValue
- ColumnValue2
- FilterTable
- GetSubField
- GetSubTable
- Arraygetdefault
- Arraysetdefault
- Arraysetdefault2
- Randomchoice
###### 集合运算
####### 内容
- MergeArray
- FilterIntersectionPart
- FilterIntersectionPart2
- DistinctStr
- IntersectionPart
- QuickIntersectionPart
- Frameconcat
####### MergeArray
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t1 := array(('b':12, 'a':1, 'c':13, 'd':'d'));
t2 := array(('a':2, 'b':22, 'c':23, 'e':'ee'));
t3 := array(('a':2, 'b':22, 'd':23, 'e':'ee'));
return MergeArray(t1, t2, t3); // 将数组t1,t2,t3合并
```
####### FilterIntersectionPart
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t1 := array(('a':1, 'b':10, 'c':13), ('a':2, 'b':17, 'c':13));
t2 := array(('a':2, 'b':22, 'c':23), ('a':1, 'b':14, 'c':13), ('a':3, 'b':12, 'c':13));
return FilterIntersectionPart(t1, t2, 'a', 'IN'); // t1 与t2的交集
```
####### FilterIntersectionPart2
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t1 := array(1, 2, 3, 4);
t2 := array(3, 4, 5, 6);
return FilterIntersectionPart2(t1, t2, 'IN'); // t1 与t2的交集
```
####### DistinctStr
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
a := array('w', 'd', 'f', 'd', 'e');
return DistinctStr(a); // 保留不相同的，相同的只保留一个
```
####### IntersectionPart
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t1 := array(1.00, 3.00, 2.00, 9.00, 8.00);
t2 := array(3.00, 0.00, 7.00, 8.00, 1.00, 5.00);
return IntersectionPart(t1, t2);
```
####### QuickIntersectionPart
范例
```tsl
t1 := array(1.00, 3.00, 2.00, 9.00, 8.00);
t2 := array(3.00, 0.00, 7.00, 8.00, 1.00, 5.00);
return IntersectionPart(t1, t2);
```
####### Frameconcat
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
a := ones(3, 3);
b := ones(2, 3);
return frameConCat(array(a, b));
```
###### 统计函数
####### 内容
- GeoMeanByColumn
- SumValueByColumn
- AverageValueByColumn
- PercentValueByField
- MedianByColumn
- VarByColumn
- SumValueByColumn2
- SkewByColumn
- AveDevByColumn
- SumValueByRow2
- MaxValueByColumn
- DevsqByColumn
- KurtByColumn
- SumValueByRow
- HarMeanByColumn
- StatByColumn
- AverageByColumn
- StdevByColumn
- MinValueByColumn
- Describe
- Framecorrel
- Framecov
- Framehhi
- Framelag_zf
- Framepct_change
- Framevaluecounts
- Simpledescribe
####### GeoMeanByColumn
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
t1 := array(('a':1, 'b':4, 'c':9), ('a':7, 'b':5, 'c':5));
return GeoMeanByColumn(t1, 'b');
// 结果：4.47
```
####### SumValueByColumn
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
t1 := array(('a':1, 'b':4, 'c':9), ('a':7, 'b':8, 'c':5));
return SumValueByColumn(t1, 'b');
// 结果：12
```
####### AverageValueByColumn
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33), ('a':3, 'c':43), ('a':5, 'c':53));
return AverageValueByColumn(t2, 'c', 1, 3);
// 结果：43
```
####### PercentValueByField
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33), ('a':3, 'c':43), ('a':5, 'c':53));
return PercentValueByField(t2, 'c', 0.1);
// 结果：19
```
####### MedianByColumn
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33), ('a':3, 'c':43), ('a':5, 'c':53));
return MedianByColumn(t2, 'c');
// 结果：38
```
####### VarByColumn
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33), ('a':3, 'c':43), ('a':5, 'c':53));
return VarByColumn(t2, 'c');
// 结果：291.67
```
####### SumValueByColumn2
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33), ('a':3, 'c':43), ('a':5, 'c':53));
return SumValueByColumn2(t2, 'c', 1, 2);
// 结果：76
```
####### SkewByColumn
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33), ('a':3, 'c':43), ('a':5, 'c':53));
return SkewByColumn(t2, 'c');
// 结果：-0.75
```
####### AveDevByColumn
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33), ('a':3, 'c':43), ('a':5, 'c':53));
return AveDevByColumn(t2, 'c');
// 结果：12.5
```
####### SumValueByRow2
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33), ('a':3, 'c':43), ('a':5, 'c':53));
return SumValueByRow2(t2, 1, 0, 1);
// 结果：36
```
####### MaxValueByColumn
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33), ('a':3, 'c':43), ('a':5, 'c':53));
return MaxValueByColumn(t2, 'c');
// 结果：53
```
####### DevsqByColumn
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t1 := array(('a':1, 'b':4, 'c':9), ('a':7, 'b':5, 'c':5));
return DevsqByColumn(t1, 'b');
// 结果：0.5
```
####### KurtByColumn
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33), ('a':3, 'c':43), ('a':5, 'c':53));
return KurtByColumn(t2, 'c');
// 结果：0.34
```
####### SumValueByRow
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33), ('a':3, 'c':43), ('a':5, 'c':53));
return SumValueByRow(t2, 2);
// 结果：46
```
####### HarMeanByColumn
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
t1 := array(('a':1, 'b':4, 'c':9), ('a':7, 'b':5, 'c':5));
return HarMeanByColumn(t1, 'b');
// 结果：4.44
```
####### StatByColumn
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
s := `array('a':(1, 2, 3, 4, 5), 'b': (-2, -3, -4, 5, 6), 'c': (3, 4, 5, 6, 7), 'd': (4, 5, 6, 7, 8));
return StatByColumn(s, 'a', 'MAX');
// 返回a列最大值:5
```
####### AverageByColumn
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t1 := array(('a':1, 'b':4, 'c':9), ('a':7, 'b':8, 'c':5));
return AverageByColumn(t1, 'b');
// 结果：6
```
####### StdevByColumn
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33), ('a':3, 'c':43), ('a':5, 'c':53));
return StdevByColumn(t2, 'c');
// 结果：17.08
```
####### MinValueByColumn
用途：进行数值统计计算。
参数：
返回：处理后的结果值。
范例
```tsl
t2 := array(('a':2, 'c':13), ('a':3, 'c':33), ('a':3, 'c':43), ('a':5, 'c':53));
return MinValueByColumn(t2, 'c');
// 结果：13
```
####### Describe
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
范例01:
```tsl
load_dataset_iris(data);
return Describe(data);
```
范例02:
```tsl
return Describe(randn(0, 1, 1000), array(0.05, 0.1) - > 0.95);
```
####### Framecorrel
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
data := TSUT_Data_ZSZF()[:, 1:];
return frameCorrel(data);
```
####### Framecov
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
data := TSUT_Data_ZSZF()[:, 1:];
return frameCov(data);
```
####### Framehhi
- SumValueByColumn
- SumValueByColumn2
- SumValueByRow
- SumValueByRow2
- MaxValueByColumn
- MinValueByColumn
- AverageValueByColumn
- AverageByColumn
- HarMeanByColumn
- GeoMeanByColumn
- DevsqByColumn
- KurtByColumn
- MedianByColumn
- SkewByColumn
- StdevByColumn
- VarByColumn
- AveDevByColumn
- PercentValueByField
- StatByColumn
- Describe
- Framecorrel
- Framecov
- Framehhi
- Framelag_zf
- Framepct_change
- Framevaluecounts
- Simpledescribe
####### Framelag_zf
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t := array(10, 5, 8, 2);
return frameLag_ZF(t); // array(INF,-50.0,60.0,-75.0)
return frameLag_ZF(t, -1); // array(-50.0,60.0,-75.0,INF)
```
####### Framepct_change
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t := array(10, 5, 8, 2);
return framePct_change(t); // array(INF,-50.0,60.0,-75.0)
return framePct_change(t, -1); // array(100.0,-37.5,300.0,INF); // 注意此时并不是未来涨幅
```
####### Framevaluecounts
- SumValueByColumn
- SumValueByColumn2
- SumValueByRow
- SumValueByRow2
- MaxValueByColumn
- MinValueByColumn
- AverageValueByColumn
- AverageByColumn
- HarMeanByColumn
- GeoMeanByColumn
- DevsqByColumn
- KurtByColumn
- MedianByColumn
- SkewByColumn
- StdevByColumn
- VarByColumn
- AveDevByColumn
- PercentValueByField
- StatByColumn
- Describe
- Framecorrel
- Framecov
- Framehhi
- Framelag_zf
- Framepct_change
- Framevaluecounts
- Simpledescribe
####### Simpledescribe
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
范例01
```tsl
load_dataset_iris(data);
return SimpleDescribe(data);
```
范例02
```tsl
return SimpleDescribe(randn(0, 1, 1000), array(0.05, 0.1) - > 0.95);
```
###### 重构函数
####### 内容
- NormalTabletoStrSubscript
- RenameField
- Field_AddSuffix
- RenameFieldByFormat
- Field_AddPrefix
- ReIndex
- ReIndexCopy
- Reshape
- Frame_addprefix
- Frame_addsuffix
####### NormalTabletoStrSubscript
用途：将输入值转换为字符串。
参数：
返回：字符串。
范例
```tsl
s := nday(10, 'time', datetostr(sp_time()), 'close', close());
return NormalTabletoStrSubscript(s, 'time');
```
把 time列的数据变为行标
---变为--》
####### RenameField
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t1 := array(('a':1, 'b':4, 'c':9), ('a':7, 'b':8, 'c':5));
return RenameField(t1, 'a', 'aaa'); // 将t1中的字段’a’改为’aaa’
// 结果：1
```
####### Field_AddSuffix
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
// 给随机数组批量加后缀
T := rand(10, 10);
Suffix := "@A";
Ifcopy := true;
return Field_AddSuffix(t, Suffix, Ifcopy);
```
####### RenameFieldByFormat
用途：按指定格式输出结果。
参数：
返回：处理后的结果值。
范例
```tsl
// 给随机数组批量加后缀
T := rand(10, 10);
Suffix := '%s'$"@A";
Ifcopy := true;
return RenameFieldByFormat(t, Suffix, Ifcopy);
```
####### Field_AddPrefix
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
// 给随机数组批量加前缀
T := rand(10, 10);
Suffix := "A";
Ifcopy := true;
return Field_AddPrefix(t, Suffix, Ifcopy);
```
####### ReIndex
用途：数组相关函数。
参数：
返回：整数。
范例
```tsl
// 修改数字列名数组为字符串列名数组，即将0,1,2(自增数字）列名重构为"a","b","c"列名的数组
A := rand(10, 3);
s := array("a", "b", "c");
ReIndex(A, nil, s);
return A;
// 修改数字行标数组为字符串行标数组，即将0,1,2(自增数字）行标重构为"a","b","c"行标的数组
A := rand(3, 3);
s := array("a", "b", "c");
ReIndex(A, s);
return A;
// 通过设置行标为nil进行删除该行记录
A := array("A":0, "B":1, "D":2, "E":3);
ReIndex(A, array("A":"A1", "D":nil));
return A;
// 返回：array("A1":0,"B":1,"E":3);
// 如果我们要对多维数组进行处理
A := rand(10, array("A", "B", "D", "E"); // 初始化一个四列的二维矩阵
ReIndex(A, nil, array("A":"A1", "D":nil));
return A;
// 说明，第2个参数为nil表示对第一维的下标不进行变动，因此我们修改列"A"为"A1",并删除"D"列。
// 利用Reindex做列的交换
A := array(1, 2, 3, 4, 5);
reIndex(A, array(0:4, 4:0));
return A;
// 结果为array(5,2,3,4,1);
```
####### ReIndexCopy
参考ReIndex
范例
实现：将指定列下标转为数组的行下标--可用于快速建立哈希表
```tsl
setsysparam(pn_stock(), "SH000001");
setsysparam(pn_date(), 20240822T);
t := nday(10, 'time', datetostr(sp_time()), 'close', close());
return reindexcopy(t, t[:, "time"]);
```
转化结果：
====》转变为：
####### Reshape
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
// 默认拉伸为一个一维数组
A := Rand(3, 6);
return B := Reshape(A);
// A 是一个4*3的矩阵，拉伸为一个2*6的矩阵
A := array((1, 2, 3), (4, 5, 6), (7, 8, 9), (10, 11, 12));
return Reshape(A, 2, 6);
```
####### Frame_addprefix
- RenameField
- ReIndex
- ReIndexCopy
- Reshape
- NormalTabletoStrSubscript
- RenameFieldByFormat
- Field_AddSuffix
- Field_AddPrefix
- Frame_addprefix
- Frame_addsuffix
####### Frame_addsuffix
- RenameField
- ReIndex
- ReIndexCopy
- Reshape
- NormalTabletoStrSubscript
- RenameFieldByFormat
- Field_AddSuffix
- Field_AddPrefix
- Frame_addprefix
- Frame_addsuffix
###### 稀疏矩阵
####### 内容
- Sparse1
- Sparse2
- Speye
- Sprand1
- Sprand2
- Sprandn1
- Sprandn2
- Sprandsym1
- Sprandsym2
- Sparsefull
- Spones
- Spnnz
- Spnonzeros
- Ifsparse
- Spdiags1
- Spdiags2
- Spdiags3
- Spdiags4
####### Sparse1
范例
```tsl
// 将矩阵S由满矩阵格式转化为稀疏格式
S := array((0, 0, 4, 0, 0),
(0, 1, 0, 0, 0),
(0, 0, 0, 0, 0),
(3, 0, 0, 0, 0),
(0, 0, 0, 0, 5));
return sparse1(S);
```
####### Sparse2
范例
```tsl
// 根据i,j,v三元组生成稀疏格式矩阵
i := array(0, 1, 2, 3);
j := array(3, 1, 4, 2);
v := array(5, 3, 2, 4);
return sparse2(i, j, v, 5, 5);
```
####### Speye
范例
```tsl
// 创建m*m稀疏单位矩阵
A := speye(4);
return A;
```
####### Sprand1
范例
```tsl
// 创建与矩阵S相同结构的稀疏均匀随机矩阵
S := array((0, 0, 3, 0, 0),
(0, 0, 0, 0, 0),
(0, 0, 0, 5, 0),
(0, 2, 0, 0, 0),
(0, 0, 0, 0, 4));
return sprand1(S);
```
####### Sprand2
范例
```tsl
// 创建10*10稀疏均匀随机矩阵
A := sprand2(10, 10, 0.3);
return A;
```
####### Sprandn1
范例
```tsl
// 创建与矩阵S相同结构的稀疏正态随机矩阵
S := array((0, 0, 0, 0, 0),
(0, 0, 0, 5, 0),
(3, 0, 0, 0, 0),
(0, 0, 2, 0, 0),
(0, 0, 0, 0, 4));
return sprandn1(S);
```
####### Sprandn2
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
// 创建10*10稀疏正态随机矩阵
A := sprandn2(10, 10, 0.2);
return A;
```
####### Sprandsym1
范例
```tsl
// 创建与矩阵S相同结构的对称稀疏正态随机矩阵
S := array((6, 1, 0, 14, 0),
(0, 7, 0, 0, 15),
(1, 0, 8, 0, 0),
(0, 2, 0, 9, 0),
(0, 0, 3, 0, 10));
return sprandsym1(S);
```
####### Sprandsym2
范例
```tsl
// 创建10*10对称稀疏正态随机矩阵
A := sprandnsym2(10, 0.2);
return A;
```
####### Sparsefull
范例
```tsl
// 将S由稀疏格式矩阵转化为5*5满矩阵格式
S := array(0:(0:1), 2:(2:3), 3:(3:4));
return sparsefull(S, 5, 5);
```
####### Spones
范例
```tsl
// 将S中非零元素替换为1
S := array(0:(0:1), 2:(2:3), 3:(3:4));
return spones(S, 1);
```
####### Spnnz
范例
```tsl
// 稀疏正态随机矩阵A中非零元素数目
A := Sprandn2(5, 5, 0.2);
return spnnz(A); // 返回4（随机）
```
####### Spnonzeros
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
// 提取稀疏正态随机矩阵A中非零元素
A := Sprandn2(5, 5, 0.2);
return Spnonzeros(A);
```
####### Ifsparse
用途：判断条件是否成立。
参数：
返回：布尔值。
范例
```tsl
// 判断矩阵S是否为稀疏矩阵
S := array(3:2, "B":3);
return ifsparse(S); // 返回0
```
####### Spdiags1
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
// 提取矩阵A中非零对角线
A := array((6, 0, 13, 0, 0),
(0, 7, 0, 14, 0),
(1, 0, 8, 0, 15),
(0, 2, 0, 9, 0),
(0, 0, 3, 0, 10));
return spdiags1(A);
```
####### Spdiags2
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
// 提取矩阵A中第-2,0,2条对角线，按列排列
A := array((6, 0, 13, 0, 0),
(0, 7, 0, 14, 0),
(1, 0, 8, 0, 15),
(0, 2, 0, 9, 0),
(0, 0, 3, 0, 10));
d := array(-2, 0, 2);
return spdiags2(A, d);
```
####### Spdiags3
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
// 将矩阵A中d指定的对角线替换为B中的列
B := array((5, 10, 15),
(4, 9, 14),
(3, 8, 13),
(2, 7, 12),
(1, 6, 11));
d := array(-2, 0, 2);
A := array((6, 0, 13, 0, 0),
(0, 7, 0, 14, 0),
(1, 0, 8, 0, 15),
(0, 2, 0, 9, 0),
(0, 0, 3, 0, 10));
return spdiags3(B, d, A);
```
####### Spdiags4
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
// 根据对角矩阵B创建稀疏带状矩阵
B := array((5, 10, 15),
(4, 9, 14),
(3, 8, 13),
(2, 7, 12),
(1, 6, 11));
d := array(-2, 0, 2);
m := 5;
n := 5;
return spdiags4(B, d, m, n);
```
###### 数据比较
####### 内容
- TwoRDateCompare_M1
- CompareDataOfDifferentDataProvider
####### TwoRDateCompare_M1
用途：日期时间处理函数。
参数：无。
返回：日期或时间值。
范例
```tsl
// 返回板块申万数字媒体机构持股情况及变化
BkName := "申万数字媒体";
RDate := 20220331;
RDate2 := 20210331;
t1 := Stocks_SharesByOrgan_Call(BkName, RDate, -1, 0);
t2 := Stocks_SharesByOrgan_Call(BkName, RDate2, -1, 0);
return TwoRDateCompare_M1(t1, t2, RDate, RDate2, "代码", 0,
FieldCountOfStrSubscript(t1) - 2, true, false);
```
####### CompareDataOfDifferentDataProvider
- TwoRDateCompare_M1
- CompareDataOfDifferentDataProvider
###### 表格显示
####### 内容
- Pivot
- Pivot_table
- Show3DTable
- Show2DTable
- ShowTableByField
- ShowTableByUnit
- ShowTableByInverse
- QuickRecordExist
- RotateTable
- NonIntersectionPart
- FooterValue
- FooterAverage
- FooterSum
- SetRowDefaultValue
- InverseTable
- GetSubTableByKey
- TableSelect
- TableType
- GetSubTableFreeParam
- ExpandTable
####### Pivot
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
// 指定条件，行标为日期，列标为名称，值为收盘价、涨幅、振幅的数据透视表
stocks := array("SZ000001", "SZ000002", "SH600050", "SZ300775");
begt := 20210515T;
endt := 20210525T;
t := select ['StockID'] as"代码",
["StockName"] as"名称",
datetostr(['date']) as"日期",
["close"] as"收盘价",
spec(specdate(stockzf3(), ['date']), ['StockID']) as"涨幅",
spec(specdate(stockzdf3(), ['date']), ['StockID']) as"振幅",
spec(base(10029), ['StockID']) as"申万行业"
from markettable datekey begt to endt of stocks end;
index := "日期";
colunms := "名称";
vals := array("收盘价", "涨幅", "振幅");
return Pivot(t, index, colunms, vals);
```
####### Pivot_table
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
// 指定条件，行标为申万行业，列标为日期，按平均值汇总值为涨幅、振幅的的数据透视表数据
stocks := GetBKByDate("SH000010", 20210525t);
begt := 20210515T;
endt := 20210525T;
t := select ['StockID'] as"代码",
["StockName"] as"名称",
datetostr(['date']) as"日期",
["close"] as"收盘价",
spec(specdate(stockzf3(), ['date']), ['StockID']) as"涨幅",
spec(specdate(stockzdf3(), ['date']), ['StockID']) as"振幅",
spec(base(10029), ['StockID']) as"申万行业"
from markettable datekey begt to endt of stocks end;
index := "申万行业";
colunms := "日期";
vals := array("涨幅", "振幅");
aggfunc := "avg";
return Pivot_table(t, index, colunms, vals, aggfunc);
```
####### Show3DTable
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
// 生成数据表t
t := array(("代码":"SH600006", "名称":"东风汽车", "2004.10-12@主营业务收入":151953.06, "2004.10-12@主营业务利润":30559.66, "2004.10-12@营业费用":10112.75, "2004.10-12@管理费用":10666.36, "2004.10-12@财务费用":-894.46, "2004.10-12@营业利润":10693.23, "2004.10-12@投资收益":-151.01, "2004.10-12@利润总额":9904.7, "2004.10-12@所得税":2413.81, "2004.10-12@净利润":7873.08, "2004.10-12@货币资金":-11664.28, "2004.10-12@短期投资":-5370.7, "2004.7-9@主营业务收入":167855.56, "2004.7-9@主营业务利润":31127.95, "2004.7-9@营业费用":4452.79, "2004.7-9@管理费用":10541.15, "2004.7-9@财务费用":-1013.26, "2004.7-9@营业利润":17162.48, "2004.7-9@投资收益":150.81, "2004.7-9@利润总额":17246.26, "2004.7-9@所得税":2629.5, "2004.7-9@净利润":14574.03, "2004.7-9@货币资金":532.5, "2004.7-9@短期投资":4962.47), ("代码":"SH600007", "名称":"中国国贸", "2004.10-12@主营业务收入":19715.3, "2004.10-12@主营业务利润":10383.2, "2004.10-12@营业费用":238.4, "2004.10-12@管理费用":1422.7, "2004.10-12@财务费用":1304.4, "2004.10-12@营业利润":7417.7, "2004.10-12@投资收益":81.1, "2004.10-12@利润总额":6404.6, "2004.10-12@所得税":2433.4, "2004.10-12@净利润":3971.2, "2004.10-12@货币资金":2964.5, "2004.10-12@短期投资":0.00, "2004.7-9@主营业务收入":17727.7, "2004.7-9@主营业务利润":9989.1, "2004.7-9@营业费用":165.5, "2004.7-9@管理费用":1151.3, "2004.7-9@财务费用":-18.2, "2004.7-9@营业利润":8690.5, "2004.7-9@投资收益":186.2, "2004.7-9@利润总额":9208.6, "2004.7-9@所得税":2977.1, "2004.7-9@净利润":6231.5, "2004.7-9@货币资金":-8101.2, "2004.7-9@短期投资":0.00), ("代码":"SH600004", "名称":"白云机场", "2004.7-9@主营业务收入":37934.65, "2004.7-9@主营业务利润":15725.54, "2004.7-9@营业费用":2623.82, "2004.7-9@管理费用":4662.1, "2004.7-9@财务费用":1789.5, "2004.7-9@营业利润":6650.11, "2004.7-9@投资收益":-15.38, "2004.7-9@利润总额":6685.16, "2004.7-9@所得税":2350.15, "2004.7-9@净利润":4000.51, "2004.7-9@货币资金":-5054.06, "2004.7-9@短期投资":101.00));
return Show3DTable(t, '名称', '代码', 3);
```
返回:
####### Show2DTable
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
// 生成数据表t
t := array(("代码":"SH600006", "名称":"东风汽车", "主营业务收入":151953.06, "主营业务利润":30559.66, "营业费用":10112.75, "管理费用":10666.36, "财务费用":-894.46, "营业利润":10693.23, "投资收益":-151.01, "利润总额":9904.7, "所得税":2413.81, "净利润":7873.08, "货币资金":-11664.28, "短期投资":-5370.7, "主营业务收入":167855.56, "主营业务利润":31127.95, "营业费用":4452.79, "管理费用":10541.15, "财务费用":-1013.26, "营业利润":17162.48, "投资收益":150.81, "利润总额":17246.26, "所得税":2629.5, "净利润":14574.03, "货币资金":532.5, "短期投资":4962.47), ("代码":"SH600007", "名称":"中国国贸", "主营业务收入":19715.3, "主营业务利润":10383.2, "营业费用":238.4, "管理费用":1422.7, "财务费用":1304.4, "营业利润":7417.7, "投资收益":81.1, "利润总额":6404.6, "所得税":2433.4, "净利润":3971.2, "货币资金":2964.5, "短期投资":0.00, "主营业务收入":17727.7, "主营业务利润":9989.1, "营业费用":165.5, "管理费用":1151.3, "财务费用":-18.2, "营业利润":8690.5, "投资收益":186.2, "利润总额":9208.6, "所得税":2977.1, "净利润":6231.5, "货币资金":-8101.2, "短期投资":0.00));
return Show2DTable(t, '名称', '代码', 2);
```
返回:
####### ShowTableByField
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
arr := array((1, 2, 3, 4, 5), (2, 3, 4, 5, 6), (3, 4, 5, 6, 7), (4, 5, 6, 7, 8));
return ShowTableByField(arr, array(1, 2, 3));
```
返回:
####### ShowTableByUnit
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t := `array('a':(1, 2, 3, 4), 'b':(2, 3, 4, 5), 'c':(3, 4, 5, 6), 'd':(4, 5, 6, 7), 'e':(5, 6, 7, 8), 'f':(7, 8, 9, 10));
return ShowTableByUnit(t, ``array('字段a', 'a', '', ''));
```
返回:
####### ShowTableByInverse
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
// 生成数据表t
t := array(("代码":"SH600006", "名称":"东风汽车", "主营业务收入":151953.06, "主营业务利润":30559.66, "营业费用":10112.75, "管理费用":10666.36, "财务费用":-894.46, "营业利润":10693.23, "投资收益":-151.01, "利润总额":9904.7, "所得税":2413.81, "净利润":7873.08, "货币资金":-11664.28, "短期投资":-5370.7, "主营业务收入":167855.56, "主营业务利润":31127.95, "营业费用":4452.79, "管理费用":10541.15, "财务费用":-1013.26, "营业利润":17162.48, "投资收益":150.81, "利润总额":17246.26, "所得税":2629.5, "净利润":14574.03, "货币资金":532.5, "短期投资":4962.47), ("代码":"SH600007", "名称":"中国国贸", "主营业务收入":19715.3, "主营业务利润":10383.2, "营业费用":238.4, "管理费用":1422.7, "财务费用":1304.4, "营业利润":7417.7, "投资收益":81.1, "利润总额":6404.6, "所得税":2433.4, "净利润":3971.2, "货币资金":2964.5, "短期投资":0.00, "主营业务收入":17727.7, "主营业务利润":9989.1, "营业费用":165.5, "管理费用":1151.3, "财务费用":-18.2, "营业利润":8690.5, "投资收益":186.2, "利润总额":9208.6, "所得税":2977.1, "净利润":6231.5, "货币资金":-8101.2, "短期投资":0.00));
return ShowTableByInverse(t, '代码', '', 2);
```
返回:
####### QuickRecordExist
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t := array('a', 'c', 'd');
return QuickRecordExist(t, 'd');
// 结果：2
```
####### RotateTable
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t := array(('a':1, 'b':4), ('a':7, 'b':8), ('a':2, 'b':4));
return RotateTable(t);
```
####### NonIntersectionPart
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t1 := array(('a':1, 'b':4), ('a':7, 'b':8), ('a':2, 'b':3));
t2 := array(('a':1, 'b':1), ('a':7, 'b':8), ('a':5, 'b':5));
return NonIntersectionPart(t1, t2, 'b');
```
####### FooterValue
用途：数组相关函数。
参数：
返回：处理后的结果值。
算法
对起始序号Fromcol、截止序号ToCol限定大小为0到数组t的字段个数，如果Fromcol>ToCol，则将Fromcol与ToCol互换
若type值为0，则计算各列平均值，如果type为1，则对列求和。
AverageColField可以为t数组中列名，如果列名刚好为对应字符串“平均”或“总计”，那么，除AverageColField列外，其他数据按type类型计算，统计数据 存储在最后一行，AverageColField列下对应为“平均”或“总计”字符串。
如果AverageColField为空或指定的列名不为“平均”或“总计”，那么，“平均”或“总计”字符串存放在第一列最后一行，其他列的统计结果存放在最后一行。范例
```tsl
s := array(array(1, 2, 3, 4, 5),
array(2, 3, 4, 5, 6),
array(3, 4, 5, 6, 7));
return FooterValue(s, 1, 3, '', 1);
```
返回:
####### FooterAverage
用途：数组相关函数。
参数：
返回：处理后的结果值。
算法
1、对起始序号Fromcol、截止序号ToCol限定大小为0到数组t的字段个数，
如果Fromcol>ToCol，则将Fromcol与ToCol互换。
2、计算各列平均值
3、AverageColField可以为t数组中列名，如果列名刚好为对应字符串“平均”，那么，除AverageColField列外，其他列计算平均值，平均值存储在最后一行，AverageColField列最后一行值为“平均”。
如果AverageColField为空或指定的列名不为“平均”，那么，“平均”字符串存放在第一列最后一行，其他列的统计结果存放在对应列最后一行。范例
```tsl
s := array(array(1, 2, 3, 4, 5),
array(2, 3, 4, 5, 6),
array(3, 4, 5, 6, 7));
return FooterAverage(s, 1, 3, '');
```
返回:
####### FooterSum
算法
1、对起始序号Fromcol、截止序号ToCol限定大小为0到数组t的字段个数，
如果Fromcol>ToCol，则将Fromcol与ToCol互换。
2、计算各列和
3、AverageColField可以为t数组中列名，如果列名刚好为对应字符串“总计”，那么，除AverageColField列外，其他列数据求和，统计值存储在最后一行，AverageColField列最后一行值为“总计”。
如果AverageColField为空或指定的列名不为“总计”，那么，“总计”字符串存放在第一列最后一行，其他列的统计结果存放在对应列最后一行。范例
```tsl
s := array(array(1, 2, 3, 4, 5),
array(2, 3, 4, 5, 6),
array(3, 4, 5, 6, 7));
return FooterAverage(s, 1, 3, '');
```
返回:
####### SetRowDefaultValue
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
s := array(array(1, 2, 3, 4, 5),
array(2, 3, 4, 5, 6),
array(3, 4, 5, 6));
SetRowDefaultValue(s, 2, 'wo');
return s;
```
返回:
####### InverseTable
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
s := array(array('A':'a', 'B':'b', 'C':'c', 'D':'d', 'e':'e'),
array('A':2, 'B':3, 'C':4, 'D':5, 'e':6),
array('A':3, 'B':4, 'C':5, 'D':6, 'e':7), );
return InverseTable(s);
```
返回:
####### GetSubTableByKey
用途：进行字符串提取或替换处理。
参数：
返回：处理后的结果值。
范例
```tsl
s := array(array('A':'a', 'B':'b', 'C':'c', 'D':'d', 'e':'e'),
array('A':'c', 'B':3, 'C':4, 'D':5, 'e':6),
array('A':3, 'B':4, 'C':5, 'D':6, 'e':7));
return GetSubTableByKey(s, 'A', 'a;c');
```
返回:
####### TableSelect
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
t := `array('a':(1, 2, 3, 4), 'b':(2, 3, 4, 5), 'c':(3, 4, 5, 6), 'd':(4, 5, 6, 7), 'e':(5, 6, 7, 8), 'f':(7, 8, 9, 10));
return TableSelect(t, "~['b']=2", '~'); // 返回t中字段’b’=2的子表
```
返回:
####### TableType
范例
```tsl
s := array(array(1, 2, 3, 4, 5),
array(2, 3, 4, 5, 6),
array(3, 4, 5, 6, 7));
return tabletype(s);
// 返回：0
```
####### GetSubTableFreeParam
用途：进行字符串提取或替换处理。
参数：
返回：处理后的结果值。
范例
```tsl
return GetSubTableFreeParam(); // 之前在系统参数中已经设置好第一个参数s=array(array('s':1,'w':2,'sl':3), array('s':2,'w':3,'sl':4), array('s':3,'w':4,'sl':5)),第二三个参数’s’,’w’。
```
返回:
####### ExpandTable
用途：数组相关函数。
参数：
返回：处理后的结果值。
范例
```tsl
// 按照分红送股列展开数据
data := Query("", "SH600000;SZ000002", true, "", "代码", DefaultStockID(), "名称",
CurrentStockName(), "分红送股", infoarray(18));
return ExpandTable(data, "分红送股");
```
###### 数组下标
####### 内容
- frameIndex_filter
- frameIndex_getilocDZ
####### frameIndex_filter
用途：数组相关函数。
参数：
返回：整数。
范例
范例01
```tsl
// 选择 "回测周期":"因子分类"
allcols :=
array("回测名称", "回测周期", "分组个数", "因子名称", "因子分类", "IC分析@IC均值", "IC分析@ICIR", "IC分析@IC胜率(%)", "回归分析@平均收益(%)", "回归分析@T值", "分组绝对收益（多头）@收益(%)", "分组绝对收益（多头）@波动率(%)", "分组绝对收益（多头）@胜率(%)", "分组相对收益（多头）@收益(%)", "分组相对收益（多头）@波动率(%)", "分组相对收益（多头）@胜率(%)", "分组相对收益（多头）@T值", "分组多空收益@收益(%)", "分组多空收益@波动率(%)", "分组多空收益@胜率(%)", "分组多空收益@T值", "创建人", "因子回测ID", "收藏人数", "是否已收藏");
return frameIndex_filter(allcols, array('回测周期', '因子分类'), 1);
```
范例02
```tsl
// 选择 IC分析 开头的
return frameIndex_filter(allcols, '^IC分析', 3);
```
范例03
```tsl
// 选择 IC分析 开头，或者 因子 开头的
return frameIndex_filter(allcols, array('^IC分析', '^因子'), 3);
```
####### frameIndex_getilocDZ
用途：数组相关函数。
参数：
返回：整数。
范例
```tsl
return frameIndex_getilocDZ(array('成长', '估值', '动量'));
```