Slices

    Shell

    2. 1/1 test "basic slices"... thread 792342 panic: index out of bounds
    3. /home/andy/Downloads/zig/docgen_tmp/test.zig:22:10: 0x207c83 in test "basic slices" (test)
    4.     slice[10] += 1;
    5.          ^
    6. /home/andy/Downloads/zig/lib/std/special/test_runner.zig:80:28: 0x22f6d3 in std.special.main (test)
    7.         } else test_fn.func();
    8.                            ^
    9. /home/andy/Downloads/zig/lib/std/start.zig:543:22: 0x2280cc in std.start.callMain (test)
    10.             root.main();
    11.                      ^
    12. /home/andy/Downloads/zig/lib/std/start.zig:495:12: 0x20953e in std.start.callMainWithArgs (test)
    13.     return @call(.{ .modifier = .always_inline }, callMain, .{});
    14.            ^
    15. /home/andy/Downloads/zig/lib/std/start.zig:409:17: 0x2085d6 in std.start.posixCallMainAndExit (test)
    16.     std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
    17.                 ^
    18. /home/andy/Downloads/zig/lib/std/start.zig:322:5: 0x2083e2 in std.start._start (test)
    19.     @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    20.     ^
    21. error: the following test command crashed:
    22. docgen_tmp/zig-cache/o/8e4964e05ddaf866e77360a551b3c05b/test /home/andy/Downloads/zig/build-release/zig

    This is one reason we prefer slices to pointers.

    slices.zig

    1. const std = @import("std");
    2. const expect = std.testing.expect;
    3. const mem = std.mem;
    4. const fmt = std.fmt;
    6. test "using slices for strings" {
    7.     // Zig has no concept of strings. String literals are const pointers
    8.     // to null-terminated arrays of u8, and by convention parameters
    9.     // that are "strings" are expected to be UTF-8 encoded slices of u8.
    10.     // Here we coerce *const [5:0]u8 and *const [6:0]u8 to []const u8
    13.     var all_together: [100]u8 = undefined;
    14.     // You can use slice syntax on an array to convert an array into a slice.
    15.     const all_together_slice = all_together[0..];
    16.     // String concatenation example.
    17.     const hello_world = try fmt.bufPrint(all_together_slice, "{s} {s}", .{ hello, world });
    19.     // Generally, you can use UTF-8 and not worry about whether something is a
    20.     // string. If you don't need to deal with individual characters, no need
    21.     // to decode.
    22.     try expect(mem.eql(u8, hello_world, "hello 世界"));
    23. }
    25. test "slice pointer" {
    26.     var array: [10]u8 = undefined;
    27.     const ptr = &array;
    29.     // You can use slicing syntax to convert a pointer into a slice:
    30.     const slice = ptr[0..5];
    31.     slice[2] = 3;
    32.     try expect(slice[2] == 3);
    33.     // The slice is mutable because we sliced a mutable pointer.
    34.     // Furthermore, it is actually a pointer to an array, since the start
    35.     // and end indexes were both comptime-known.
    36.     try expect(@TypeOf(slice) == *[5]u8);
    38.     // You can also slice a slice:
    39.     const slice2 = slice[2..3];
    40.     try expect(slice2.len == 1);
    41.     try expect(slice2[0] == 3);
    42. }

    Shell

    The syntax [:x]T is a slice which has a runtime known length and also guarantees a sentinel value at the element indexed by the length. The type does not guarantee that there are no sentinel elements before that. Sentinel-terminated slices allow element access to the index.

    null_terminated_slice.zig

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

    Shell

    1. $ zig test null_terminated_slice.zig
    2. 1/1 test "null terminated slice"... OK
    3. All 1 tests passed.

    Sentinel-terminated slices can also be created using a variation of the slice syntax data[start..end :x], where data is a many-item pointer, array or slice and x is the sentinel value.

    Shell

    1. $ zig test null_terminated_slicing.zig
    2. 1/1 test "null terminated slicing"... OK
    3. All 1 tests passed.

    Sentinel-terminated slicing asserts that the element in the sentinel position of the backing data is actually the sentinel value. If this is not the case, safety-protected results.

    test.zig

    1. const std = @import("std");
    2. const expect = std.testing.expect;
    4. test "sentinel mismatch" {
    5.     var array = [_]u8{ 3, 2, 1, 0 };
    7.     // Creating a sentinel-terminated slice from the array with a length of 2 
    8.     // will result in the value `1` occupying the sentinel element position. 
    9.     // This does not match the indicated sentinel value of `0` and will lead 
    10.     // to a runtime panic.
    11.     var runtime_length: usize = 2;
    12.     const slice = array[0..runtime_length :0];
    14.     _ = slice;

    Shell