Arrays

    Shell

    2. 1/4 test "iterate over an array"... OK
    3. 2/4 test "modify an array"... OK
    4. 3/4 test "compile-time array initialization"... OK
    5. 4/4 test "array initialization with function calls"... OK
    6. All 4 tests passed.

    See also:

    Similar to and Anonymous Struct Literals the type can be omitted from array literals:

    anon_list.zig

    1. const std = @import("std");
    2. const expect = std.testing.expect;
    4. test "anonymous list literal syntax" {
    5.     var array: [4]u8 = .{11, 22, 33, 44};
    6.     try expect(array[0] == 11);
    7.     try expect(array[2] == 33);
    8.     try expect(array[3] == 44);
    9. }

    If there is no type in the result location then an anonymous list literal actually turns into a with numbered field names:

    infer_list_literal.zig

    2. const expect = std.testing.expect;
    4. test "fully anonymous list literal" {
    5.     try dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi"});
    6. }
    8. fn dump(args: anytype) !void {
    9.     try expect(args.@"0" == 1234);
    10.     try expect(args.@"1" == 12.34);
    11.     try expect(args.@"2");
    12.     try expect(args.@"3"[0] == 'h');
    13.     try expect(args.@"3"[1] == 'i');
    14. }

    Shell

    1. 1/1 test "fully anonymous list literal"... OK

    Multidimensional arrays can be created by nesting arrays:

    Shell

    1. $ zig test multidimensional.zig
    2. 1/1 test "multidimensional arrays"... OK
    3. All 1 tests passed.

    The syntax [N:x]T describes an array which has a sentinel element of value x at the index corresponding to len.

    null_terminated_array.zig

    1. const std = @import("std");
    2. const expect = std.testing.expect;
    4. test "null terminated array" {
    5.     const array = [_:0]u8 {1, 2, 3, 4};
    7.     try expect(@TypeOf(array) == [4:0]u8);
    8.     try expect(array.len == 4);
    9.     try expect(array[4] == 0);

    Shell