JAVA笔记-表达式引擎aviator

￡神魔★判官ぃ 2021-08-27 18:11 930阅读 0赞

## 简介 ##

Aviator是一个高性能、轻量级的 java 语言实现的表达式求值引擎, 主要用于各种表达式的动态求值。现在已经有很多开源可用的 java 表达式求值引擎,为什么还需要 Avaitor 呢?  
Aviator的设计目标是轻量级和高性能,相比于Groovy、JRuby的笨重, Aviator非常小, 加上依赖包也才450K,不算依赖包的话只有 70K; 当然, Aviator的语法是受限的, 它不是一门完整的语言, 而只是语言的一小部分集合。  
其次, Aviator的实现思路与其他轻量级的求值器很不相同, 其他求值器一般都是通过解释的方式运行, 而Aviator则是直接将表达式编译成Java 字节码, 交给JVM去执行。简单来说, Aviator的定位是介于Groovy这样的重量级脚本语言和IKExpression这样的轻量级表达式引擎 之间。  
Aviator支持大部分运算操作符, 包括算术操作符、关系运算符、逻辑操作符、位运算符、正则匹配操作符(`=~`)、三元表达式(`?:`), 并且支持操作符的优先级和括号强制优先级, 具体请看后面的操作符列表, 支持自定义函数.

## 包依赖 ##

Aviator依赖了`commons-beanutils`, 使用Aviator可以添加下面的maven依赖:

<dependency>
        <groupId>com.googlecode.aviator</groupId>
        <artifactId>aviator</artifactId>
        <version>2.3.3</version>
     </dependency>

## 使用手册 ##

### 执行表达式 ###

Aviator的使用都是集中通过`com.googlecode.aviator.AviatorEvaluator`这个入口类来处理, 最简单的例子, 执行一个计算`1+2+3`的表达式:

import com.googlecode.aviator.AviatorEvaluator;
    public class TestAviator {
        public static void main(String[] args) {
            Long result = (Long) AviatorEvaluator.execute("1+2+3");
            System.out.println(result);
        }
     }

细心的朋友肯定注意到结果是`Long`,而不是`Integer`。这是因为`Aviator`的数值类型仅支持`Long`和`Double`, 任何整数都将转换成`Long`, 任何浮点数都将转换为`Double`, 包括用户传入的变量数值。这个例子的打印结果将是正确答案`6`。

### 使用变量 ###

想让Aviator对你`say hello`吗? 很简单, 传入你的名字, 让Aviator负责字符串的相加:

public class TestAviator {
        public static void main(String[] args) {
            String yourName = "Michael";
            Map<String, Object> env = new HashMap<String, Object>();
            env.put("yourName", yourName);
            String result = (String) AviatorEvaluator.execute(" 'hello ' + yourName ", env);
            System.out.println(result);  // hello Michael
        }
     }

上面的例子演示了怎么向表达式传入变量值, 表达式中的`yourName`是一个变量, 默认为`null`, 通过传入`Map<String,Object>`的变量绑定环境, 将`yourName`设置为你输入的名称。 `env` 的`key`是变量名, `value`是变量的值。  
上面例子中的`'hello '`是一个`Aviator`的`String`, `Aviator`的`String`是任何用单引号或者双引号括起来的字符序列, `String`可以比较大小(基于`unicode`顺序), 可以参与正则匹配, 可以与任何对象相加, 任何对象与`String`相加结果为`String`。 `String`中也可以有转义字符,如` 、、'` 等。

AviatorEvaluator.execute(" 'a"b' ");           // 字符串 a"b
    AviatorEvaluator.execute(" "a'b" ");         // 字符串 a'b
    AviatorEvaluator.execute(" 'hello ' + 3 ");     // 字符串 hello 3
    AviatorEvaluator.execute(" 'hello '+ unknow "); // 字符串 hello null

### exec 方法 ###

Aviator 2.2 开始新增加一个`exec`方法, 可以更方便地传入变量并执行, 而不需要构造`env`这个`map`了:

String name = "dennis";
    AviatorEvaluator.exec(" 'hello ' + yourName ", name); // hello dennis

只要在`exec`中按照变量在表达式中的出现顺序传入变量值就可以执行, 不需要构建`Map`了。

### 调用函数 ###

Aviator 支持函数调用, 函数调用的风格类似 lua, 下面的例子获取字符串的长度:

AviatorEvaluator.execute("string.length('hello')"); // 5

`string.length('hello')`是一个函数调用, `string.length`是一个函数, `'hello'`是调用的参数。  
再用`string.substring`来截取字符串:

AviatorEvaluator.execute("string.contains("test", string.substring('hello', 1, 2))");  // true

通过`string.substring('hello', 1, 2)`获取字符串`'e'`, 然后通过函数`string.contains`判断`e`是否在`'test'`中。可以看到, 函数可以嵌套调用。  
Aviator 的内置函数列表请看后面。

### 自定义函数 ###

Aviator 除了内置的函数之外,还允许用户自定义函数,只要实现`com.googlecode.aviator.runtime.type.AviatorFunction`接口, 并注册到`AviatorEvaluator`即可使用. `AviatorFunction`接口十分庞大, 通常来说你并不需要实现所有的方法, 只要根据你的方法的参 数个数, 继承`AbstractFunction`类并`override`相应方法即可。

可以看一个例子,我们实现一个`add`函数来做数值的相加:

public class TestAviator {
        public static void main(String[] args) {
            //注册函数
            AviatorEvaluator.addFunction(new AddFunction());
            System.out.println(AviatorEvaluator.execute("add(1, 2)"));           // 3.0
            System.out.println(AviatorEvaluator.execute("add(add(1, 2), 100)")); // 103.0
        }
     }
     class AddFunction extends AbstractFunction {
        @Override
        public AviatorObject call(Map<String, Object> env, AviatorObject arg1, AviatorObject arg2) {
            Number left = FunctionUtils.getNumberValue(arg1, env);
            Number right = FunctionUtils.getNumberValue(arg2, env);
            return new AviatorDouble(left.doubleValue() + right.doubleValue());
        }
        public String getName() {
            return "add";
        }
     }

注册函数通过`AviatorEvaluator.addFunction`方法, 移除可以通过`removeFunction`。

### 编译表达式 ###

上面提到的例子都是直接执行表达式, 事实上 Aviator 背后都帮你做了编译并执行的工作。 你可以自己先编译表达式, 返回一个编译的结果, 然后传入不同的`env`来复用编译结果, 提高性能, 这是更推荐的使用方式:

public class TestAviator {
        public static void main(String[] args) {
            String expression = "a-(b-c)>100";
            // 编译表达式
            Expression compiledExp = AviatorEvaluator.compile(expression);
            Map<String, Object> env = new HashMap<String, Object>();
            env.put("a", 100.3);
            env.put("b", 45);
            env.put("c", -199.100);
            // 执行表达式
            Boolean result = (Boolean) compiledExp.execute(env);
            System.out.println(result);  // false
        }
     }

通过`compile`方法可以将表达式编译成`Expression`的中间对象, 当要执行表达式的时候传入`env`并调用`Expression`的`execute`方法即可。 表达式中使用了括号来强制优先级, 这个例子还使用了`>`用于比较数值大小, 比较运算符`!=、==、>、>=、<、<=`不仅可以用于数值, 也可以用于`String、Pattern、Boolean`等等, 甚至是任何用户传入的两个都实现了`java.lang.Comparable`接口的对象之间。

编译后的结果你可以自己缓存, 也可以交给 Aviator 帮你缓存, `AviatorEvaluator`内部有一个全局的缓存池, 如果你决定缓存编译结果, 可以通过:

public static Expression compile(String expression, boolean cached)

将`cached`设置为`true`即可, 那么下次编译同一个表达式的时候将直接返回上一次编译的结果。  
使缓存失效通过:

public static void invalidateCache(String expression)

方法。

### 访问数组和集合 ###

可以通过中括号去访问数组和`java.util.List`对象, 可以通过`map.key`访问`java.util.Map`中`key`对应的`value`, 一个例子:

public static void main(String[] args) {
        final List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add(" world");
        final int[] array = new int[3];
        array[0] = 0;
        array[1] = 1;
        array[2] = 3;
        final Map<String, Date> map = new HashMap<String, Date>();
        map.put("date", new Date());
        Map<String, Object> env = new HashMap<String, Object>();
        env.put("list", list);
        env.put("array", array);
        env.put("mmap", map);
        System.out.println(AviatorEvaluator.execute("list[0]+list[1]", env));   // hello world
        System.out.println(AviatorEvaluator.execute("'array[0]+array[1]+array[2]=' + (array[0]+array[1]+array[2])", env));  // array[0]+array[1]+array[2]=4
        System.out.println(AviatorEvaluator.execute("'today is ' + mmap.date ", env));  // today is Wed Feb 24 17:31:45 CST 2016
     }

### 三元操作符 ###

Aviator 不提供`if else`语句, 但是提供了三元操作符`?:`用于条件判断,使用上与 java 没有什么不同:

AviatorEvaluator.exec("a>0? 'yes':'no'", 1);  // yes

Aviator 的三元表达式对于两个分支的结果类型并不要求一致,可以是任何类型,这一点与 java 不同。

### 正则表达式匹配 ###

Aviator 支持类 Ruby 和 Perl 风格的表达式匹配运算,通过`=~`操作符, 如下面这个例子匹配 email 并提取用户名返回:

public static void main(String[] args) {
        String email = "killme2008@gmail.com";
        Map<String, Object> env = new HashMap<String, Object>();
        env.put("email", email);
        String username = (String) AviatorEvaluator.execute("email=~/([w0-8]+)@w+[.w+]+/ ? $1 : 'unknow' ", env);
        System.out.println(username); // killme2008
     }

`email`与正则表达式`/([w0-8]+@w+[.w+]+)/`通过`=~`操作符来匹配,结果为一个 `Boolean` 类 型, 因此可以用于三元表达式判断,匹配成功的时候返回`$1`,指代正则表达式的分组 1,也就是用户名,否则返回`unknown`。

Aviator 在表达式级别支持正则表达式,通过`//`括起来的字符序列构成一个正则表达式,正则表 达式可以用于匹配(作为`=~`的右操作数)、比较大小,匹配仅能与字符串进行匹配。匹配成功后, Aviator 会自动将匹配成功的分组放入`$num`的变量中,其中`$0` 指代整个匹配的字符串,而`$1`表示第一个分组,以此类推。

Aviator 的正则表达式规则跟 Java 完全一样,因为内部其实就是使用`java.util.regex.Pattern`做编译的。

### 变量的语法糖 ###

Aviator 有个方便用户使用变量的语法糖, 当你要访问变量`a`中的某个属性`b`, 那么你可以通过`a.b`访问到, 更进一步, `a.b.c`将访问变量`a`的`b`属性中的`c`属性值, 推广开来也就是说 Aviator 可以将变量声明为嵌套访问的形式。  
`TestAviator`类符合`JavaBean`规范, 并且是 `public` 的，我们就可以使用语法糖:

public class TestAviator {
        int i;
        float f;
        Date date;
        // 构造方法
        public TestAviator(int i, float f, Date date) {
            this.i = i;
            this.f = f;
            this.date = date;
        }
        // getter and setter
    
        public static void main(String[] args) {
            TestAviator foo = new TestAviator(100, 3.14f, new Date());
            Map<String, Object> env = new HashMap<String, Object>();
            env.put("foo", foo);
            System.out.println(AviatorEvaluator.execute("'foo.i = '+foo.i", env));   // foo.i = 100
            System.out.println(AviatorEvaluator.execute("'foo.f = '+foo.f", env));   // foo.f = 3.14
            System.out.println(AviatorEvaluator.execute("'foo.date.year = '+(foo.date.year+1990)", env));  // foo.date.year = 2106
        }
     }

### nil 对象 ###

`nil`是 Aviator 内置的常量,类似 java 中的`null`,表示空的值。`nil`跟`null`不同的在于,在 java 中`null`只能使用在`==、!=`的比较运算符,而`nil`还可以使用`>、>=、<、<=`等比较运算符。 Aviator 规定,任何对象都比`nil`大除了`nil`本身。用户传入的变量如果为`null`,将自动以`nil`替代。

AviatorEvaluator.execute("nil == nil");   //true
    AviatorEvaluator.execute(" 3> nil");      //true
    AviatorEvaluator.execute(" true!= nil");  //true
    AviatorEvaluator.execute(" ' '>nil ");    //true
    AviatorEvaluator.execute(" a==nil ");     //true, a 是 null

`nil`与`String`相加的时候,跟 java 一样显示为 `null`

### 日期比较 ###

Aviator 并不支持日期类型,如果要比较日期,你需要将日期写字符串的形式,并且要求是形如 “yyyy-MM-dd HH:mm:ss:SS”的字符串,否则都将报错。 字符串跟`java.util.Date`比较的时候将自动转换为`Date`对象进行比较:

public static void main(String[] args) {
        Map<String, Object> env = new HashMap<String, Object>();
        final Date date = new Date();
        String dateStr = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS").format(date);
        env.put("date", date);
        env.put("dateStr", dateStr);
        Boolean result = (Boolean) AviatorEvaluator.execute("date==dateStr", env);
        System.out.println(result);  // true
        result = (Boolean) AviatorEvaluator.execute("date > '2010-12-20 00:00:00:00' ", env);
        System.out.println(result);  // true
        result = (Boolean) AviatorEvaluator.execute("date < '2200-12-20 00:00:00:00' ", env);
        System.out.println(result);  // true
        result = (Boolean) AviatorEvaluator.execute("date==date ", env);
        System.out.println(result);  // true
     }

也就是说`String`除了能跟`String`比较之外,还能跟`nil`和`java.util.Date`对象比较。

### 大数计算和精度 ###

从 2.3.0 版本开始,aviator 开始支持大数字计算和特定精度的计算, 本质上就是支持`java.math.BigInteger`和`java.math.BigDecimal`两种类型, 这两种类型在 aviator 中简称 为`big int`和`decimal`类型。 类似`99999999999999999999999999999999`这样的数字在 Java 语言里是没办法编译通过 的, 因为它超过了`Long`类型的范围, 只能用`BigInteger`来封装。但是 aviator 通过包装,可 以直接支持这种大整数的计算,例如:

public static void main(String[] args) {
        System.out.println(AviatorEvaluator.exec("99999999999999999999999999999999 + 99999999999999999999999999999999"));
     }

结果为类型`big int`的: `199999999999999999999999999999998`

字面量表示

`big int`和`decimal`的表示与其他数字不同,两条规则:

*  以大写字母`N`为后缀的整数都被认为是`big int`,如`1N,2N,9999999999999999999999N`等, 都是`big int`类型。
 *  超过`long`范围的整数字面量都将自动转换为`big int`类型。
 *  以大写字母`M`为后缀的数字都被认为是`decimal`, 如`1M,2.222M, 100000.9999M`等, 都是`decimal`类型。

用户也可以通过变量传入这两种类型来参与计算。

运算

`big int`和`decimal`的运算,跟其他数字类型`long,double`没有什么区别,操作符仍然是一样的。 aviator重载了基本算术操作符来支持这两种新类型:

public static void main(String[] args) {
        Object rt = AviatorEvaluator.exec("9223372036854775807100.356M * 2");
        System.out.println(rt + " " + rt.getClass());  // 18446744073709551614200.712 class java.math.BigDecimal
        rt = AviatorEvaluator.exec("92233720368547758074+1000");
        System.out.println(rt + " " + rt.getClass());  // 92233720368547759074 class java.math.BigInteger
        BigInteger a = new BigInteger(String.valueOf(Long.MAX_VALUE) + String.valueOf(Long.MAX_VALUE));
        BigDecimal b = new BigDecimal("3.2");
        BigDecimal c = new BigDecimal("9999.99999");
        rt = AviatorEvaluator.exec("a+10000000000000000000", a);
        System.out.println(rt + " " + rt.getClass());  // 92233720368547758089223372036854775807 class java.math.BigInteger
        rt = AviatorEvaluator.exec("b+c*2", b, c);
        System.out.println(rt + " " + rt.getClass());  // 20003.19998 class java.math.BigDecimal
        rt = AviatorEvaluator.exec("a*b/c", a, b, c);
        System.out.println(rt + " " + rt.getClass());  // 2.951479054745007313280155218459508E+34 class java.math.BigDecimal
     }

类型转换和提升

当`big int`或者`decimal`和其他类型的数字做运算的时候,按照`long < big int < decimal < double`的规则做提升, 也就是说运算的数字如果类型不一致, 结果的类型为两者之间更“高”的类型。例如:

*  `1 + 3N`, 结果为`big int`的`4N`
 *  `1 + 3.1M`,结果为`decimal`的`4.1M`
 *  `1N + 3.1M`,结果为`decimal`的 `4.1M`
 *  `1.0 + 3N`,结果为`double`的`4.0`
 *  `1.0 + 3.1M`,结果为`double`的`4.1`

decimal 的计算精度

Java 的`java.math.BigDecimal`通过`java.math.MathContext`支持特定精度的计算,任何涉及到金额的计算都应该使用`decimal`类型。

默认 Aviator 的计算精度为`MathContext.DECIMAL128`,你可以自定义精度, 通过:

AviatorEvaluator.setMathContext(MathContext.DECIMAL64);

即可设置,更多关于`decimal`的精度问题请看`java.math.BigDecimal`的 javadoc 文档。

### 强大的 seq 库 ###

aviator 拥有强大的操作集合和数组的 `seq` 库。整个库风格类似函数式编程中的高阶函数。在 aviator 中, 数组以及`java.util.Collection`下的子类都称为`seq`,可以直接利用 `seq` 库进行遍历、过滤和聚合等操作。

例如,假设我有个 `list`:

public static void main(String[] args) {
        Map<String, Object> env = new HashMap<String, Object>();
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(3);
        list.add(20);
        list.add(10);
        env.put("list", list);
        Object result = AviatorEvaluator.execute("count(list)", env);
        System.out.println(result);  // 3
        result = AviatorEvaluator.execute("reduce(list,+,0)", env);
        System.out.println(result);  // 33
        result = AviatorEvaluator.execute("filter(list,seq.gt(9))", env);
        System.out.println(result);  // [10, 20]
        result = AviatorEvaluator.execute("include(list,10)", env);
        System.out.println(result);  // true
        result = AviatorEvaluator.execute("sort(list)", env);
        System.out.println(result);  // [3, 10, 20]
        AviatorEvaluator.execute("map(list,println)", env);
     }

我们可以:

*  求长度: `count(list)`
 *  求和: `reduce(list,+,0)`, `reduce`函数接收三个参数,第一个是`seq`,第二个是聚合的函数,如`+`等,第三个是聚合的初始值
 *  过滤: `filter(list,seq.gt(9))`, 过滤出`list`中所有大于`9`的元素并返回集合; `seq.gt`函数用于生成一个谓词,表示大于某个值
 *  判断元素在不在集合里: `include(list,10)`
 *  排序: `sort(list)`
 *  遍历整个集合: `map(list,println)`, `map`接受的第二个函数将作用于集合中的每个元素,这里简单地调用`println`打印每个元素

### 两种运行模式 ###

默认 `AviatorEvaluator` 以执行速度优先:

AviatorEvaluator.setOptimize(AviatorEvaluator.EVAL);

你可以修改为编译速度优先,这样不会做编译优化:

AviatorEvaluator.setOptimize(AviatorEvaluator.COMPILE);

### 调试信息 ###

从 2.1.1.版本开始,Aviator允许设置输出每个表达式生成的字节码,只要设置`trace`为`true`即可:

AviatorEvaluator.setTrace(true);

方便用户做跟踪和调试。默认是输出到标准输出,你可以改变输出指向:

AviatorEvaluator.setTraceOutputStream(new FileOutputStream(new File("aviator.log")));

## 语法手册 ##

下面是 Aviator 详细的语法规则定义。

### 数据类型 ###

*  `Number`类型: 数字类型,支持四种类型,分别是`long,double,java.math.BigInteger(简称 big int)`和`java.math.BigDecimal(简 称 decimal)`,规则如下:
    
     *  任何以大写字母 `N` 结尾的整数都被认为是 `big int`
     *  任何以大写字母 `M` 结尾的数字都被认为是 `decimal`
     *  其他的任何整数都将被转换为 `Long`
     *  其他任何浮点数都将被转换为 `Double`
     *  超过 `long` 范围的整数字面量都将自动转换为 `big int` 类型

其中 `big int` 和 `decimal` 是 2.3.0 版本开始引入的。数字还支持十六进制(以`0x`或者`0X`开头的数字), 以及科学计数法,如`1e-3`等。 不支持其他进制。

*  `String`类型: 字符串类型,单引号或者双引号括起来的文本串,如`'hello world'`, 变量如果传入的是`String`或者`Character`也将转为`String`类型
 *  `Bool`类型: 常量`true`和`false`,表示真值和假值,与 java 的`Boolean.TRUE`和`Boolean.False`对应
 *  `Pattern`类型: 正则表达式, 以`//`括起来的字符串,如`/d+/`,内部 实现为`java.util.Pattern`
 *  变量类型: 与 Java 的变量命名规则相同,变量的值由用户传入
 *  `nil`类型: 常量`nil`,类似 java 中的`null`,但是`nil`比较特殊,`nil`不仅可以参与`==、!=`的比较, 也可以参与`>、>=、<、<=`的比较,Aviator 规定任何类型都大于`nil`除了`nil`本身,`nil==nil`返回`true`。 用户传入的变量值如果为`null`,那么也将作为`nil`处理,`nil`打印为`null`

### 操作符 ###

算术运算符

Aviator 支持常见的算术运算符,包括`+ - * / %`五个二元运算符,和一元运算符`-(负)`。其中`- * / %`和一元的`-`仅能作用于`Number`类型。  
`+`不仅能用于`Number`类型,还可以用于`String`的相加,或者字符串与其他对象的相加。  
Aviator 规定,任何类型与`String`相加,结果为`String`。

逻辑运算符

Avaitor 的支持的逻辑运算符包括,一元否定运算符`!`,以及逻辑与的`&&`,逻辑或的`||`。逻辑运算符的操作数只能为`Boolean`。  
`&&`和`||`都执行短路规则。

关系运算符

Aviator 支持的关系运算符包括`<, <=, >, >=`以及`==`和`!=` 。  
关系运算符可以作用于`Number`之间、`String`之间、`Pattern`之间、`Boolean`之间、变量之间以及其他类型与`nil`之间的关系比较, 不同类型除了`nil`之外不能相互比较。

位运算符

Aviator 支持所有的 Java 位运算符,包括`&, |, ^, ~, >>, <<, >>>`。

匹配运算符

匹配运算符`=~`用于`String`和`Pattern`的匹配,它的左操作数必须为`String`,右操作数必须为`Pattern`。 匹配成功后,`Pattern`的分组将存于变量`$num`,`num`为分组索引。

三元运算符

Aviator 没有提供`if else`语句,但是提供了三元运算符`?:`,形式为`bool ? exp1: exp2`。 其中`bool`必须为`Boolean`类型的表达式, 而`exp1`和`exp2`可以为任何合法的 Aviator 表达式,并且不要求`exp1`和`exp2`返回的结果类型一致。

## 内置函数 ##

<table> 
 <thead> 
  <tr> 
   <th>函数名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>sysdate()</td> 
   <td>返回当前日期对象 java.util.Date</td> 
  </tr> 
  <tr> 
   <td>rand()</td> 
   <td>返回一个介于 0-1 的随机数,double 类型</td> 
  </tr> 
  <tr> 
   <td>print([out],obj)</td> 
   <td>打印对象,如果指定 out,向 out 打印, 否则输出到控制台</td> 
  </tr> 
  <tr> 
   <td>println([out],obj)</td> 
   <td>与 print 类似,但是在输出后换行</td> 
  </tr> 
  <tr> 
   <td>now()</td> 
   <td>返回 System.currentTimeMillis</td> 
  </tr> 
  <tr> 
   <td>long(v)</td> 
   <td>将值的类型转为 long</td> 
  </tr> 
  <tr> 
   <td>double(v)</td> 
   <td>将值的类型转为 double</td> 
  </tr> 
  <tr> 
   <td>str(v)</td> 
   <td>将值的类型转为 string</td> 
  </tr> 
  <tr> 
   <td>date_to_string(date,format)</td> 
   <td>将 Date 对象转化化特定格式的字符串,2.1.1 新增</td> 
  </tr> 
  <tr> 
   <td>string_to_date(source,format)</td> 
   <td>将特定格式的字符串转化为 Date 对 象,2.1.1 新增</td> 
  </tr> 
  <tr> 
   <td>string.contains(s1,s2)</td> 
   <td>判断 s1 是否包含 s2,返回 Boolean</td> 
  </tr> 
  <tr> 
   <td>string.length(s)</td> 
   <td>求字符串长度,返回 Long</td> 
  </tr> 
  <tr> 
   <td>string.startsWith(s1,s2)</td> 
   <td>s1 是否以 s2 开始,返回 Boolean</td> 
  </tr> 
  <tr> 
   <td>string.endsWith(s1,s2)</td> 
   <td>s1 是否以 s2 结尾,返回 Boolean</td> 
  </tr> 
  <tr> 
   <td>string.substring(s,begin[,end])</td> 
   <td>截取字符串 s,从 begin 到 end,如果忽略 end 的话,将从 begin 到结尾,与 java.util.String.substring 一样。</td> 
  </tr> 
  <tr> 
   <td>string.indexOf(s1,s2)</td> 
   <td>java 中的 s1.indexOf(s2),求 s2 在 s1 中 的起始索引位置,如果不存在为-1</td> 
  </tr> 
  <tr> 
   <td>string.split(target,regex,[limit])</td> 
   <td>Java 里的 String.split 方法一致,2.1.1 新增函数</td> 
  </tr> 
  <tr> 
   <td>string.join(seq,seperator)</td> 
   <td>将集合 seq 里的元素以 seperator 为间隔 连接起来形成字符串,2.1.1 新增函数</td> 
  </tr> 
  <tr> 
   <td>string.replace_first(s,regex,replacement)</td> 
   <td>Java 里的 String.replaceFirst 方法, 2.1.1 新增</td> 
  </tr> 
  <tr> 
   <td>string.replace_all(s,regex,replacement)</td> 
   <td>Java 里的 String.replaceAll 方法 , 2.1.1 新增</td> 
  </tr> 
  <tr> 
   <td>math.abs(d)</td> 
   <td>求 d 的绝对值</td> 
  </tr> 
  <tr> 
   <td>math.sqrt(d)</td> 
   <td>求 d 的平方根</td> 
  </tr> 
  <tr> 
   <td>math.pow(d1,d2)</td> 
   <td>求 d1 的 d2 次方</td> 
  </tr> 
  <tr> 
   <td>math.log(d)</td> 
   <td>求 d 的自然对数</td> 
  </tr> 
  <tr> 
   <td>math.log10(d)</td> 
   <td>求 d 以 10 为底的对数</td> 
  </tr> 
  <tr> 
   <td>math.sin(d)</td> 
   <td>正弦函数</td> 
  </tr> 
  <tr> 
   <td>math.cos(d)</td> 
   <td>余弦函数</td> 
  </tr> 
  <tr> 
   <td>math.tan(d)</td> 
   <td>正切函数</td> 
  </tr> 
  <tr> 
   <td>map(seq,fun)</td> 
   <td>将函数 fun 作用到集合 seq 每个元素上, 返回新元素组成的集合</td> 
  </tr> 
  <tr> 
   <td>filter(seq,predicate)</td> 
   <td>将谓词 predicate 作用在集合的每个元素 上,返回谓词为 true 的元素组成的集合</td> 
  </tr> 
  <tr> 
   <td>count(seq)</td> 
   <td>返回集合大小</td> 
  </tr> 
  <tr> 
   <td>include(seq,element)</td> 
   <td>判断 element 是否在集合 seq 中,返回 boolean 值</td> 
  </tr> 
  <tr> 
   <td>sort(seq)</td> 
   <td>排序集合,仅对数组和 List 有效,返回排 序后的新集合</td> 
  </tr> 
  <tr> 
   <td>reduce(seq,fun,init)</td> 
   <td>fun 接收两个参数,第一个是集合元素, 第二个是累积的函数,本函数用于将 fun 作用在集合每个元素和初始值上面,返回 最终的 init 值</td> 
  </tr> 
  <tr> 
   <td>seq.eq(value)</td> 
   <td>返回一个谓词,用来判断传入的参数是否跟 value 相等,用于 filter 函数,如filter(seq,seq.eq(3)) 过滤返回等于3 的元素组成的集合</td> 
  </tr> 
  <tr> 
   <td>seq.neq(value)</td> 
   <td>与 seq.eq 类似,返回判断不等于的谓词</td> 
  </tr> 
  <tr> 
   <td>seq.gt(value)</td> 
   <td>返回判断大于 value 的谓词</td> 
  </tr> 
  <tr> 
   <td>seq.ge(value)</td> 
   <td>返回判断大于等于 value 的谓词</td> 
  </tr> 
  <tr> 
   <td>seq.lt(value)</td> 
   <td>返回判断小于 value 的谓词</td> 
  </tr> 
  <tr> 
   <td>seq.le(value)</td> 
   <td>返回判断小于等于 value 的谓词</td> 
  </tr> 
  <tr> 
   <td>seq.nil()</td> 
   <td>返回判断是否为 nil 的谓词</td> 
  </tr> 
  <tr> 
   <td>seq.exists()</td> 
   <td>返回判断不为 nil 的谓词</td> 
  </tr> 
 </tbody> 
</table>

本文转载自：[https://blog.csdn.net/keda8997110/article/details/50782848][https_blog.csdn.net_keda8997110_article_details_50782848]

[https_blog.csdn.net_keda8997110_article_details_50782848]: https://blog.csdn.net/keda8997110/article/details/50782848