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

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

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

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

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

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