« 标识符 类型 »
Elastic 文档 ›Painless 脚本语言 [8.16] ›Painless 语言规范

变量

编辑

变量

编辑

变量用于加载和存储值，以便在运算期间进行评估。

声明

编辑

在使用变量之前，需要使用以下格式进行声明：类型 后跟 标识符。使用开括号 [ 和闭括号 ] 分别表示每个维度来声明 数组类型 变量。在类型后面指定以逗号分隔的标识符列表，可在单个语句中声明多个变量。使用赋值运算符结合声明，可以立即为变量赋值。未立即赋值的变量将根据类型隐式分配默认值。

错误

  • 如果在声明之前或未声明的情况下使用变量。

语法

declaration : type ID assignment? (',' ID assignment?)*;
type: ID ('.' ID)* ('[' ']')*;
assignment: '=' expression;

示例

  • 变量声明的不同变体。

    int x;           
List y;          
int x, y = 5, z; 
def d;           
int i = 10;      
float[] f;       
Map[][] m;

    声明 int x；将默认值 null 存储到 x 中

    声明 List y；将默认值 null 存储到 y 中

    声明 int x；将默认值 int 0 存储到 x 中；声明 int y；将 int 5 存储到 y 中；声明 int z；将默认值 int 0 存储到 z 中；

    声明 def d；将默认值 null 存储到 d 中

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

    声明 float[] f；将默认值 null 存储到 f 中

    声明 Map[][] m；将默认值 null 存储到 m 中

赋值

编辑

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

错误

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

语法

assignment: ID '=' expression

示例

  • 使用整数字面量进行变量赋值。

    int i;  
i = 10;

    声明 int i；将默认值 int 0 存储到 i 中

    将 int 10 存储到 i 中

  • 声明结合立即赋值。

    int i = 10;     
double j = 2.0;

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

    声明 double j；将 double 2.0 存储到 j 中

  • 使用基本类型值将一个变量赋值给另一个变量。

    int i = 10; 
int j = i;

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

    声明 int j；从 i 加载 → int 10；将 int 10 存储到 j 中

  • 使用新建实例运算符进行引用类型赋值。

    ArrayList l = new ArrayList(); 
Map m = new HashMap();

    声明 ArrayList l；分配 ArrayList 实例 → ArrayList 引用；将 ArrayList 引用 存储到 l 中

    声明 Map m；分配 HashMap 实例 → HashMap 引用；将 HashMap 引用 隐式转换为 Map 引用 → Map 引用；将 Map 引用 存储到 m 中

  • 使用引用类型值将一个变量赋值给另一个变量。

    List l = new ArrayList(); 
List k = l;               
List m;                   
m = k;

    声明 List l；分配 ArrayList 实例 → ArrayList 引用；将 ArrayList 引用 隐式转换为 List 引用 → List 引用；将 List 引用 存储到 l 中

    声明 List k；从 l 加载 → List 引用；将 List 引用 存储到 k 中；（注意 l 和 k 指向同一个实例，称为浅拷贝）

    声明 List m；将默认值 null 存储到 m 中

    从 k 加载 → List 引用；将 List 引用 存储到 m 中；（注意 l、k 和 m 指向同一个实例）

  • 使用新建数组运算符进行数组类型变量赋值。

    int[] ia1;                   
ia1 = new int[2];            
ia1[0] = 1;                  
int[] ib1 = ia1;             
int[][] ic2 = new int[2][5]; 
ic2[1][3] = 2;               
ic2[0] = ia1;

    声明 int[] ia1；将默认值 null 存储到 ia1 中

    分配长度为 [2] 的 1-d int 数组 实例 → 1-d int 数组引用；将 1-d int 数组引用 存储到 ia1 中

    从 ia1 加载 → 1-d int 数组引用；将 int 1 存储到 1-d int 数组引用 的索引 [0] 中

    声明 int[] ib1；从 ia1 加载 → 1-d int 数组引用；将 1-d int 数组引用 存储到 ib1 中；（注意 ia1 和 ib1 指向同一个实例，称为浅拷贝）

    声明 int[][] ic2；分配长度为 [2, 5] 的 2-d int 数组 实例 → 2-d int 数组引用；将 2-d int 数组引用 存储到 ic2 中

    从 ic2 加载 → 2-d int 数组引用；将 int 2 存储到 2-d int 数组引用 的索引 [1, 3] 中

    从 ia1 加载 → 1-d int 数组引用；从 ic2 加载 → 2-d int 数组引用；将 1-d int 数组引用 存储到 2-d int 数组引用 的索引 [0] 中；（注意 ia1、ib1 和 ia2 的索引 [0] 指向同一个实例）
« 标识符 类型 »