if

if.zig

  1. // If expressions have three uses, corresponding to the three types:
  2. // * bool
  3. // * ?T
  4. // * anyerror!T
  6. const assert = @import("std").debug.assert;
  8. test "if boolean" {
  9.     // If expressions test boolean conditions.
  10.     const a: u32 = 5;
  11.     const b: u32 = 4;
  12.     if (a != b) {
  13.         assert(true);
  14.     } else if (a == 9) {
  15.         unreachable;
  16.     } else {
  17.         unreachable;
  18.     }
  20.     // If expressions are used instead of a ternary expression.
  21.     const result = if (a != b) 47 else 3089;
  22.     assert(result == 47);
  23. }
  25. test "if optional" {
  26.     // If expressions test for null.
  28.     const a: ?u32 = 0;
  29.     if (a) |value| {
  30.         assert(value == 0);
  31.     } else {
  32.         unreachable;
  33.     }
  35.     const b: ?u32 = null;
  36.     if (b) |value| {
  37.         unreachable;
  38.     } else {
  39.         assert(true);
  40.     }
  42.     // The else is not required.
  43.     if (a) |value| {
  44.         assert(value == 0);
  45.     }
  47.     // To test against null only, use the binary equality operator.
  48.     if (b == null) {
  49.         assert(true);
  50.     }
  52.     // Access the value by reference using a pointer capture.
  53.     var c: ?u32 = 3;
  54.     if (c) |*value| {
  55.         value.* = 2;
  56.     }
  58.     if (c) |value| {
  59.         assert(value == 2);
  60.     } else {
  61.         unreachable;
  62.     }
  63. }
  65. test "if error union" {
  66.     // If expressions test for errors.
  67.     // Note the |err| capture on the else.
  69.     const a: anyerror!u32 = 0;
  70.     if (a) |value| {
  71.         assert(value == 0);
  72.     } else |err| {
  73.         unreachable;
  74.     }
  76.     const b: anyerror!u32 = error.BadValue;
  77.     if (b) |value| {
  78.         unreachable;
  79.     } else |err| {
  80.         assert(err == error.BadValue);
  81.     }
  83.     // The else and |err| capture is strictly required.
  84.     if (a) |value| {
  85.         assert(value == 0);
  86.     } else |_| {}
  88.     // To check only the error value, use an empty block expression.
  89.     if (b) |_| {} else |err| {
  90.         assert(err == error.BadValue);
  91.     }
  93.     // Access the value by reference using a pointer capture.
  94.     var c: anyerror!u32 = 3;
  95.     if (c) |*value| {
  96.         value.* = 9;
  97.     } else |err| {
  98.         unreachable;
  99.     }
  101.     if (c) |value| {
  102.         assert(value == 9);
  103.     } else |err| {
  104.         unreachable;
  105.     }
  106. }
  1. $ zig test if.zig
  2. 1/3 test "if boolean"...OK
  3. 2/3 test "if optional"...OK
  4. 3/3 test "if error union"...OK
  5. All tests passed.

See also: