"Fossies" - the Fresh Open Source Software Archive

Member "elasticsearch-6.8.23/docs/painless/painless-variables.asciidoc" (29 Dec 2021, 5634 Bytes) of package /linux/www/elasticsearch-6.8.23-src.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format (assuming AsciiDoc format). Alternatively you can here view or download the uninterpreted source code file. A member file download can also be achieved by clicking within a package contents listing on the according byte size field.

Variables

A variable loads and stores a value for evaluation during operations.

Declaration

Declare a variable before use with the format of type followed by identifier. Declare an array type variable using an opening [ token and a closing ] token for each dimension directly after the identifier. Specify a comma-separated list of identifiers following the type to declare multiple variables in a single statement. Use an assignment operator combined with a declaration to immediately assign a value to a variable. A variable not immediately assigned a value will have a default value assigned implicitly based on the type.

Errors

  • If a variable is used prior to or without declaration.

Grammar

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

Examples

  • Different variations of variable declaration.

    int x;           (1)
    List y;          (2)
    int x, y = 5, z; (3)
    def d;           (4)
    int i = 10;      (5)
    float[] f;       (6)
    Map[][] m;       (7)
    1. declare int x; store default null to x

    2. declare List y; store default null to y

    3. declare int x; store default int 0 to x; declare int y; store int 5 to y; declare int z; store default int 0 to z;

    4. declare def d; store default null to d

    5. declare int i; store int 10 to i

    6. declare float[] f; store default null to f

    7. declare Map[][] m; store default null to m

Assignment

Use the assignment operator '=' to store a value in a variable for use in subsequent operations. Any operation that produces a value can be assigned to any variable as long as the types are the same or the resultant type can be implicitly cast to the variable type.

Errors

  • If the type of value is unable to match the type of variable.

Grammar

assignment: ID '=' expression

Examples

  • Variable assignment with an integer literal.

    int i;  (1)
    i = 10; (2)
    1. declare int i; store default int 0 to i

    2. store int 10 to i

  • Declaration combined with immediate assignment.

    int i = 10;     (1)
    double j = 2.0; (2)
    1. declare int i; store int 10 to i

    2. declare double j; store double 2.0 to j

  • Assignment of one variable to another using primitive type values.

    int i = 10; (1)
    int j = i;  (2)
    1. declare int i; store int 10 to i

    2. declare int j; load from iint 10; store int 10 to j

  • Assignment with reference types using the new instance operator.

    ArrayList l = new ArrayList(); (1)
    Map m = new HashMap();         (2)
    1. declare ArrayList l; allocate ArrayList instance → ArrayList reference; store ArrayList reference to l

    2. declare Map m; allocate HashMap instance → HashMap reference; implicit cast HashMap reference to Map referenceMap reference; store Map reference to m

  • Assignment of one variable to another using reference type values.

    List l = new ArrayList(); (1)
    List k = l;               (2)
    List m;                   (3)
    m = k;                    (4)
    1. declare List l; allocate ArrayList instance → ArrayList reference; implicit cast ArrayList reference to List referenceList reference; store List reference to l

    2. declare List k; load from lList reference; store List reference to k; (note l and k refer to the same instance known as a shallow-copy)

    3. declare List m; store default null to m

    4. load from kList reference; store List reference to m; (note l, k, and m refer to the same instance)

  • Assignment with array type variables using the new array operator.

    int[] ia1;                   (1)
    ia1 = new int[2];            (2)
    ia1[0] = 1;                  (3)
    int[] ib1 = ia1;             (4)
    int[][] ic2 = new int[2][5]; (5)
    ic2[1][3] = 2;               (6)
    ic2[0] = ia1;                (7)
    1. declare int[] ia1; store default null to ia1

    2. allocate 1-d int array instance with length [2]1-d int array reference; store 1-d int array reference to ia1

    3. load from ia11-d int array reference; store int 1 to index [0] of 1-d int array reference

    4. declare int[] ib1; load from ia11-d int array reference; store 1-d int array reference to ib1; (note ia1 and ib1 refer to the same instance known as a shallow copy)

    5. declare int[][] ic2; allocate 2-d int array instance with length [2, 5]2-d int array reference; store 2-d int array reference to ic2

    6. load from ic22-d int array reference; store int 2 to index [1, 3] of 2-d int array reference

    7. load from ia11-d int array reference; load from ic22-d int array reference; store 1-d int array reference to index [0] of 2-d int array reference; (note ia1, ib1, and index [0] of ia2 refer to the same instance)