Variables

    Variables are never allowed to shadow identifiers from an outer scope.

    It is generally preferable to use rather than var when declaring a variable. This causes less work for both humans and computers to do when reading code, and creates more optimization opportunities.

    Container level variables have static lifetime and are order-independent and lazily analyzed. The initialization value of container level variables is implicitly . If a container level variable is const then its value is comptime-known, otherwise it is runtime-known.

    container_level_variables.zig

    Shell

    1. $ zig test container_level_variables.zig
    2. 1/1 test "container level variables"... OK
    3. All 1 tests passed.

    Container level variables may be declared inside a struct, , or enum:

    namespaced_container_level_variable.zig

    1. const std = @import("std");
    2. const expect = std.testing.expect;
    4. test "namespaced container level variable" {
    5.     try expect(foo() == 1235);
    6.     try expect(foo() == 1236);
    7. }
    9. const S = struct {
    10.     var x: i32 = 1234;
    11. };
    13. fn foo() i32 {
    14.     return S.x;
    15. }

    It is also possible to have local variables with static lifetime by using containers inside functions.

    static_local_variable.zig

    1. const std = @import("std");
    4. test "static local variable" {
    5.     try expect(foo() == 1235);
    6.     try expect(foo() == 1236);
    7. }
    9. fn foo() i32 {
    10.     const S = struct {
    11.         var x: i32 = 1234;
    12.     };
    13.     S.x += 1;
    14.     return S.x;
    15. }

    Shell

    1. $ zig test static_local_variable.zig
    2. 1/1 test "static local variable"... OK
    3. All 1 tests passed.

    The extern keyword or builtin function can be used to link against a variable that is exported from another object. The export keyword or @export builtin function can be used to make a variable available to other objects at link time. In both cases, the type of the variable must be C ABI compatible.

    See also:

    A variable may be specified to be a thread-local variable using the threadlocal keyword:

    tls.zig

    1. $ zig test tls.zig
    2. 1/1 test "thread local storage"... OK
    3. All 1 tests passed.

    For , all thread local variables are treated as regular Container Level Variables.

    Thread local variables may not be const.

    Local variables occur inside , comptime blocks, and blocks.

    When a local variable is , it means that after initialization, the variable’s value will not change. If the initialization value of a const variable is comptime-known, then the variable is also comptime-known.

    A local variable may be qualified with the comptime keyword. This causes the variable’s value to be comptime-known, and all loads and stores of the variable to happen during semantic analysis of the program, rather than at runtime. All variables declared in a comptime expression are implicitly comptime variables.

    comptime_vars.zig

    1. const std = @import("std");
    2. const expect = std.testing.expect;
    4. test "comptime vars" {
    5.     var x: i32 = 1;
    6.     comptime var y: i32 = 1;
    8.     x += 1;
    9.     y += 1;
    11.     try expect(x == 2);
    12.     try expect(y == 2);
    14.     if (y != 2) {
    15.         // This compile error never triggers because y is a comptime variable,
    16.         // and so `y != 2` is a comptime value, and this if is statically evaluated.
    17.         @compileError("wrong y value");
    18. }

    Shell