Arrays

arrays.zig

  1. const assert = @import("std").debug.assert;
  2. const mem = @import("std").mem;
  4. // array literal
  5. const message = []u8{ 'h', 'e', 'l', 'l', 'o' };
  7. // get the size of an array
  8. comptime {
  9.     assert(message.len == 5);
  10. }
  12. // a string literal is an array literal
  13. const same_message = "hello";
  15. comptime {
  16.     assert(mem.eql(u8, message, same_message));
  17.     assert(@typeOf(message) == @typeOf(same_message));
  18. }
  20. test "iterate over an array" {
  21.     var sum: usize = 0;
  22.     for (message) |byte| {
  23.         sum += byte;
  24.     }
  25.     assert(sum == usize('h') + usize('e') + usize('l') * 2 + usize('o'));
  26. }
  28. // modifiable array
  29. var some_integers: [100]i32 = undefined;
  31. test "modify an array" {
  32.     for (some_integers) |*item, i| {
  33.         item.* = @intCast(i32, i);
  34.     }
  35.     assert(some_integers[10] == 10);
  36.     assert(some_integers[99] == 99);
  37. }
  39. // array concatenation works if the values are known
  40. // at compile time
  41. const part_one = []i32{ 1, 2, 3, 4 };
  42. const part_two = []i32{ 5, 6, 7, 8 };
  43. const all_of_it = part_one ++ part_two;
  44. comptime {
  45.     assert(mem.eql(i32, all_of_it, []i32{ 1, 2, 3, 4, 5, 6, 7, 8 }));
  46. }
  48. // remember that string literals are arrays
  49. const hello = "hello";
  50. const world = "world";
  51. const hello_world = hello ++ " " ++ world;
  52. comptime {
  53.     assert(mem.eql(u8, hello_world, "hello world"));
  54. }
  56. // ** does repeating patterns
  57. const pattern = "ab" ** 3;
  58. comptime {
  59.     assert(mem.eql(u8, pattern, "ababab"));
  60. }
  62. // initialize an array to zero
  63. const all_zero = []u16{0} ** 10;
  65. comptime {
  66.     assert(all_zero.len == 10);
  67.     assert(all_zero[5] == 0);
  68. }
  70. // use compile-time code to initialize an array
  71. var fancy_array = init: {
  72.     var initial_value: [10]Point = undefined;
  73.     for (initial_value) |*pt, i| {
  74.         pt.* = Point{
  75.             .x = @intCast(i32, i),
  76.             .y = @intCast(i32, i) * 2,
  77.         };
  78.     }
  79.     break :init initial_value;
  80. };
  81. const Point = struct {
  82.     x: i32,
  83.     y: i32,
  84. };
  86. test "compile-time array initalization" {
  87.     assert(fancy_array[4].x == 4);
  88.     assert(fancy_array[4].y == 8);
  89. }
  91. // call a function to initialize an array
  92. var more_points = []Point{makePoint(3)} ** 10;
  93. fn makePoint(x: i32) Point {
  94.     return Point{
  95.         .x = x,
  96.         .y = x * 2,
  97.     };
  98. }
  99. test "array initialization with function calls" {
  100.     assert(more_points[4].x == 3);
  101.     assert(more_points[4].y == 6);
  102.     assert(more_points.len == 10);
  103. }
  1. $ zig test arrays.zig
  2. Test 1/4 iterate over an array...OK
  3. Test 2/4 modify an array...OK
  4. Test 3/4 compile-time array initalization...OK
  5. Test 4/4 array initialization with function calls...OK
  6. All tests passed.

See also: