Common Template Engine

一. 表达式规则: 模板指南...
(1) 常规中缀表达式规则
(2) 支持Java所有表达式

二. 特殊表达式符号:
1. 括号：() 用于加强优先级
2. 字符串：" ' ` (三种)引号
其中，单双引号使用与Java相似
字符串中转义符反斜线(\)，支持\b, \t, \n, \f, \r, \uXXXX, \", \', \\
与Java不同点：
引号允许多行字符串
忽略不识别的转义字符，如：${"\h"} 输出两个字符：\h
增加反单引号(`)表示不转义串，内容不能包含反单引号本身，通常用于输出Windows地址，如：${`C:\native\user\file.txt`}
注：不建议用表达式输出字面字符串，建议将其直接写在模板内，如：
${"xxx" + var1 + "yyy" + var2} 建议写成 xxx${var1}yyy${var2}
3. 数字：以0-9开头表示数字
以0x开头的为16进制数字，如：0xF5A7
以0开头的整数为8进制数字，如：07
后缀B/b, S/s, I/i, L/l, F/f, D/d，分别表示Byte, Short, Integer, Long, Float, Double
没有后缀的数字，无点号缺省为Integer，有点号缺省为Double
.12 等价于 0.12
E表示10的n次方，也就是科学计数法，如：1.25E3 等于 1250
* 星号代表无穷数，如：${list[2..*]} (注：星号不可以作为一元操作符)
4. 关键字：表示特殊值 (注：不可以作为变量名) 配置...
null 空值
true, false 布尔值
this 代表当前区域
super 代表上级区域
5. 操作符关键字： (注：不可以作为变量名)
new 一元操作符(优先于变量)
6. 区域特殊变量： 扩展...
this.global 代表当前GlobalContext
this.context 代表当前Context
this.root 代表当前RootContext
this.local 代表当前LocalContext
this.template 代表当前Template
this.element 代表当前Element
this.for 代表当前迭代状态
(注：如果模板中没有同名变量，this前缀可省)
super.super 代表上级的上级(可递归)
super.local 代表变量栈的上级LocalContext
super.template 代表包含关系的上级Template，如果当前模板未被其它模板所包含，则为null
super.element 代表上级Element，通常为BlockDirective
super.for 代表上级迭代状态

三. 变量上下文:
页面内的每一个块指令(如$if,$for等)都会创建相应的LocalContext, 变量取值时逐级向上查找,
如果当前LocalContext中的变量与上级变量重名，可以使用super关键字跳到上级取值，如：${super.var}
Web应用中变量查找顺序：页面内, root, model, request, parameter, header, session, cookie, application, global
可以用context["区域名"]在指定范围内查找，如：${context["session"].loginUser}
另外，也可以用context["指令名"]查找最近的某个块指令区域内的变量，如：${context["for"].xxx} ${context["if"].xxx}
赋值也一样，如：$var{session->xxx="xxx"} 或 $var{for->xxx="xxx"}
变量上下文示意图：

变量上下文举例：
$var{name="aaa"}
$if{true}
    $var{name="bbb"}
    $for{1}
        $var{name="ccc"}
        "for" name: ${name}
        "for" super name: ${super.name}
        "for" super super name: ${super.super.name}
        "for" if name: ${context["if"].name}
        "for" root name: ${context["root"].name}
    $end
    "if" name: ${name}
    "if" super name: ${super.name}
$end
"root" name: ${name}
输出结果：
"for" name: ccc
"for" super name: bbb
"for" super super name: aaa
"for" if name: bbb
"for" root name: aaa
"if" name: bbb
"if" super name: aaa
"root" name: aaa

四. 标准操作符: 扩展...
(1) 对象(Object)：
. 点号, 属性取值, 如: ${user.name}
[ ] 方括号, 索引属性, 如: ${user["name"]} ${user[variable]}
new 创建类实例, 如: ${new com.xxx.User(1, "james")} 或 ${new com.xxx.User(id: 1, name: "james")} 或 ${new com.xxx.User()} 或 ${new com.xxx.User}
(注：参数若为List则传入构造函数, 若为Map则调用无参构造函数, 然后调用setXXX()初始化属性)
& 一元与号，包名或类名前缀, 如: ${&com.xxx.AppConstant.PREFIX} 或 ${&com.xxx.AppUtils.calc(xxx)} 等价于 ${"com.xxx.AppUtils".toClass.calc(xxx)}
is 或 instanceof，类型判断，如：${user1 is com.xxx.User} 或 ${user1 instanceof com.xxx.User} (注：建议使用is)
== 值相等比较，名称符eq，如: ${user1 == user2} ${user1 eq user2}(注：相近类型如char与string,int与long等对比时，将自动转换类型)
!= 值不相等比较，名称符ne，如: ${user1 != user2} ${user1 ne user2}
=== 内存地址相等比较，名称符aeq，如: ${user1 === user2} ${user1 aeq user2}
!== 内存地址不相等比较，名称符ane，如: ${user1 !== user2} ${user1 ane user2}
(2) 布尔值(Boolean)：
&& 逻辑与，名称符and, 如: ${user1.agree && user2.agree} ${user1.agree and user2.agree}
|| 逻辑或，名称符or, 如: ${user1.agree || user2.agree} ${user1.agree or user2.agree} $for{user : (users1 || users2 || users3} (注：对非Boolean值对象，将返回非null对象，与JavaScript规则相同)
^ 逻辑异或，名称符xor, 如: ${user1.agree ^ user2.agree} ${user1.agree xor user2.agree}
! 逻辑非, 如: ${! user1.agree}
?: 逻辑选择, 如: ${user1.agree ? "yes" : "no"}
(3) 数字(Number)：
+ 一元加号，正数，如：${3 * +2} ${+user1.coins}
- 一元减号，负数, 如: ${3 * -2} ${-user1.coins}
+ 加法运算, 如: ${user1.coins + 3.2D}
- 减法运算, 如: ${user1.coins - user2.coins}
* 乘法运算, 如: ${user.coins * 2}
/ 除法运算, 如: ${user.coins / 2}
% 求模/求余运算, 如: ${user.coins % 2}
** 求幂次方运算, 如: ${2 ** 2 ** 3}
& 按位与运算，如: ${128 & 2}
| 按位或运算，如: ${128 | 256}
^ 按位异或运算，如: ${128 ^ 2}
~ 按位取反运算，如: ${~128}
>> 按位右移运算，如: ${32 >> 2}
<< 按位左移运算，如: ${128 << 2}
>>> 按位无符号右移运算，如: ${32 >>> 2}
> 数字大于比较，名称符gt, 如: ${user1.coins > user2.coins} ${user1.coins gt user2.coins}
< 数字小于比较，名称符lt, 如: ${user1.coins < user2.coins} ${user1.coins lt user2.coins}
>= 数字大于等于比较，名称符ge, 如: ${user1.coins >= user2.coins} ${user1.coins ge user2.coins}
<= 数字小于等于比较，名称符le, 如: ${user1.coins <= user2.coins} ${user1.coins le user2.coins}
<=> 数字大小全比较，名称符cmp，0表示相等，1表示大于，-1表示小于, 如: ${user1.coins <=> user2.coins} ${user1.coins cmp user2.coins}
~= 数字近似值等于比较(任何数字类型只比较intValue相等), 如: ${user1.coins ~= user2.coins}
# 数字格式化, 如: ${user1.coins # "###,##0.###"}
max 取最大值, 如: ${max(1,5,3)} 输出：5
min 取最小值, 如: ${min(1,5,3)} 输出：1
sum 求和, 如: ${sum(1,5,3)} 输出：9
avg 求平均值, 如: ${avg(1,5,3)} 输出：3
(4) 字符串(String)：
[ ] 方括号，字符索引，如：${"abcdefg"[1..2]} 输出：bc (注：可以将String看成char[]数组)
+ 加号，两个字符串相连, 非字符将调用其toString, 如: ${user.firstname + user.lastname}
- 减号, 过滤字符串, 如: ${"ab.cd.ef" - "."} 输出：abcdef
* 乘号，字符串重复, 如: ${"abc" * 3} 或者 ${3 * "abc"} 输出：abcabcabc
/ 除号, 字符串分割, 并忽略空段, 如：${"aaa.bbb.ccc" / "."} 输出数组：[aaa, bbb, ccc]
% 截余/缩略, 如: ${"abcdefghijklmn" % 10} 输出：abcdefg...
- 一元减号，将String倒序, 如: ${- str}
~ 字符串正则表达式匹配, 如: $if{code ~ "^[0-9]+$"}
!~ 字符串正则表达式不匹配, 如: $if{code !~ "^[0-9]+$"}
> 字符串大于比较, 如: $if{user1.name > user2.name}
< 字符串小于比较, 如: $if{user1.name < user2.name}
>= 字符串大于等于比较, 如: $if{user1.name >= user2.name}
<= 字符串小于等于比较, 如: $if{user1.name <= user2.name}
<=> 字符串大小全比较，0表示相等，1表示大于，-1表示小于, 如: ${user1.name <=> user2.name}
~= 字符串忽略大小写比较，如: ${"aa" ~= "AA"} $if{user1.name ~= user2.name}
(注：以下操作符中，^ 代表开头，$ 代表结尾，* 代表全串匹配，来源于正则表达式)
^= 字符串是否以另一字符串开头，也就是startsWith, 如: ${"abcd" ^= "ab"} $if{user1.name ^= "james"}
$= 字符串是否以另一字符串结尾，也就是endsWith, 如: ${"abcd" $= "cd"} $if{user1.name $= "lee"}
*= 字符串是否包含另一字符串，也就是containsWith, 如: ${"abcd" *= "bc"} $if{user1.name *= "lee"}
^~ (忽略大小写比较)字符串是否以另一字符串开头，也就是startsWith, 如: ${"abcd" ^~ "ab"} $if{user1.name ^~ "james"}
$~ (忽略大小写比较)字符串是否以另一字符串结尾，也就是endsWith, 如: ${"abcd" $~ "cd"} $if{user1.name $~ "lee"}
*~ (忽略大小写比较)字符串是否包含另一字符串，也就是containsWith, 如: ${"abcd" *~ "bc"} $if{user1.name *~ "lee"}
^? 从最前开始匹配子串所在位置，也就是indexOf，如：${"aaa.bbb.ccc" ^? "."} 输出：3
$? 从最后开始匹配子串所在位置，也就是lastIndexOf，如：${"aaa.bbb.ccc" $? "."} 输出：7
*? 整个字符串中匹配子串的个数，如：${"xxxabcxxxabcxxx" *? "abc"} 输出：2
^- 截取前缀，如：${"note.txt" ^- "."} 输出：note
$- 截取后缀，如：${"note.txt" $- "."} 输出：txt
(5) 日期(Date)：
+ 日期年数后推, 如: ${user.registerDate + 3.year} (注：参见数字属性扩展)
- 日期年数前推, 如: ${user.registerDate - 3.year}
> 日期大于比较, 如: ${user1.registerDate > user2.registerDate}
< 日期小于比较, 如: ${user1.registerDate < user2.registerDate}
>= 日期大于等于比较, 如: ${user1.registerDate >= user2.registerDate}
<= 日期小于等于比较, 如: ${user1.registerDate <= user2.registerDate}
<=> 日期大小全比较，0表示相等，1表示大于，-1表示小于, 如: ${user1.registerDate <=> user2.registerDate}
~= 日期忽略时分秒比较, 如: ${user1.registerDate ~= user2.registerDate}
# 日期格式化, 如: ${user.registerDate # "yyyy-MM-dd"}
(6) 集合(Collection)：
[ ] 方括号, 数组或List下标，如: ${list[1]} ${list[1..3]} ${list[1,2,4]} ${string[1..3]}
注：${String[0..2]}会将String看成char[ ]使用，数组或List下标为负数时表示倒数：${list[-1]}，取list的倒数第一个元素
[ ] 方括号, Map索引, 如: ${map["key"]} ${map[keyVar]}，同样可以用${map.key}，但点号优先查getter属性，方括优先查entry键值对，如：${map.size}和${map["size"]}，如果map中有size的entry，则返回结果可能不一样。
[prop:value] 属性索引，List如：${users[name:"james"].coins}将从列表中返回第一个属性"name"值为"james"的user对象，也可以是多个属性${users[name:"james",role:"admin"]}，Map如：${map[value:"james"].key}通过value查key，${map[key:"james"].value}与${map["james"]}等价
=> 推导符号，表示筛选过滤器(lambda表达式)，隐含状态信息index,size,count，index为当前项索引号，size为集合大小，count为已接收数，List缺省变量名为item，如：${list[=> item ~ "[0-9]+" && count < 3]} ${users[u => u.name != 'guest']}，Map缺省变量名为entry，如：${map[=> entry.key != 'xxx' && count < 3]} ${map[x => x.key != 'xxx']}
-> 箭头号, 表示层级名称，左右参数均为名称串，用于需要多个层级名称的指令中，如：$var{global -> user = "james"} $for{menu -> children : menus}
: 冒号，表示键值对(Entry)，如：${name : "james"} ${user.name : "james"}
注：entry采用JSON的设计风格，因为key通常是字符串，而非变量，所以当key为无引号名称时，将会作为字符串处理，而不是变量取值，如果要用变量作为key，在key前加反斜线: ${\name : "james"}，另请注意：${user.name : "james"}会取user.name变量的值作为key, 因为点号先运算.
= 等号，与冒号功能相同，表示键值对(Entry)，但优先级更低(其它操作符均先于它运行)，如：$set{xxx = aa:bb,cc:dd}，可以不需要括号。
.. 双点号, 表示序列(Sequence), 如: ${1..5} $for{num : 1..5} $for{weekDay : "Sunday".."Saturday"}
, 逗号, 表示列表(List), 如: ${1,2,5,7} $for{num : (1,2,5,7)}
(注：序列和列表可以合并使用，如：${1,3..6,9} 输出展开式列表：[1,3,4,5,6,9]，而：${1,(3..6),9} 或者 ${1,[3..6],9} 输出两级列表：[1,[3,4,5,6],9])
:, 冒号加逗号, 表示哈希表(Map), 如: ${a : 1, b: 2, c : 7} $for{rel : (a : 1, b: 2, c : 7)}
[ ] 一元方括号, 转换成集合, 将Object转成List, 将Entry转成Map, 如: $for{num : [100]} $for{num : [name:value]}
注：如果[ ]中已经是List或Map, 则将保持不变, 相当于( ), 如: $for{num : [20,50,100]} $for{num : [name1:value1, name2:value2]}
+ 加号，两个List或Map相连, 如: ${items + ("a","b")}
* 乘号，重复集合内容, 如: ${["a","b"] * 2} 输出：[a, b, a, b]
- 一元减号，将List或Array倒序, 如: ${-items}
~ 判断集合内是否有匹配项，如：$if{state ~ (1, 2, 4)} $if{user1 ~ users}
!~ 判断集合内是否没有匹配项，如：$if{state !~ (1, 2, 4)} $if{user1 !~ users}
orderby 按属性排序，+号升序(可省)，-号降序，如: $for{book : books orderby ("-price","+title","author")}
(7) 系统(System)：
. 一元点号，取系统属性，如：${.now} ${.random} ${.uuid} ${.system.currentTimeMillis} ${.system.properties["user.dir"]} ${.engine.version} ${.engine.released} ${.engine.vendor}

五. 操作符结合律及优先级
结合律：(注：可以用括号改变结合)
优先级高的先结合，
一元操作符之间总是从右到左结合，
同优先级的二元操作符从左到右结合。
优先级：(注：括号的优先级总是最高)
操作符优先级从低到高依次为：
"=>"
"="
".."
","
":"
"?"
"#"
"||"
"&&"
"|"
"^"
"&"
"==", "!=", "~=", "~", "!~", "^=", "$=", "*=", "^~", "$~", "*~"
"<", ">", "<=", ">=", "<=>", "is", "instanceof"
">>", "<<", ">>>"
"orderby"
"^?", "$?", "*?", "^-", "$-"
"+", "-"
"*", "/", "%"
"**"
一元："+", "-", "!", "~", "?"
".", "[ ]", "->"
一元：".", "[ ]", "\", "&", "new", "max", "min", "sum", "avg"
"( )"

六. 对象属性及扩展属性 扩展...
属性调用格式
${对象.属性}
属性查找顺序
以${obj.XXX}为例
(1) 首先查找obj类型的外部扩展属性(可覆盖原有属性) (注：参见下一节)
(2) 再查找obj.getXXX()函数
(3) 再查找obj.isXXX()函数
(4) 再查找obj.XXX()函数
(5) 再查找obj.XXX属性
标准扩展属性
(注：根据上面的规则，没有参数，但有返回值的函数，可以直接作为属性，如：toString, hashCode, trim, toUpperCase, size等，下面不再列出)
(1) 空值(Null):
toString 转为String类型，如：null.toString 返回"null"字符串
null的其它任意属性都返回null，如：null.xxx 返回null
任意对象的null属性都返回null，如：obj.null 返回null
null的null属性也返回null，如：null.null 返回null
(2) 对象(Object/Bean):
toJson 输出JSON格式的字符串表示，如：${user.toJson}, ${map.toJson} (注：需json.jar支持)
toXml 输出XML格式的字符串表示，如：${user.toXml}, ${map.toXml} (注：采用java.beans.XMLEncoder实现)
toXstream 输出Xstream的XML格式的字符串表示，如：${user.toXstream} (注：需xstream.jar支持)
(3) 字符串(String):
capitalize 首字母大写, eg: ${"james".capitalize} (输出：James)
uncapitalize 首字母小写, eg: ${"James".uncapitalize} (输出：james)
md5Code MD5摘要密文, 如: ${"mypassword".md5Code}
shaCode SHA摘要密文, 如: ${"mypassword".shaCode}
base64Code BASE64编码, 如: ${"mail".base64Code}
escapeHtml HTML转码, 将<和>分别转成<和>等, 如: ${"<b>".escapeHtml}
escapeXml XML转码, 如: ${"<book><book>".escapeXml}
escapeXhtml XHTML转码, 如: ${"<book><book>".escapeXhtml}
escapeUrl URL转码, 如: ${"http://xxx.com?xx=xx&yy=yy".escapeUrl}
escapeJs JS转码, 如: ${"\"\n\"".escapeJs}
toCamelNaming 转为骆驼命名, 如：${"user_name".toCamelNaming} 输出：userName
toCapitalNaming 转为大写命名, 如：${"user_name".toCapitalNaming} 输出：UserName
toUnderlineNaming 转为下划线命名, 如：${"userName".toUnderlineNaming} 输出：user_name
toAscii 将Unicode码转为ASCII码表示, 如：${"中国".toAscii} 输出：\u4E2D\u56FD
toUnicode 将ASCII码转为Unicode码表示, 如：${"\u4E2D\u56FD".toUnicode} 输出：中国
toSwapCase 交换大小写, 把串中大写的改小写, 小写的改为大写. 如：${"ABCdef".toSwapCase} 输出：abcDEF (注：与toUpperCase, toLowerCase相对应)
toClass 将字符串转为类元, 如: ${"com.xxx.User".toClass}
newInstance 将字符串转为类实例, 通过无参构造函数创建, 如: ${"com.xxx.User".newInstance}
toDate 以yyyy-MM-dd格式转换为Date, 如: ${"2007-01-01".toDate}
toTime 以HH:mm:ss格式转换为Date, 如: ${"22:10:15".toTime}
toDateTime 以yyyy-MM-dd HH:mm:ss格式转换为Date, 如: ${"2007-01-01 23:10:05".toDateTime}
toBoolean 将字符串转成Boolean类型, 如: ${"true".toBoolean}
toCharacter 转为Character类型, 如: ${"a".toCharacter}
toByte 转为Byte类型, 如: ${"1".toByte + 2}
toShort 转为Short类型, 如: ${"1".toShort + 2}
toInteger 转为Integer类型, 如: ${"1".toInteger + 2}
toLong 转为Long类型, 如: ${"25".toLong + 2}
toFloat 转为Float类型, 如: ${"1.2".toFloat + 2}
toDouble 转为Double类型, 如: ${"2.3".toDouble + 2}
empty 是否为空字符串, 如：${"".empty} 输出：true
whitespace 是否为空白字符串, 如：${" ".whitespace} 输出：true
naming 是否为命名字符串, 如：${"abc".naming} 输出：true
number 是否为数字字符串, 如：${"123".number} 输出：true
fromJson 将Json字符串转换为对象值(Map或List), 如：${"{name:'kent'}".fromJson}
fromXml 将XML字符串转换为对象值, 如：${"<int>1</int>".fromJson}
fromXstream 将Xstream字符串转换为对象值, 如：${"<int>1</int>".fromXstream}
(4) 日期(Date):
year, month, day, hour, minute, second, millisecond 时间各个部分取值, 如: ${createDate.day} ${createDate.hour}
week 星期几，如: ${createDate.week}
dayOfYear 一年中的第多少天, 如: ${createDate.dayOfYear}
weekOfYear 一年中的第几周, 如: ${createDate.weekOfYear}
weekOfMonth 一月中的第几周, 如: ${createDate.weekOfMonth}
era 纪元, 如: ${createDate.era}
century 世纪, 如: ${createDate.century}
timezone 时间参照的时区, 如: ${createDate.timezone}
leap 是否为润年, 如: $if{now.leap}
toDateString 以yyyy-MM-dd格式化日期, 如: ${createDate.toDateString}
toTimeString 以HH:mm:ss格式化日期, 如: ${createDate.toTimeString}
toDateTimeString 以yyyy-MM-dd HH:mm:ss格式化日期, 如: ${createDate.toDateTimeString}
toLong 计算机时间, 即相对于1970-01-01 00:00:00.000的毫秒数, 如: ${createDate.toLong}
(5) 数字(Number):
toDate 以相对于1970-01-01 00:00:00.000的毫秒数转换为Date, 如: ${9999999.toDate}
year, month, week, day, hour, minute, second, millisecond，分别表示转换为年，月，周，日，时，分，秒，毫秒等数字单位，如：${createDate + 3.day}
toByte, toShort, toInteger, toLong, toFloat, toDouble 类型间转换, 如: ${3L.toFloat}
toBoolean 0为false, 非0为true, 如: ${1.toBoolean} 输出：true
toSize 根据大小显示Bytes,KB,MB等单位, 如: ${917.toSize}(输出：917Bytes) ${(11 * 1024).toSize}(输出：11KB)
toChinese 数字转中文, 如: ${123.toChinese} 输出：一百二十三
toChineseCurrency 数字转中文货币, 如: ${123.toChineseCurrency} 输出：壹佰贰拾叁圆整
abs 取绝对值, 如: ${(-10).abs} 输出：10
sign 取符号, 如: ${(-10).sign} 输出：-1
positive 是否为正数(非负数), 如: ${(-10).positive} 输出：false
negative 是否为负数, 如: ${(-10).negative} 输出：true
toBinaryString 十进制整型转为二进制串，如: ${12.toBinaryString} 输出：1100
toOctalString 十进制整型转为八进制串，如: ${12.toOctalString} 输出：14
toHexString 十进制整型转为十六进制串，如: ${12.toHexString} 输出：c
toCeilingInteger 浮点型向上取整，如: ${12.3.toCeilingInteger} 输出：13
toFloorInteger 浮点型向下取整，如: ${12.3.toFloorInteger} 输出：12
(6) 布尔值(Boolean):
not 取反, 如: ${true.not} ${user.allow.not}
toInteger false为0, true为1, 如: ${true.toInteger} 输出：1
(7) 数组(Array):
asList 数组转换为List，如：${arr.asList}
size 数组长度，保持与List统一，如：${arr.size}
sort 数组或List排序，如：${arr.sort} ${list.sort} ${['f','a','d'].sort} (注：集合中的项需实现Comparable接口)

七. 对象函数及扩展函数 扩展...
函数调用格式
${对象.函数(参数1, 参数2)}
(注：不允许调用返回类型为void的函数)
(注：如果是没有参数的函数，建议采用属性方式调用，也就是省略括号，如：${obj.toString}，而不是${obj.toString()})
函数查找顺序
以${obj.XXX(123)}为例
(1) 首先查找obj类型的外部扩展函数(可覆盖原有函数) (注：参见下一节)
(2) 再查找参数类型匹配的函数obj.XXX(Integer)
(3) 再查找参数类型相近的函数obj.XXX(int)
标准扩展函数
(注：根据上面的规则，有返回值的函数，可以直接调用，如：replaceAll, substring, split等，下面不再列出)
(1) 字符串(String):
replace(String, String) 替换，如：${"a-b-c".replace('-', '.')} 输出：a.b.c (注：重载了JRE1.4中String原有replace函数，使其支持字符串替换)
abbreviate(int) 缩略，如：${"abcdefghijk".abbreviate(6)} 输出：abc... (注：参数必需大于3)
abbreviate(int, int) 从偏移位置开始缩略，如：${"abcdefghijk".abbreviate(2, 6)} 输出：cde...
leftPad(int, String) 左填充对齐，如：${"123".leftPad(6, '0')} 输出：000123
leftPad(int) 以空格左填充对齐，如：${"123".leftPad(6)} 输出：□□□123
rightPad(int, String) 右填充对齐，如：${"123".rightPad(6, '-')} 输出：123---
rightPad(int) 以空格右填充对齐，如：${"123".rightPad(6)} 输出：123□□□
newInstance(arg1, arg2) 通过构造函数创建类实例, 如: ${"com.xxx.User".newInstance(12, "james")}
newInstance(prop1 : value1, prop2 : value2) 通过无参构造函数创建类实例, 并通过setXXX注入相应属性值, 如: ${"com.xxx.User".newInstance(id:12, name:"james")}
函数与操作符
函数与操作符部分功能是重叠的，建议采用操作符，如：
${"abcdefgh"[1..2]} 等价于 ${"abcdefgh".substring(1, 3)}
${"ab.cd.ef" / "."} 等价于 ${"ab.cd.ef".split("\\.")}
${"abcdefghijk" % 6} 等价于 ${"abcdefghijk".abbreviate(6)}

八. 序列扩展 扩展...
(1) 数字: ${1 .. 20} ${20 .. -12}
(2) 字母: ${'a' .. 'z'} ${'z' .. 'a'} ${'A' .. 'Z'} ${'b' .. 'k'}
(3) 季度: ${"Spring" .. "Winter"}
(4) 月份: ${"January" .. "December"}
(5) 星期: ${"Sunday" .. "Saturday"}

九. 遗留： (注: 将在1.0版本统一删除)
(1) @ 一元操作符
    起止版本：0.8.3加入，0.8.5废弃
    废弃原因：用动态操作符实现不转义字符串有BUG，并且不希望特殊化@操作符
    替代方案：改用反单引号实现不转义字符串
(3) $ 一元操作符
    起止版本：0.8.3加入，0.8.7废弃
    废弃原因：创建类实例操作符，保持与Java一致，改为"new"，并设为关键字
    替代方案：new