精华内容
下载资源
问答
  • 关系运算符和表达式

    2019-08-03 09:58:31
    关系运算符的值只能0或1关系运算符的值真时,结果值都为1关系运算符的值假时,结果值都为0。 注意事项(优先级) (1)前4种关系运算符的优先级别相同,后两种也相同。前四种高于后两种。 (2)关系运算符...

    关系运算符和表达式

    关系运算符有6种关系,分别为小于、小于等于、大于、等于、大于等于、不等于。
    六种运算符

    结果值
    关系运算符的值只能是0或1。
    关系运算符的值为真时,结果值都为1。
    关系运算符的值为假时,结果值都为0。

    注意事项(优先级)
    (1)前4种关系运算符的优先级别相同,后两种也相同。前四种高于后两种。
    (2)关系运算符的优先级低于算术运算符。
    (3)关系运算符的优先级高于赋值运算符。

    C语言中的关系表达式
    用关系运算符将两个表达式连接起来的式子,称关系表达式。关系表达式的值是逻辑值“真”或“假”。但是C语言没有逻辑型变量和逻辑型常量,也没有专门的逻辑值,故以“非0”代表“真”,以“0”代表“假”。在关系表达式求解时,以“1”代表“真”,以“0”代表假。当关系表达式成立时,表达式的值为1,否则表达式的值为0。

    #include <stdio.h>
    
    int main()
    {
    	char c = 'k';
    	int i = 1, j = 2, k = 3;
    	float x = 3e+5, y = 0.85f;
    	printf("%d,%d\n",'a'+5<c,-i-2*j>=k+i);
    	printf("%d,%d\n",i<j&&j<5,x-5.25<=x+y);
    	printf("%d,%d\n",i+j+k==-2*j,k==j==i+5);
    	return 0;
    }
    

    程序运行结果为:
    1,0
    1,1
    0,0
    在这里插入图片描述

    展开全文
  • 表达式详解

    2019-09-27 15:33:54
      ②有些表达式的操作数在求的过程中可能需要转换其他类型    c的整型算术运算总是至少以缺省整型类型的精度来进行的   为了获得这个精度,表达式中的字符和短整型操作数在使用之前被转换普通整型,这种...

    一.隐式类型转换

    表达式求值的顺序应遵循什么样的原则?

      ①一部分是由操作符的优先级和结合性决定的
      ②有些表达式的操作数在求值的过程中可能需要转换为其他类型

       c的整型算术运算总是至少以缺省整型类型的精度来进行的
      为了获得这个精度,表达式中的字符和短整型操作数在使用之前被转换为普通整型,这种转换称为整型提升

    整型提升的意义

     表达式的整型运算要在CPU的相应运算器件内执行,CPU内整型运算器(ALU)的操作数的字节长度一般就是int的字节长度,同时也是CPU的通用寄存器的长度
     因此,即使两个char类型相加,在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。
     通用CPU是难以直接实现两个8比特字节直接相加运算,所以,表达式中各种长度可能小于int长度的整型值,都必须先转换为int或者unsigned int,然后才能送到CPU中去执行。

    如:

    char a, b, c;
    .....
    a = b + c;
    

      a,b,c为char类型,所以b和c的值会被提升为普通整型,然后再执行加法运算。运算结束,结果将被截断,然后存入a中

    如何进行整体提升?(提升之后补位补什么?)
      整型提升是按照变量的数据类型的符号位来提升的

    ①负数的整型提升
        char c1=-1;
    c1存储到计算机内存中以二进制补码形式存储
    1 1 1 1  1 1 1 1
    因为char为有符号的char
    所以整形提升的时候,高位补充符号位,即补1
    提升后的结果为:
       11111111 11111111  11111111  11111111 
    
    
    ②正数的整型提升
       char c2=1;
    c2存储到计算机内存中以二进制补码形式存储
    0 0 0 0 0 0 0 1
    因为char为有符号的char
    所以整形提升的时候,高位补充符号位,即补0
    提升后的结果为:
        00000000  00000000  00000000  00000001
    

    整型提升实例1:

    int main()
    {
    	char a = 0xb6;
    	short b = 0xb600;
    	int c = 0xb6000000;
    	if (a == 0xb6)
    		printf("a");
    	if (b == 0xb600)
    		printf("b");
    	if (c == 0xb6000000)
    		printf("c");
    	system("pause");
    	return 0;
    }
    
    
    
    //输出结果为c
    a,b要进行整型提升,而c就是整型,不需要提升。
    

    整型提升实例2:

    int main()
    {
    	char c = 1;
    	printf("%u\n", sizeof(c));   //c没有参加表达式运算
    	printf("%u\n", sizeof(+c));
    	printf("%u\n", sizeof(!c));
    	system("pause");
    	return 0;
    }
    
    //输出结果为1 4 4/1(编译器不同结果不同)
    

     *注意:*只要参与了表达式的运算,就会进行整型的提升

      
      

    二.算术转换

      如果某个操作符的各个操作数属于不同的类型,那么除非其中一个操作数转换为另一个操作数的类型,否则操作就无法进行。
      算术类型转换尽可能转换为当前类型的最大类型

    long double
    double
    float
    unsigned long int
    long int 
    unsigned int 
    int
    

      如果某个操作数的类型在上面列表中排位较低,首先转换为另一个操作数的类型后执行运算。算术转换要合理。

    float f=3.14;
    int num=f;       //隐式转换,会有精度丢失
    

        
      

    三.操作符的属性

    复杂表达式的求值有三个影响因素:
    1.操作符的优先级
    2.操作符的结合性
    3.是否控制求值顺序

    操作符优先级:

    操作符 描述
    () 聚组
    () 函数调用
    [] 下标引用
    . 访问结构体成员
    -> 访问结构指针成员
    ++ 后缀自增
    后缀自减
    逻辑反
    ~ 按位反
    + 单目,表示正值
    - 单目,表示负值
    ++ 前缀自增
    前缀自减
    * 间接访问
    & 取地址
    sizeof 取字节长度
    (类型) 类型转换
    * 乘法
    / 除法
    % 整数取余
    + 加法
    - 减法
    << 左移位
    >> 右移位
    > 大于
    >= 大于等于
    < 小于
    <= 小于等于
    == 等于
    != 不等于
    & 位与
    ^ 位异或
    && 逻辑与
    ?: 条件操作符
    = 赋值
    += 以…加
    -= 以…减
    *= 以…乘
    /= 以…除
    %= 以…取模
    <<= 以…左移
    >>= 以…右移
    &= 以…与
    ^= 以…异或
    逗号

    简单记:
    ! > 算术运算符 > 关系运算符 > && > || > 赋值运算符
      
    一些有问题的表达式:

    1.//计算时*比+优先级高,只能保证*先计算,不能决定第三个*比第一个+早执行
    a*b + c*d + e*f;
    
    2.//我们可以知道自减--在+运算的前面,但+操作符的左操作数的获取在右操作数之前还是之后求值,结果有歧义
    c + --c
    
    3.//非法表达式
    int main()
    {
         int i=10;
         i=i-- - --i * (i= -3) * i++ + ++i;
         printf("i=%d\n",i);
         return 0;
    

      要注意写出的表达式如果不能通过操作符的属性确定唯一的计算路径,那这个表达式就存在问题。

    展开全文
  • 表达式

    2018-08-10 15:11:02
    表达式由一个多个运算对象组成,对表达式将得到一个结果。字面值和变量是最简单的表达式,其结果就是字面值和变量的。把一个运算符和一个多个运算对象组合起来可以生成较复杂的表达式。 基础 1、基本...

    表达式由一个或多个运算对象组成,对表达式求值将得到一个结果。字面值和变量是最简单的表达式,其结果就是字面值和变量的值。把一个运算符和一个或多个运算对象组合起来可以生成较复杂的表达式。

    基础

    1、基本概念

    • 一元运算符
    • 二元运算符
    • 三元运算符

     左值和右值

      C++的表达式要么是左值,要么就是右值。

      当一个对象被用作右值的时候,用的是对象的值(内容);当对象被用作左值的时候,用的是对象的身份(在内存中的位置)。

      在需要右值的地方可以用左值来代替,但是不能把右值当成左值使用。

    2、优先级与结合律

      复合表达式是指含有两个或多个运算符的表达式。求复合表达式的值需要首先将运算符和运算对象合理地组合在一起,优先级与结合律决定了运算对象组合的方式。

    括号无视优先级与结合律

    3、求值顺序

    优先级规定了运算对象的组合方式,但是没有说明运算对象按照什么顺序求值。在大多数情况下,不会明确指定求值的顺序。

    int i=f1()*f2();

    上述就无法知道到底f1在f2之前调用,还是f2在f1之前调用。

    NOTE:对于那些没有指定执行顺序的运算符来说,如果表达式指向并修改了同一个对象,将会引发错误并产生未定义的行为。

    int i=0;
    cout<<i<<"  "<<++i<<endl;    //未定义

    (但是VS2013中测试结果是先进行++i运算)

     

    有四种运算符明确规定了运算对象的求值顺序。

    • 逻辑与(&&)运算符:先求左侧对象的值,只有当左侧运算对象的值为真时才继续求右侧对象的值
    • 逻辑或(||)运算符
    • 条件(?:)运算符
    • 逗号运算符

    求值顺序、优先级、结合律

    运算对象的求值顺序与优先级和结合律无关。当表达式中对象不改变同一对象时,其求值顺序不受限制,如果有对同一对象产生影响,则会是一条错误的表达式,产生未定义的行为。(VS13中已经不报错,而是按照从左到右的顺序求值,如果表达式中只有一个对象改变其值,则先求改变对象的值)

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    int n = 0;

     

    int f1()

    {

        return ++n;

    }

     

    int f2()

    {

        return --n;

    }

     

    int main()

    {

        int a = f1() + f2();

        cout << a << endl;

        system("pause");

        return 0;

    }

    输出结果是1.

    因为f1和f2都对n有改变,所以先求f1的值再求f2的值。

    1

    2

    int i = 0;

    cout << i << "  " << ++i << endl;

    输出结果是1,1.

    因为++i会改变对象,所以先对其求值,再从左到右的结合律执行。

    算术运算符

    算术运算符的运算对象和求值结果都是右值。在表达式求值之前,小整数类型的运算对象被提升成较大的整数类型(int),所有运算对象最终会转换成同一类型。

    对大多数运算符来说,布尔类型的运算对象将被提升为int,对于一元运算符+或-,布尔值不应该参与运算。

    整数相除的结果还是整数,小数部分直接弃掉。

    %取余:计算两个整数相除所得的余数,运算对象必须都是整数。

     逻辑和关系运算符

    关系运算符作用域算术类型或指针类型,逻辑运算符作用于任意能转换成布尔值的类型。逻辑运算符和关系运算符的返回值都是布尔类型。二者的运算对象和求值结果都是右值。

    逻辑与和逻辑或运算符

    二者都是先求左侧运算对象的值再求右侧运算对象的值。

    短路求值:当左侧运算对象的值无法确定表达式的结果时才会计算右侧运算对象的值。

    赋值运算符

    赋值运算符的左侧运算对象必须是一个可修改的左值。

    赋值运算的结果是它的左侧运算对象,并且是一个左值。相应的,结果的类型就是左侧运算对象的类型。如果赋值运算符的左右两个运算对象类型不同,则右侧运算对象转换成左侧运算对象的类型。

    赋值运算满足右结合律

    其他二元运算符满足左结合律,赋值运算返回的是其左侧运算对象。

     赋值运算优先级较低

    通常需要给赋值部分加上括号使其符合我们的原意。

    不要混用赋值运算符和相等运算符

    复合赋值运算符

    任意一种复合运算符都完全等价于:

    a=a op b;

    区别在于左侧运算对象的求值次数:使用复合运算符只求值一次,使用普通运算符则求值两次。

    递增和递减运算符

    递增和递减运算符有两种形式:前置版本和后置版本。

    前置版本是先对对象进行递增或递减运算并返回运算之后的对象值,对象本身已经发生改变。

    后置版本是先返回未改变之前的对象的值,然后再对对象进行递增或递减操作。

    NOTE:除非必须,否则不用递增或递减运算符的后置版本。

    在一条语句中混用解引用和递增运算符

    如果想在一条复合表达式中既将变量加1或减1又能使用它原来的值,这时就可以使用递增或递减的后置版本。

    NOTE:后置运算符的优先级高于解引用运算符,因此*p++等价于*(p++)

    成员访问运算符

    点运算符和箭头运算符

    NOTE:解引用运算符的优先级低于点运算符,所以执行解引用运算的子表达式两端必须加上括号。

    条件运算符

    条件运算符(?:)允许把简单的if-else逻辑嵌入到单个表达式中

    cond?expr1:expr2

    cond是判断条件的表达式,expr1和expr2是两个类型相同或可能转换为某个公共类型的表达式。

    表达式的结果是expr1或expr2的返回值。当两个表达式都是左值或能转换成同一种左值类型时,运算的结果哦是左值;否则运算的结果是右值。

     嵌套条件运算符

    条件运算的嵌套最好别超过两到三层。

    在输出表达式中使用条件运算符

     条件运算符的优先级非常低,因此当一条长表达式中嵌套了条件运算子表达式时,通常需要加上括号。

    位运算符

    位运算符作用于整数类型的运算对象,并把运算对象看成是二进制位的集合。位运算符提供检查和设置二进制位的功能。

     

    一般来说,如果运算复习时小整型,则会自动提升成较大的整数类型。运算对象可以是带符号,也可以是无符号。如果运算对象是带符号的且它的值为负,那么位运算符如何处理对象的“符号位”依赖于机器,左移操作可能改变符号位的值,因此是一种未定义的行为。

    NOTE:强烈建议仅将位运算符用于处理无符号类型。

    移位运算符

    首先令左侧运算对象的内容按照右侧运算对象的要求移动指定位数,然后将经过移动的左侧运算对象的拷贝作为求值结果。

    其中,右侧的运算对象一定不能为负,而且值必须严格小于结果的位数,否则产生未定义的行为。二进制位移出边界之外的位被舍弃掉。

    位求反运算符

    位与、位或、位异或运算符

    sizeof运算符

    sizeof运算符返回一条表达式或一个类型名字所占的字节数。其值是一个size_t类型的常量表达式。

    sizeof并不实际计算其运算对象的值。

    • 对char或者类型为char的表达式执行sizeof运算,结果为1
    • 对引用和解引用指针执行sizeof,得到的是实际对象所占空间的大小
    • 对指针的运算结果是指针本身所占空间的大小
    • 对数组的运算结果是整个数组所占空间的大小,等价于对数组中所有的元素各执行一次的结果之和
    • 对string和vector的执行结果是该类型固定部分的大小,不会计算对象中的元素占用了多少空间

    NOTE:sizeof的返回值是常量表达式,因此可以用来定义数组。

     逗号运算符

    逗号运算符含有两个运算对象,安装从左向右的顺序依次求值。

    首先对左侧的表达式求值,然后将求值结果丢弃掉,逗号运算符真正的结果是右侧表达式的值。如果右侧对象是左值,最终结果也是左值。

    逗号运算符经常被用在for循环中。

    类型转换

    算术类型之间的隐式转换被设计得尽可能避免损失精度。

    何时发生隐式转换

    • 大多数表达式中,比int类型小的整型值首先提升为较大的整数类型
    • 在条件中,非布尔值转换成布尔类型
    • 初始化过程中,初始值转换成变量的类型;在赋值语句中,右侧运算对象转换成左侧运算对象的类型
    • 如果算术运算或关系运算的运算对象有多种类型,需要转换成同一种类型。
    • 函数调用时也会发生类型转换

    算术转换

    运算符的运算对象转换成最宽的类型。当表达式中既有浮点又有整型的时候,整型转换为浮点。

    整型提升

    • 小整数类型(bool、char、signed char、unsigned char、short和unsigned short)转换成int类型
    • 较大的char类型(wchar_t、char16_t、char32_t)提升为int、unsigned、long、unsigned long、long long和unsigned long long中能容纳其值的最小的一种

    无符号类型的运算对象

    • 无符号类型大于带符号类型,则带符号类型转换成无符号类型
    • 无符号类型小于带符号类型,转换结果依赖于机器。

    其他隐式类型转换

    数组转换成指针

    在大多数用到数组的表达式中,数组自动转换成指向数组首元素的指针;

    当数组被用作decltype关键字的参数,或者作为取地址符、sizeof、typeid等运算符的运算对象时,上述转换不会发生。

    指针的转换

    转换成布尔类型

    如果指针或算术类型的值为0,转换结果是FALSE,否则是TRUE

    转换成常量

    允许将非常量类型的指针转换成指向相应的常量类型的指针,对于引用也是这样。相反的转换并不存在,因为它试图删除掉底层const。

    类类型定义的转换

    显式转换

    也称为强制类型转换。

    NOTE:强制类型转换很危险

    命名的强制类型转换

    cast-name<type>(expression);

    其中,type是转换的目标类型而expression是要转换的值。

    cast-name是static_cast、dynamic_cast、const_cast和reinterpret_cast中的一种。

    static_cast

    任何具有明确定义的类型转换,只要不包含底层const,都可以使用static_cast.

    当需要把一个较大的算术类型赋值给较小的类型时,static_cast非常有用。它会让编译器知道我们不在乎精度损失,而不报警。

    static_cast对于编译器无法自动执行的类型转换也非常有用。

    const_cast

    const_cast只能改变运算对象的底层const。常用于有函数重载的上下文中。

    只有const_cast能改变表达式的常量属性,使用其他形式的命名类型转换改变表达式的常量属性都将引发编译器错误。

    1

    2

    const char *p;

    char *q = const_cast<char*>(p);

    reinterpret_cast

    通常为运算对象的位模式提供较低层次上的重新解释。尽量不使用。主要是指针之间的转换

    1

    2

    int *ip;

    char *q = reinterpret_cast<char*>(ip);

    展开全文
  • Aviator 一种表达式引擎

    千次阅读 2019-03-19 17:56:07
    现在已经有很多开源可用的 java 表达式引擎,什么还需要 Avaitor 呢? Aviator的设计目标是轻量级和高性能,相比于Groovy、JRuby的笨重, Aviator非常小, 加上依赖包也才 537K,不算依赖包的话只有 70K; 当然, ...

    1.简介

    Aviator是一个高性能、轻量级的 java 语言实现的表达式求值引擎, 主要用于各种表达式的动态求值。现在已经有很多开源可用的 java 表达式求值引擎,为什么还需要 Avaitor 呢?
    Aviator的设计目标是轻量级和高性能,相比于Groovy、JRuby的笨重, Aviator非常小, 加上依赖包也才 537K,不算依赖包的话只有 70K; 当然, Aviator的语法是受限的, 它不是一门完整的语言, 而只是语言的一小部分集合。
    其次, Aviator的实现思路与其他轻量级的求值器很不相同, 其他求值器一般都是通过解释的方式运行, 而Aviator则是直接将表达式编译成 JVM 字节码, 交给 JVM 去执行。简单来说, Aviator的定位是介于 Groovy 这样的重量级脚本语言和 IKExpression 这样的轻量级表达式引擎之间。

    2.特性

    Aviator的特性:

    • 支持绝大多数运算操作符,包括算术操作符、关系运算符、逻辑操作符、位运算符、正则匹配操作符(=~)、三元表达式(? : );
    • 支持操作符优先级和括号强制设定优先级;
    • 逻辑运算符支持短路运算;
    • 支持丰富类型,例如nil、整数和浮点数、字符串、正则表达式、日期、变量等,支持自动类型转换;
    • 支持传入变量,支持类似a.b.c的嵌套变量访问;
    • 内置一套强大的常用函数库;
    • 可自定义函数,易于扩展;
    • 可重载操作符;
    • 支持大数运算(BigInteger)和高精度运算(BigDecimal);
    • 性能优秀。

    Aviator的限制:

    • 没有if else、do while等语句,没有赋值语句,仅支持逻辑表达式、算术表达式、三元表达式和正则匹配。
    • 无法自定义运算符,自定义函数有局限性

    3.依赖

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

    <dependency>
          <groupId>com.googlecode.aviator</groupId>
          <artifactId>aviator</artifactId>
          <version>{version}</version>
     </dependency>
    

    从 3.2.0 版本开始, Aviator 仅支持 JDK 7 及其以上版本。 JDK 6 请使用 3.1.1 这个稳定版本。

    4.使用手册

    1. 执行表达式
      Aviator的使用都是集中通过com.googlecode.aviator.AviatorEvaluator这个入口类来处理, 最简单的例子, 执行一个计算1+2+3的表达式:
    val result = AviatorEvaluator.execute("1+2+3")
    println(result)     //6
    

    如果开启了 ALWAYS_PARSE_FLOATING_POINT_NUMBER_INTO_DECIMAL 选项,那么在表达式中出现的浮点数都将解析为 BigDecimal,这是为了方便一些用户要求高精度的计算,又不想额外地给浮点数加上 M 后缀标记为 BigDecimal:

    AviatorEvaluator.setOption(Options.ALWAYS_PARSE_FLOATING_POINT_NUMBER_INTO_DECIMAL, true)
    
    1. 多行表达式
      从 4.0.0 开始, aviator支持以分号 ; 隔开的多行表达式,对于多行表达式求值的结果将是最后一个表达式的结果,例如
    val result = AviatorEvaluator.execute("println('hello world'); 1+2+3 ; 100-1")
    println(result) 
    //输出结果:
    //hello world
    //99
    

    表达式的结果将是最后一个表达式 100-1,也就是 99,但是中间的表达式也将执行,包括打印 hello world。通过在表达式求值过程中加入 println打印,可以方便调试,也可以通过 Options.TRACE_EVAL来跟踪执行过程,参见后续章节。

    1. 求值器多实例
      AviatorEvaluator是一个全局静态实例,但是很多场景下,你可能想为不同的场景提供一个不同的求值器实例,包括不同的选项配置和自定义函数列表等,那么从 4.0.0开始, Aviator提供了多实例的求值器支持:
    val instance = AviatorEvaluator.newInstance
    //接下来使用 instance,几乎跟 AviatorEvaluator 没有不同,只是换成了实例方法
    
    1. 使用变量
      下面的例子演示了怎么向表达式传入变量值, 表达式中的world是一个变量, 默认为null, 通过传入Map<String,Object>的变量绑定环境, 将world设置为“world”。 env 的key是变量名, value是变量的值。
    val world = "world"
    val env = new util.HashMap[String,Object]()
    env.put("world",world)
    val result =AviatorEvaluator.execute(" 'hello ' + world ",env)
    println(result)        //  hello world
    

    'hello ‘是一个Aviator的String, Aviator的String是任何用单引号或者双引号括起来的字符序列, String可以比较大小(基于unicode顺序), 可以参与正则匹配, 可以与任何对象相加, 任何对象与String相加结果为String。 String中也可以有转义字符,如\n、\、’ 等。

    AviatorEvaluator.execute(" 'a\"b' ")                  // 字符串 a"b
    AviatorEvaluator.execute(" \"a\'b\" ")                // 字符串 a'b
    AviatorEvaluator.execute(" 'hello ' + 3 ")              // 字符串 hello 3
    AviatorEvaluator.execute(" 'hello '+ unknow ")         // 字符串 hello null
    
    1. exec 方法
      Aviator 2.2 开始新增加一个exec方法, 可以更方便地传入变量并执行, 而不需要构造env这个map了:
    val value = "world"
    AviatorEvaluator.exec("'hello' + value",value)        //  hello world
    
    1. 调用函数
      Aviator 支持函数调用, 函数调用的风格类似 lua, 下面的例子获取字符串的长度:
    AviatorEvaluator.execute("string.length('hello')") 
    

    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’中。可以看到, 函数可以嵌套调用。

    1. 自定义函数
      Aviator除了内置的函数之外,还允许用户自定义函数,只要实现com.googlecode.aviator.runtime.type.AviatorFunction接口, 并注册到AviatorEvaluator即可使用. AviatorFunction接口十分庞大, 通常来说你并不需要实现所有的方法, 只要根据你的方法的参数个数, 继承AbstractFunction类并override相应方法即可。
    object test {
      def main(args: Array[String]): Unit = {
        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 def call(env: java.util.Map[String, Object], arg1: AviatorObject, arg2: AviatorObject): AviatorObject = {
        val left = FunctionUtils.getNumberValue(arg1, env)
        val right = FunctionUtils.getNumberValue(arg2, env)
        new AviatorDouble(left.doubleValue + right.doubleValue)
      }
    
      def getName = "add"
    }
    

    注册函数通过AviatorEvaluator.addFunction方法, 移除可以通过removeFunction。另外, FunctionUtils 提供了一些方便参数类型转换的方法。

    如果你的参数个数不确定,可以继承 AbstractVariadicFunction 类,只要实现其中的 variadicCall 方法即可,比如我们实现一个找到第一个参数不为 null 的函数:

    object test {
      def main(args: Array[String]): Unit = {
        AviatorEvaluator.addFunction(new GetFirstNonNullFunction)
        System.out.println(AviatorEvaluator.execute("getFirstNonNull(1)")) // 1
        System.out.println(AviatorEvaluator.execute("getFirstNonNull(1,2,3,4,nil,5)")) // 1
        System.out.println(AviatorEvaluator.execute("getFirstNonNull(a,b,c,d)")) // null
      }
    }
    class GetFirstNonNullFunction extends AbstractVariadicFunction {
      override def variadicCall(env: util.Map[String, AnyRef], args: AviatorObject*): AviatorObject = {
        if (args != null) for (arg <- args) {
          if (arg.getValue(env) != null) return arg
        }
        new AviatorString(null)
      }
    
      override def getName = "getFirstNonNull"
    
    }
    

    当然,同时你仍然覆写特定的 call 方法来自定义实现。
    自定义函数在 4.0.0 之后也可以通过 lambda 来定义:

    AviatorEvaluator.defineFunction("add", "lambda (x,y) -> x + y end")
    AviatorEvaluator.exec("add(1,2)")    //3
    
    1. 函数加载器
      从 4.0.0 开始,Aviator 还支持 FunctionLoader接口,可以用于自定义函数加载器:
    class function extends FunctionLoader{
      /**
        * Invoked when function not found
        *
        * @param name function name
        */
      override def onFunctionNotFound(name: String): AviatorFunction = ???
    }
    

    用户可以自主实现函数加载器,当函数不能从当前求值器中找到的时候,将调用 loader 的onFunctionNotFound 方法进行查找。自定义的加载器,通过 AviatorEvaluator.addFunctionLoader(loader)注册,可以注册多个加载器,加载顺序将按照添加顺序进行查找,其中任何一个找到,都将中断查找过程。

    1. 重载运算符
      Aviator 支持的运算符参见操作符一节。部分用户可能有重载这些内置运算符的需求,例如在 Excel 里, & 不是位运算,而是字符串连接符,那么你可以通过 3.3.0 版本支持的运算符重载来实现:
    AviatorEvaluator.addOpFunction(OperatorType.BIT_AND, new AbstractFunction() {
          override def call(env: util.Map[String, Object], arg1: AviatorObject, arg2: AviatorObject) = new AviatorString(arg1.getValue(env).toString + arg2.getValue(env).toString)
    
          override def getName = "&"
        })
    

    AviatorEvaluator.addOpFunction(opType, func) 就可以重载指定的运算符,重载后运行即可看到:

    val map = new util.HashMap[String,Object]()
    map.put("a","4")
    val result = AviatorEvaluator.execute("a&3", map)
    println(result)      //43
    val map1 = new util.HashMap[String,Object]()
    map1.put("a","hello")
    val result1 =  AviatorEvaluator.execute("a&' world'", map1)
    println(result1)    //hello world
    

    请注意,运算符重载使用不当,一定程度上会带来混乱,并且有一定的性能损失,请慎重使用。

    1. 编译表达式
      上面提到的例子都是直接执行表达式, 事实上 Aviator 背后都帮你做了编译并执行的工作。 你可以自己先编译表达式, 返回一个编译的结果, 然后传入不同的env来复用编译结果, 提高性能, 这是更推荐的使用方式:
    val expression = "a-(b-c)>100"
    // 编译表达式
    val compiledExp = AviatorEvaluator.compile(expression)
    val env = new util.HashMap[String,Object]()
    env.put("a", 100.3.asInstanceOf[Object])
    env.put("b", new Integer(45))
    env.put("c", (-199.100).asInstanceOf[Object])
    // 执行表达式
    val result = compiledExp.execute(env).asInstanceOf[Boolean]
    println(result) // false
    

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

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

    public static Expression compile(final String expression, final boolean cached)
    

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

    public static void invalidateCache(String expression)
    
    1. 访问数组和集合
      可以通过中括号去访问数组和java.util.List对象, 可以通过map.key访问java.util.Map中key对应的value, 一个例子:
    val list = new util.ArrayList[String]
    list.add("hello")
    list.add(" world")
    val array = new Array[Int](3)
    array(0) = 0
    array(1) = 1
    array(2) = 3
    val map = new util.HashMap[String,Object]()
    map.put("date", new Date())
    val env = new util.HashMap[String,Object]()
    env.put("list", list)
    env.put("array", array)
    env.put("mmap", map)
    println(AviatorEvaluator.execute("list[0]+list[1]", env)) // hello world
    
    println(AviatorEvaluator.execute("'array[0]+array[1]+array[2]=' + (array[0]+array[1]+array[2])", env)) // array[0]+array[1]+array[2]=4
    
    println(AviatorEvaluator.execute("'today is ' + mmap.date ", env)) // today is Tue Mar 19 11:42:51 CST 2019
    

    如果函数调用或者括号表达式结果是一个数组或者List,你同样可以可以通过 [index] 访问:

    println(AviatorEvaluator.exec("string.split(s,',')[0]", "a,b,c,d"))    //a
    
    1. 三元操作符
      Aviator 不提供if else语句, 但是提供了三元操作符?:用于条件判断,使用上与 java 没有什么不同:
    println(AviatorEvaluator.exec("a>0? 'yes':'no'", new Integer(1))) // yes
    

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

    1. 正则表达式匹配
      Aviator 支持类 Ruby 和 Perl 风格的表达式匹配运算,通过=~操作符, 如下面这个例子匹配 email 并提取用户名返回:
    val email = "killme2008@gmail.com"
    val env = new util.HashMap[String,Object]()
    env.put("email", email)
    val username = AviatorEvaluator.execute("email=~/([\\w0-8]+)@\\w+[\\.\\w+]+/ ? $1 : 'unknow' ", env).asInstanceOf[String]
    println(username) // killme2008
    

    email与正则表达式/([\w0-8]+@\w+[\.\w+]+)/通过=~操作符来匹配,结果为一个 Boolean 类 型, 因此可以用于三元表达式判断,匹配成功的时候返回$1,指代正则表达式的分组 1,也就是用户名,否则返回unknown。
    Aviator 在表达式级别支持正则表达式,通过//括起来的字符序列构成一个正则表达式,正则表达式可以用于匹配(作为=~的右操作数)、比较大小。但是匹配仅能与字符串进行匹配。匹配成功后, Aviator 会自动将匹配成功的捕获分组(capturing groups) 放入 env ${num}的变量中,其中$0 指代整个匹配的字符串,而$1表示第一个分组,$2表示第二个分组以此类推。
    请注意,分组捕获放入 env 是默认开启的,因此如果传入的 env 不是线程安全并且被并发使用,可能存在线程安全的隐患。关闭分组匹配,可以通过 AviatorEvaluator.setOption(Options.PUT_CAPTURING_GROUPS_INTO_ENV, false); 来关闭,对性能有稍许好处。
    Aviator 的正则表达式规则跟 Java 完全一样,因为内部其实就是使用java.util.regex.Pattern做编译的。

    1. 变量的语法糖
      Aviator 有个方便用户使用变量的语法糖, 当你要访问变量a中的某个属性b, 那么你可以通过a.b访问到, 更进一步, a.b.c将访问变量a的b属性中的c属性值, 推广开来也就是说 Aviator 可以将变量声明为嵌套访问的形式。
      TestAviator类符合JavaBean规范, 并且是 public 的,我们就可以使用语法糖:
    object test { 
    
      def main(args: Array[String]): Unit = {
        val foo = new Foo(100, 3.14f, new Date())
        val env = new util.HashMap[String,Object]()
        env.put("foo", foo)
        println(AviatorEvaluator.execute("'foo.i = '+foo.i", env)) // foo.i = 100
    
        println(AviatorEvaluator.execute("'foo.f = '+foo.f", env)) // foo.f = 3.14
    
        println(AviatorEvaluator.execute("'foo.date.year = '+(foo.date.year+1900)", env)) // foo.date.year = 2019
    
      }
    }
    
    class Foo(var i: Int, var f: Float, var date: Date) {
    
      def getI: Int = i
    
      def setI(i: Int): Unit = {
        this.i = i
      }
    
      def getF: Float = f
    
      def setF(f: Float): Unit = {
        this.f = f
      }
    
      def getDate: Date = date
    
      def setDate(date: Date): Unit = {
        this.date = date
      }
    }
    
    1. 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

    1. 日期比较
      Aviator 并不支持日期类型,如果要比较日期,你需要将日期写字符串的形式,并且要求是形如 “yyyy-MM-dd HH:mm:ss:SS”的字符串,否则都将报错。 字符串跟java.util.Date比较的时候将自动转换为Date对象进行比较:
    val env = new util.HashMap[String,Object]()
    val date = new Date()
    val dateStr = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS").format(date)
    env.put("date", date)
    env.put("dateStr", dateStr)
    var result = AviatorEvaluator.execute("date==dateStr", env).asInstanceOf[Boolean]
    println(result) // true
    result = AviatorEvaluator.execute("date > '2010-12-20 00:00:00:00' ", env).asInstanceOf[Boolean]
    println(result)// true
    result = AviatorEvaluator.execute("date < '2200-12-20 00:00:00:00' ", env).asInstanceOf[Boolean]
    println(result)// true
    result = AviatorEvaluator.execute("date==date ", env).asInstanceOf[Boolean]
    println(result)// true
    

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

    1. 大数计算和精度
      从 2.3.0 版本开始,aviator 开始支持大数字计算和特定精度的计算, 本质上就是支持java.math.BigInteger和java.math.BigDecimal两种类型, 这两种类型在 aviator 中简称为big int和decimal类型。 类似99999999999999999999999999999999这样的数字在 Java 语言里是没办法编译通过 的, 因为它超过了Long类型的范围, 只能用BigInteger来封装。但是 aviator 通过包装,可以直接支持这种大整数的计算,例如:
    println(AviatorEvaluator.execute("99999999999999999999999999999999 + 99999999999999999999999999999999"))
    //结果:199999999999999999999999999999998
    
    1. 字面量表示
      big int和decimal的表示与其他数字不同,两条规则:
      以大写字母N为后缀的整数都被认为是big int,如1N,2N,9999999999999999999999N等, 都是big int类型。
      超过long范围的整数字面量都将自动转换为big int类型。
      以大写字母M为后缀的数字都被认为是decimal, 如1M,2.222M, 100000.9999M等, 都是decimal类型。
      用户也可以通过变量传入这两种类型来参与计算。
      如果用户觉的给浮点数添加 M 后缀比较繁琐,也可以强制所有浮点数解析为 BigDecimal,通过代码开启下列选项即可:
    AviatorEvaluator.setOption(Options.ALWAYS_PARSE_FLOATING_POINT_NUMBER_INTO_DECIMAL, true)
    
    1. 运算
      big int和decimal的运算,跟其他数字类型long,double没有什么区别,操作符仍然是一样的。 aviator重载了基本算术操作符来支持这两种新类型:
    var rt = AviatorEvaluator.exec("9223372036854775807100.356M * 2")
    println(rt + " " + rt.getClass) // 18446744073709551614200.712 class java.math.BigDecimal
    rt = AviatorEvaluator.exec("92233720368547758074+1000")
    println(rt + " " + rt.getClass) // 92233720368547759074 class java.math.BigInteger
    val a = new BigInteger(String.valueOf(Long.MaxValue) + String.valueOf(Long.MaxValue))
    val b = new java.math.BigDecimal("3.2")
    val c = new java.math.BigDecimal("9999.99999")
    rt = AviatorEvaluator.exec("a+10000000000000000000", a)
    println(rt + " " + rt.getClass) // 92233720368547758089223372036854775807 class java.math.BigInteger
    rt = AviatorEvaluator.exec("b+c*2", b, c)
    println(rt + " " + rt.getClass) // 20003.19998 class java.math.BigDecimal
    rt = AviatorEvaluator.exec("a*b/c", a, b, c)
    println(rt + " " + rt.getClass) // 2.951479054745007313280155218459508E+34 class java.math.BigDecimal
    
    1. 类型转换和提升
      当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.setOption(Options.MATH_CONTEXT, MathContext.DECIMAL64)
    

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

    1. 强大的 seq 库
      aviator 拥有强大的操作集合和数组的 seq 库。整个库风格类似函数式编程中的高阶函数。在 aviator 中, 数组以及java.util.Collection下的子类都称为seq,可以直接利用 seq 库进行遍历、过滤和聚合等操作。
      例如,假设我有个 list:
    val env = new util.HashMap[String,Object]()
    val list = new util.ArrayList[Integer]
    list.add(3)
    list.add(20)
    list.add(10)
    env.put("list", list)
    var result = AviatorEvaluator.execute("count(list)", env)
    println(result) // 3
    result = AviatorEvaluator.execute("reduce(list,+,0)", env)
    println(result) // 33
    result = AviatorEvaluator.execute("filter(list,seq.gt(9))", env)
    println(result) // [20, 10]
    result = AviatorEvaluator.execute("include(list,10)", env)
    println(result) // true
    result = AviatorEvaluator.execute("sort(list)", env)
    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打印每个元素
    其他还有:
    seq.some(list, pred) 当集合中只要有一个元素满足谓词函数 pred 返回 true,立即返回 true,否则为 false。
    seq.every(list, pred) 当集合里的每个元素都满足谓词函数 pred 返回 true,则结果为 true,否则返回 false。
    seq.not_any(list, pred),当集合里的每个元素都满足谓词函数 pred 返回 false,则结果为 true,否则返回 false。
    以及 seq.or(p1, p2, …) 和 seq.and(p1, p2, …) 用于组合 seq.gt、seq.lt 等谓词函数。

    1. 两种运行模式
      默认 AviatorEvaluator 以执行速度优先:
    AviatorEvaluator.setOption(Options.OPTIMIZE_LEVEL, AviatorEvaluator.EVAL)
    

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

    AviatorEvaluator.setOption(Options.OPTIMIZE_LEVEL, AviatorEvaluator.COMPILE)
    
    1. 调试信息
      如果想查看每个表达式生成的字节码,可以通过打开 Trace 选项:
    AviatorEvaluator.setOption(Options.TRACE, true)
    

    默认是打印到标准输出,你可以改变输出指向:

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

    5.语法手册

    下面是 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返回的结果类型一致。

    6.内置函数

    完整的内置函数列表参见内置函数。
    点击此处

    7.选项列表

    AviatorEvaluator.setOption(opt, val) 支持定义求值器的行为,完整的 Options 枚举选项参见完整选项说明
    点击此处

    8.JavaDoc

    点击此处

    9.4.0功能详解

    点击此处

    10.参考链接

    主页
    示例
    官方指南

    展开全文
  • 转载: http://www.cnblogs.com/whgk/p/6600393.html ... 一、什么是Ognl?  通过百度百科查询到的解释,其中详细的说明了OGNL的作用。... 下面我们就对OGNL这5个作用进行讲解 ... 1、存取对象的任意...
  • google aviator表达式引擎

    千次阅读 2018-11-15 16:52:16
    现在已经有很多开源可用的 java 表达式引擎,什么还需要 Avaitor 呢? Aviator的设计目标是轻量级和高性能,相比于Groovy、JRuby的笨重, Aviator非常小, 加上依赖包也才450K,不算依赖包的话只有 70K; 当然, ...
  • 栈实现表达式(C语言)

    万次阅读 多人点赞 2016-10-28 11:32:41
    刚刚学习C语言的时候很多人就写过计算器,但是当时写的计算器只能进行一步四则运算;对于一次输入(1+2)*3+4这样的运算则没有办法计算。 本篇博文利用栈这种数据结构实现了支持带括号的表达式计算器;栈有栈底和...
  • Aviator 表达式引擎开源框架

    万次阅读 2010-12-17 15:22:00
    现在已经有很多开源可用的java表达式引擎,什么还需要Avaitor呢? Aviator的设计目标是轻量级和高性能 ,相比于Groovy、JRuby的笨重,Aviator非常小,加上依赖包也才450K,不算依赖包的话只有70K;当然,...
  • 前言:二叉树的一种应用是无歧义地表示代数、关系或逻辑表达式。在上个世纪20年代初期,波兰的逻辑学家发明了一种命题逻辑的特殊表示方法,允许从公式中删除所有括号,称之波兰表示法。但是,与原来带括号的公式...
  • 逻辑表达式

    千次阅读 2016-08-25 11:38:30
    1.比较表达式只能描述1个条件 2.逻辑表达式可以描述多个条件,并且使用逻辑运算符来指定多个条件之间的关系 符号 含义 && 与 ll ! 非 * 逻辑与表达式逻辑与:由&&连接起来的逻辑表达式,只要当两边的条件都...
  • 复合表达式的求

    千次阅读 2007-08-13 19:54:00
    含有两个更多操作符的表达式称为复合表达式(compound expression).在复合表达式中,操作数和操作符的结合方式决定了整个表达式.表达式的结果会因为操作符和操作数的分组结合方式的不同而不同.操作数的分组结合...
  • 正则表达式简介——从01

    千次阅读 2007-06-08 14:46:00
    正则表达式简介——从01 (一)这些页包含的信息其目的是提供一个关于正则表达式的通用介绍。尽管试图让每个主题的内容都比较独立,但这些主题所包含的大部分信息都依赖于对前面所介绍的特性概念的理解。因此,...
  • 布尔表达式

    2020-03-11 16:21:50
    从最基本的层次来说,所有的布尔表达式,不论它的长短如何,其值只能是truefalse。 最简单的布尔表达式是等式(equality)。这种布尔表达式用来测试一个值是否与另一个值相同。它可以是一个简单的等式,例如: 2 == ...
  •  表达式的求上,java的选择非常多,强大的如Groovy、JRuby,N年没维护的beanshell,包括javaeye上朋友的IKExpression。什么还需要Aviator?或者说Aviator的特点是什么?  我将Aviator定位在Groovy这样全...
  • EL表达式

    千次阅读 2012-04-22 16:10:58
    EL表达式在je22开发中会程序员节省不少的代码,因为他是jsp代码的简化操作 。 EL的格式 ${要输出的属性} , EL表达式可以方便的操作 从另一个网页传递过来的参数 、 javaBean 、 获取属性等等。 下面是一些...
  • PostgreSQL SQL语法(二):值表达式

    千次阅读 2017-08-17 13:56:44
    值表达式被用于各种各样的环境中,例如在SELECT命令的目标列表中、作为INSERTUPDATE中的新列或者若干命令中的搜索条件。为了区别于一个表表达式(是一个表)的结果,一个值表达式的结果有时候被称为一个标量。...
  • print("数量{0},单价{1}".format(100,285.6)) print(str.format("数量{0},单价{1:3.2f}",100,285.6)) print("数量%4d,单价%3.3f"%(100,285.6)) 【填空题】Python表达式 17.0/3**2 的值为________________。...
  • var reg = /^[\w]{6,12}$/这个是正则表达式 ...^只是一个标记,说明正则表达式的开始,$结束的标记,与{}中的范围没有关系,经过测试{6,12}是没有错误的,也可以自行测试一下,找到一个更合适的表达式
  • JavaScript正则表达式

    千次阅读 2016-05-08 21:54:46
    之前好一段时间,自己很抵触“正则表达式”。一是,对其了解甚浅,不能很完整的掌握;再者,觉得好多需要正则的,要不网上可以找到,要不可以使用其他方式去实现。总之,对于正则毫无心得。 最近,看完了...
  • “栈”的典型应用—表达式(C语言实现)

    万次阅读 多人点赞 2012-06-13 00:30:20
    表达式是程序设计语言编译中的一个基本问题。它的实现就是对“栈”的典型应用。本文针对表达式使用的是最...操作数即可以是常量,也可以是被说明变量常量的标识符。 运算符可以分为算术运算,关系运算和
  •  lambda [参数1,参数2,.....]:表达式(默认只能写一个)  说明:  1.lambda 只是一个表达式,它用来创建一个函数对象  2.当lambda表达式调用时,先执行冒号(:)后的表达式,并返回表达式的结果的引用关系 ...
  • 并不是这个问题,跟宏没有关系,而是全局变量必须用常量常量表达式赋值。 我就很纳闷了,刚开始以为是宏定义不能够将赋值的变量再次赋给另一变量,纠结了好久,看来问题不在这儿,想想应该是全局变量不能够用...
  • core 表达式

    千次阅读 2018-06-14 16:44:55
    Cron表达式的格式{秒数} {分钟} {小时} {日期} {月份} {星期} {年份(可空)}字段允许允许的特殊字符秒0-59, - * /分0-59, - * /小时0-23, - * /日期1-31, - * ? / L W C月份1-12 或者 JAN-DEC, - * /星期1-7 或者...
  • 一实验目的 二实验要求及实验环境 1实验要求 2实验环境 三设计思想 1逻辑设计 2物理设计 四测试结果 五系统不足与经验体会 1系统不足 2经验体会 六源码
  • EL表达式详解

    万次阅读 多人点赞 2018-04-08 12:27:28
    1、EL表达式介绍 2、EL获取数据 3、EL中的内置对象 4、EL访问Bean的属性 5、EL访问数组中的数据 6、EL获取list中数据 7、EL访问Map 8、EL中的运算符(empty) 9、自定义EL函数 10、总结 ...
  • JS正则表达式完整版

    万次阅读 多人点赞 2018-07-17 13:14:13
    第一章 正则表达式字符匹配攻略 1 两种模糊匹配 2. 字符组 3. 量词 4. 多选分支 5. 案例分析 第1章 小结 第二章 正则表达式位置匹配攻略 1. 什么是位置呢? 2. 如何匹配位置呢? 3. 位置的特性 4. 相关...
  • Java正则表达式语法

    千次阅读 2014-03-13 23:53:05
    Java正则表达式 表达式意义: 1.字符 x 字符 x。例如a表示字符a \\ 反斜线字符。在书写时要写\\\\。(注意:因为java在第一次解析时,把\\\\解析成正则...\0n 带有八进制 0的字符 n (0 \0nn 带有八进制 0
  • JSTL表达式与EL表达式

    千次阅读 2015-11-04 17:25:34
    EL表达式1、EL简介1)语法结构${expression}2)[]与.运算符EL 提供.和[]两种运算符来存取数据。 当要存取的属性名称中包含一些特殊字符,如.?等并非字母数字的符号,就一定要使用 []。 例如: ${user.My-Name...
  • 正则表达式

    千次阅读 2017-01-18 14:33:23
    在很多文本编辑器其他工具里,正则表达式通常被用来检索替换那些符合某个模式的文本内容。许多程序设计语言都支持利用正则表达式进行字符串操作。例如,在Perl中就内建了一个功能强大的正则表达式引擎。正则...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 197,119
精华内容 78,847
关键字:

关系表达式的值只能为1或0