Variables

A variable is a unit of Memory storage.

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

It is generally preferable to use const 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.

Global Variables

Global variables are considered to be a top level declaration, which means that they are order-independent and lazily analyzed. The initialization value of global variables is implicitly comptime. If a global variable is const then its value is comptime-known, otherwise it is runtime-known.

global_variables.zig

  1. var y: i32 = add(10, x);
  2. const x: i32 = add(12, 34);
  4. test "global variables" {
  5.     expect(x == 46);
  6.     expect(y == 56);
  7. }
  9. fn add(a: i32, b: i32) i32 {
  10.     return a + b;
  11. }
  13. const std = @import("std");
  14. const expect = std.testing.expect;
  1. $ zig test global_variables.zig
  2. 1/1 test "global variables"... OK
  3. All 1 tests passed.

Global variables may be declared inside a struct, union, or enum:

namespaced_global.zig

  1. const std = @import("std");
  2. const expect = std.testing.expect;
  4. test "namespaced global variable" {
  5.     expect(foo() == 1235);
  6.     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. }
  1. $ zig test namespaced_global.zig
  2. 1/1 test "namespaced global variable"... OK
  3. All 1 tests passed.

The extern keyword 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:

Thread Local Variables

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

tls.zig

  1. const std = @import("std");
  2. const assert = std.debug.assert;
  4. threadlocal var x: i32 = 1234;
  6. test "thread local storage" {
  7.     const thread1 = try std.Thread.spawn({}, testTls);
  8.     const thread2 = try std.Thread.spawn({}, testTls);
  9.     testTls({});
  10.     thread1.wait();
  11.     thread2.wait();
  12. }
  14. fn testTls(context: void) void {
  15.     assert(x == 1234);
  16.     x += 1;
  17.     assert(x == 1235);
  18. }
  1. $ zig test tls.zig
  2. 1/1 test "thread local storage"... OK
  3. All 1 tests passed.

For Single Threaded Builds, all thread local variables are treated as Global Variables.

Thread local variables may not be const.

Local Variables

Local variables occur inside Functions, comptime blocks, and @cImport blocks.

When a local variable is const, 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.     expect(x == 2);
  12.     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.     }
  19. }
  1. $ zig test comptime_vars.zig
  2. 1/1 test "comptime vars"... OK
  3. All 1 tests passed.