if

if.zig

  1. // If expressions have three uses, corresponding to the three types:
  2. // * bool
  3. // * ?T
  4. // * anyerror!T
  6. const expect = @import("std").testing.expect;
  8. test "if expression" {
  9.     // If expressions are used instead of a ternary expression.
  10.     const a: u32 = 5;
  11.     const b: u32 = 4;
  12.     const result = if (a != b) 47 else 3089;
  13.     try expect(result == 47);
  14. }
  16. test "if boolean" {
  17.     // If expressions test boolean conditions.
  18.     const a: u32 = 5;
  19.     const b: u32 = 4;
  20.     if (a != b) {
  21.         try expect(true);
  22.     } else if (a == 9) {
  23.         unreachable;
  24.     } else {
  25.         unreachable;
  26.     }
  27. }
  29. test "if optional" {
  30.     // If expressions test for null.
  32.     const a: ?u32 = 0;
  33.     if (a) |value| {
  34.         try expect(value == 0);
  35.     } else {
  36.         unreachable;
  37.     }
  39.     const b: ?u32 = null;
  40.     if (b) |_| {
  41.         unreachable;
  42.     } else {
  43.         try expect(true);
  44.     }
  46.     // The else is not required.
  47.     if (a) |value| {
  48.         try expect(value == 0);
  49.     }
  51.     // To test against null only, use the binary equality operator.
  52.     if (b == null) {
  53.         try expect(true);
  54.     }
  56.     // Access the value by reference using a pointer capture.
  57.     var c: ?u32 = 3;
  58.     if (c) |*value| {
  59.         value.* = 2;
  60.     }
  62.     if (c) |value| {
  63.         try expect(value == 2);
  64.     } else {
  65.         unreachable;
  66.     }
  67. }
  69. test "if error union" {
  70.     // If expressions test for errors.
  71.     // Note the |err| capture on the else.
  73.     const a: anyerror!u32 = 0;
  74.     if (a) |value| {
  75.         try expect(value == 0);
  76.     } else |err| {
  77.         _ = err;
  78.         unreachable;
  79.     }
  81.     const b: anyerror!u32 = error.BadValue;
  82.     if (b) |value| {
  83.         _ = value;
  84.         unreachable;
  85.     } else |err| {
  86.         try expect(err == error.BadValue);
  87.     }
  89.     // The else and |err| capture is strictly required.
  90.     if (a) |value| {
  91.         try expect(value == 0);
  92.     } else |_| {}
  94.     // To check only the error value, use an empty block expression.
  95.     if (b) |_| {} else |err| {
  96.         try expect(err == error.BadValue);
  97.     }
  99.     // Access the value by reference using a pointer capture.
  100.     var c: anyerror!u32 = 3;
  101.     if (c) |*value| {
  102.         value.* = 9;
  103.     } else |_| {
  104.         unreachable;
  105.     }
  107.     if (c) |value| {
  108.         try expect(value == 9);
  109.     } else |_| {
  110.         unreachable;
  111.     }
  112. }
  114. test "if error union with optional" {
  115.     // If expressions test for errors before unwrapping optionals.
  116.     // The |optional_value| capture's type is ?u32.
  118.     const a: anyerror!?u32 = 0;
  119.     if (a) |optional_value| {
  120.         try expect(optional_value.? == 0);
  121.     } else |err| {
  122.         _ = err;
  123.         unreachable;
  124.     }
  126.     const b: anyerror!?u32 = null;
  127.     if (b) |optional_value| {
  128.         try expect(optional_value == null);
  129.     } else |_| {
  130.         unreachable;
  131.     }
  133.     const c: anyerror!?u32 = error.BadValue;
  134.     if (c) |optional_value| {
  135.         _ = optional_value;
  136.         unreachable;
  137.     } else |err| {
  138.         try expect(err == error.BadValue);
  139.     }
  141.     // Access the value by reference by using a pointer capture each time.
  142.     var d: anyerror!?u32 = 3;
  143.     if (d) |*optional_value| {
  144.         if (optional_value.*) |*value| {
  145.             value.* = 9;
  146.         }
  147.     } else |_| {
  148.         unreachable;
  149.     }
  151.     if (d) |optional_value| {
  152.         try expect(optional_value.? == 9);
  153.     } else |_| {
  154.         unreachable;
  155.     }
  156. }

Shell

  1. $ zig test if.zig
  2. 1/5 test "if expression"... OK
  3. 2/5 test "if boolean"... OK
  4. 3/5 test "if optional"... OK
  5. 4/5 test "if error union"... OK
  6. 5/5 test "if error union with optional"... OK
  7. All 5 tests passed.

See also: