Values

values.zig

// Top-level declarations are order-independent:
const print = std.debug.print;
const std = @import("std");
const os = std.os;
const assert = std.debug.assert;
pub fn main() void {
    // integers
    const one_plus_one: i32 = 1 + 1;
    print("1 + 1 = {}\n", .{one_plus_one});
    // floats
    const seven_div_three: f32 = 7.0 / 3.0;
    print("7.0 / 3.0 = {}\n", .{seven_div_three});
    // boolean
    print("{}\n{}\n{}\n", .{
        true and false,
        true or false,
        !true,
    });
    // optional
    var optional_value: ?[]const u8 = null;
    assert(optional_value == null);
    print("\noptional 1\ntype: {s}\nvalue: {s}\n", .{
        @typeName(@TypeOf(optional_value)),
        optional_value,
    });
    optional_value = "hi";
    assert(optional_value != null);
    print("\noptional 2\ntype: {s}\nvalue: {s}\n", .{
        @typeName(@TypeOf(optional_value)),
        optional_value,
    });
    // error union
    var number_or_error: anyerror!i32 = error.ArgNotFound;
    print("\nerror union 1\ntype: {s}\nvalue: {}\n", .{
        @typeName(@TypeOf(number_or_error)),
        number_or_error,
    });
    number_or_error = 1234;
    print("\nerror union 2\ntype: {s}\nvalue: {}\n", .{
        @typeName(@TypeOf(number_or_error)),
        number_or_error,
    });
}

$ zig build-exe values.zig
$ ./values
1 + 1 = 2
7.0 / 3.0 = 2.33333325e+00
false
true
false
optional 1
type: ?[]const u8
value: null
optional 2
type: ?[]const u8
value: hi
error union 1
type: anyerror!i32
value: error.ArgNotFound
error union 2
type: anyerror!i32
value: 1234

Primitive Types

In addition to the integer types above, arbitrary bit-width integers can be referenced by using an identifier of i or u followed by digits. For example, the identifier i7 refers to a signed 7-bit integer. The maximum allowed bit-width of an integer type is 65535.

See also:

• Integers
• Floats
• void
• Errors
• @Type

Primitive Values

See also:

• Optionals
• undefined

String Literals and Unicode Code Point Literals

String literals are constant single-item Pointers to null-terminated byte arrays. The type of string literals encodes both the length, and the fact that they are null-terminated, and thus they can be coerced to both Slices and Null-Terminated Pointers. Dereferencing string literals converts them to Arrays.

The encoding of a string in Zig is de-facto assumed to be UTF-8. Because Zig source code is UTF-8 encoded, any non-ASCII bytes appearing within a string literal in source code carry their UTF-8 meaning into the content of the string in the Zig program; the bytes are not modified by the compiler. However, it is possible to embed non-UTF-8 bytes into a string literal using \xNN notation.

Unicode code point literals have type comptime_int, the same as Integer Literals. All Escape Sequences are valid in both string literals and Unicode code point literals.

In many other programming languages, a Unicode code point literal is called a “character literal”. However, there is no precise technical definition of a “character” in recent versions of the Unicode specification (as of Unicode 13.0). In Zig, a Unicode code point literal corresponds to the Unicode definition of a code point.

test.zig

const expect = @import("std").testing.expect;
const mem = @import("std").mem;
test "string literals" {
    const bytes = "hello";
    try expect(@TypeOf(bytes) == *const [5:0]u8);
    try expect(bytes.len == 5);
    try expect(bytes[1] == 'e');
    try expect(bytes[5] == 0);
    try expect('e' == '\x65');
    try expect('\u{1f4a9}' == 128169);
    try expect('💯' == 128175);
    try expect(mem.eql(u8, "hello", "h\x65llo"));
    try expect("\xff"[0] == 0xff); // non-UTF-8 strings are possible with \xNN notation.
}

$ zig test test.zig
Test [1/1] test "string literals"... 
All 1 tests passed.

See also:

• Arrays
• Zig Test
• Source Encoding

Escape Sequences

Note that the maximum valid Unicode point is 0x10ffff.

Multiline String Literals

Multiline string literals have no escapes and can span across multiple lines. To start a multiline string literal, use the \\ token. Just like a comment, the string literal goes until the end of the line. The end of the line is not included in the string literal. However, if the next line begins with \\ then a newline is appended and the string literal continues.

const hello_world_in_c =
    \\#include <stdio.h>
    \\
    \\int main(int argc, char **argv) {
    \\    printf("hello world\n");
    \\    return 0;
    \\}
;

See also:

• @embedFile

Assignment

Use the const keyword to assign a value to an identifier:

test.zig

const x = 1234;
fn foo() void {
    // It works at file scope as well as inside functions.
    const y = 5678;
    // Once assigned, an identifier cannot be changed.
    y += 1;
}
test "assignment" {
    foo();
}

$ zig test test.zig
./docgen_tmp/test.zig:8:7: error: cannot assign to constant
    y += 1;
      ^

const applies to all of the bytes that the identifier immediately addresses. Pointers have their own const-ness.

If you need a variable that you can modify, use the var keyword:

test.zig

const expect = @import("std").testing.expect;
test "var" {
    var y: i32 = 5678;
    y += 1;
    try expect(y == 5679);
}

$ zig test test.zig
Test [1/1] test "var"... 
All 1 tests passed.

Variables must be initialized:

test.zig

test "initialization" {
    var x: i32;
    x = 1;
}

$ zig test test.zig
./docgen_tmp/test.zig:2:5: error: variables must be initialized
    var x: i32;
    ^

undefined

Use undefined to leave variables uninitialized:

test.zig

const expect = @import("std").testing.expect;
test "init with undefined" {
    var x: i32 = undefined;
    x = 1;
    try expect(x == 1);
}

$ zig test test.zig
Test [1/1] test "init with undefined"... 
All 1 tests passed.

undefined can be coerced to any type. Once this happens, it is no longer possible to detect that the value is undefined. undefined means the value could be anything, even something that is nonsense according to the type. Translated into English, undefined means “Not a meaningful value. Using this value would be a bug. The value will be unused, or overwritten before being used.”

In Debug mode, Zig writes 0xaa bytes to undefined memory. This is to catch bugs early, and to help detect use of undefined memory in a debugger.