« 运算符 运算符：数值 »
Elastic 文档 ›Painless 脚本语言 [8.16] ›Painless 语言规范

运算符：通用

编辑

运算符：通用

编辑

优先级

编辑

使用 优先级运算符 '()' 来保证表达式的求值顺序。用优先级运算符（括号括起来）封装的表达式会覆盖运算符之间现有的优先级关系，并在其他表达式之前按照由内向外的顺序进行求值。

语法

precedence: '(' expression ')';

示例

  • 带数值运算符的优先级。

    int x = (5+4)*6;   
int y = 12/(x-50);

    声明 int x；将 int 5 和 int 4 相加 → int 9；将 int 9 和 int 6 相乘 → int 54；将 int 54 存储到 x 中；（注意，由于优先级运算符的存在，加法在乘法之前求值）

    声明 int y；从 x 中加载 → int 54；从 int 54 中减去 int 50 → int 4；将 int 12 除以 int 4 → int 3；将 int 3 存储到 y 中；（注意，由于优先级运算符的存在，减法在除法之前求值）

函数调用

编辑

使用 函数调用运算符 () 来调用现有函数。一个 函数调用 在脚本中定义。

语法

function_call: ID '(' ( expression (',' expression)* )? ')'';

示例

  • 函数调用。

    int add(int x, int y) { 
      return x + y;
  }

int z = add(1, 2);

    定义一个名为 add 的函数，该函数返回 int 并且具有参数（int x、int y）

    声明 int z；调用 add 并传入参数（int 1、int 2）→ int 3；将 int 3 存储到 z 中

强制类型转换

编辑

显式强制类型转换会强制将原始类型的值转换为目标类型的等效值作为一种操作。使用 强制类型转换运算符 '()' 指定显式强制类型转换。有关更多信息，请参阅 强制类型转换。

条件运算符

编辑

条件运算符包含三个表达式。第一个表达式将使用预期的布尔结果类型进行求值。如果第一个表达式的值为 true，则将求值第二个表达式。如果第一个表达式的值为 false，则将求值第三个表达式。如果求值结果的类型不相同，则第二个和第三个表达式将被 提升。使用 条件运算符 '? :' 作为快捷方式，以避免在某些表达式中需要完整的 if/else 分支。

错误

  • 如果第一个表达式没有求值为布尔类型的值。
  • 如果第二个和第三个表达式的值无法提升。

语法

conditional: expression '?' expression ':' expression;

提升

byte

short

char

int

long

float

double

引用

def

byte

int

int

int

int

long

float

double

-

def

short

int

int

int

int

long

float

double

-

def

char

int

int

int

int

long

float

double

-

def

int

int

int

int

int

long

float

double

-

def

long

long

long

long

long

long

float

double

-

def

float

float

float

float

float

float

float

double

-

def

double

double

double

double

double

double

double

double

-

def

引用

-

-

-

-

-

-

-

对象 @

def

def

def

def

def

def

def

def

def

def

def

@ 如果两个引用类型的值相同，则不会发生此提升。

示例

  • 条件运算符的求值。

    boolean b = true;        
int x = b ? 1 : 2;       
List y = x > 1 ? new ArrayList() : null; 
def z = x < 2 ? x : 2.0;

    声明 boolean b；将 boolean true 存储到 b 中

    声明 int x；从 b 中加载 → boolean true 求值第一个表达式：int 1 → int 1；将 int 1 存储到 x 中

    声明 List y；从 x 中加载 → int 1；int 1 大于 int 1 → boolean false；求值第二个表达式：null → null；将 null 存储到 y 中；

    声明 def z；从 x 中加载 → int 1；int 1 小于 int 2 → boolean true；求值第一个表达式：从 x 中加载 → int 1；提升 int 1 和 double 2.0：结果 double；将 int 1 隐式转换为 double 1.0 → double 1.0；将 double 1.0 隐式转换为 def → def；将 def 存储到 z 中；

赋值

编辑

使用 赋值运算符 '=' 将值存储到变量或引用类型成员字段中，以便在后续操作中使用。任何生成值的运算都可以分配给任何变量/字段，只要 类型 相同或结果类型可以 隐式转换为 变量/字段类型。

有关使用变量的示例，请参阅 变量赋值。

错误

  • 如果值的类型无法与变量或字段的类型匹配。

语法

assignment: field '=' expression

示例

这些示例使用以下引用类型定义

name:
  Example

non-static member fields:
  * int x
  * def y
  * List z

  • 不同类型值的字段赋值。

    Example example = new Example(); 
example.x = 1;                   
example.y = 2.0;                 
example.z = new ArrayList();

    声明 Example example；分配 Example 实例 → Example 引用；将 Example 引用 存储到 example 中

    从 example 中加载 → Example 引用；将 int 1 存储到 Example 引用 的 x 中

    从 example 中加载 → Example 引用；将 double 2.0 隐式转换为 def → def；将 def 存储到 Example 引用 的 y 中

    从 example 中加载 → Example 引用；分配 ArrayList 实例 → ArrayList 引用；将 ArrayList 引用 隐式转换为 List 引用 → List 引用；将 List 引用 存储到 Example 引用 的 z 中

  • 从字段访问中进行字段赋值。

    Example example = new Example(); 
example.x = 1;                   
example.y = example.x;

    声明 Example example；分配 Example 实例 → Example 引用；将 Example 引用 存储到 example 中

    从 example 中加载 → Example 引用；将 int 1 存储到 Example 引用 的 x 中

    从 example 中加载 → Example 引用 @0；从 example 中加载 → Example 引用 @1；从 Example 引用 @1 的 x 中加载 → int 1；将 int 1 隐式转换为 def → def；将 def 存储到 Example 引用 @0 的 y 中；（注意 Example 引用 @0 和 Example 引用 @1 是相同的）

复合赋值

编辑

使用 复合赋值运算符 '$=' 作为赋值的快捷方式，其中将在变量/字段作为左侧表达式和单独的右侧表达式之间执行二元运算。

复合赋值等效于以下表达式，其中 V 是变量/字段，T 是变量/成员的类型。

V = (T)(V op expression);

运算符

下表显示了可在复合赋值中使用的运算符。每个运算符都遵循其常规定义中的强制类型转换/提升规则。对于数值运算，如果需要，在返回提升后的数值类型值到变量/字段的原始数值类型值时，会进行额外的隐式强制类型转换，这可能导致数据丢失。

运算符

复合符号

乘法

*=

除法

/=

取余

%=

加法

+=

减法

-=

左移

<<=

右移

>>=

无符号右移

>>>=

按位与

&=

布尔与

&=

按位异或

^=

布尔异或

^=

按位或

|=

布尔或

|=

字符串连接

+=

错误

  • 如果值的类型无法与变量或字段的类型匹配。

语法

compound_assignment: ( ID | field ) '$=' expression;

注意，$= 代表使用任何可能的二元运算符。

示例

  • 每个数值运算符的复合赋值。

    int i = 10; 
i *= 2;     
i /= 5;     
i %= 3;     
i += 5;     
i -= 5;     
i <<= 2;    
i >>= 1;    
i >>>= 1;   
i &= 15;    
i ^= 12;    
i |= 2;

    声明 int i；将 int 10 存储到 i 中

    从 i 中加载 → int 10；将 int 10 和 int 2 相乘 → int 20；将 int 20 存储到 i 中；（注意，这等效于 i = i*2）

    从 i 中加载 → int 20；将 int 20 除以 int 5 → int 4；将 int 4 存储到 i 中；（注意，这等效于 i = i/5）

    从 i 中加载 → int 4；将 int 4 对 int 3 取余 → int 1；将 int 1 存储到 i 中；（注意，这等效于 i = i%3）

    从 i 中加载 → int 1；将 int 1 和 int 5 相加 → int 6；将 int 6 存储到 i 中；（注意，这等效于 i = i+5）

    从 i 中加载 → int 6；从 int 6 中减去 int 5 → int 1；将 int 1 存储到 i 中；（注意，这等效于 i = i-5）

    从 i 中加载 → int 1；将 int 1 左移 int 2 位 → int 4；将 int 4 存储到 i 中；（注意，这等效于 i = i<<2）

    从 i 中加载 → int 4；将 int 4 右移 int 1 位 → int 2；将 int 2 存储到 i 中；（注意，这等效于 i = i>>1）

    从 i 中加载 → int 2；将 int 2 无符号右移 int 1 位 → int 1；将 int 1 存储到 i 中；（注意，这等效于 i = i>>>1）

    从 i 中加载 → int 1；将 int 1 和 int 15 按位与 → int 1；将 int 1 存储到 i 中；（注意，这等效于 i = i&2）

    从 i 中加载 → int 1；将 int 1 和 int 12 按位异或 → int 13；将 int 13 存储到 i 中；（注意，这等效于 i = i^2）

    从 i 中加载 → int 13；将 int 13 和 int 2 按位或 → int 15；将 int 15 存储到 i 中；（注意，这等效于 i = i|2）

  • 每个布尔运算符的复合赋值。

    boolean b = true; 
b &= false;       
b ^= false;       
b |= true;

    声明 boolean b；将 boolean true 存储到 b 中；

    从 b 加载 → 布尔值 true；布尔值与 布尔值 true 和 布尔值 false 进行与运算 → 布尔值 false；将 布尔值 false 存储到 b；（注意这等价于 b = b && false）

    从 b 加载 → 布尔值 false；布尔值与 布尔值 false 和 布尔值 false 进行异或运算 → 布尔值 false；将 布尔值 false 存储到 b；（注意这等价于 b = b ^ false）

    从 b 加载 → 布尔值 true；布尔值与 布尔值 false 和 布尔值 true 进行或运算 → 布尔值 true；将 布尔值 true 存储到 b；（注意这等价于 b = b || true）

  • 使用字符串连接运算符的复合赋值。

    String s = 'compound'; 
s += ' assignment';

    声明 字符串 s；将 字符串 'compound' 存储到 s；

    从 s 加载 → 字符串 'compound'；字符串连接 字符串 'compound' 和 字符串 ' assignment'' → 字符串 'compound assignment'；将 字符串 'compound assignment' 存储到 s；（注意这等价于 s = s + ' assignment'）

  • 使用 def 类型的复合赋值。

    def x = 1; 
x += 2;

    声明 def x；将 整数 1 隐式转换为 def；将 def 存储到 x；

    从 x 加载 → def；将 def 隐式转换为 整数 1 → 整数 1；将 整数 1 和 整数 2 进行加法运算 → 整数 3；将 整数 3 隐式转换为 def → def；将 def 存储到 x；（注意这等价于 x = x+2）

  • 带有额外隐式转换的复合赋值。

    byte b = 1; 
b += 2;

    声明 字节 b；将 字节 1 存储到 x；

    从 x 加载 → 字节 1；将 字节 1 隐式转换为 整数 1 → 整数 1；将 整数 1 和 整数 2 进行加法运算 → 整数 3；将 整数 3 隐式转换为 字节 3 → 字节 3；将 字节 3 存储到 b；（注意这等价于 b = b+2）
« 运算符 运算符：数值 »