« 标识符 类型 »
Elastic 文档 ›Painless 脚本语言 [8.17] ›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 维 int 数组实例 → 1 维 int 数组引用；将 1 维 int 数组引用 存储到 ia1

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

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

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

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

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