Operators
- Operators
  - Table of Operators

Operators

There is no operator overloading. When you see an operator in Zig, you know that it is doing something from this table, and nothing else.

Table of Operators

Name	Syntax	Types	Remarks	Example
Addition	```
a + b
a += b
```

Integers
Floats

Can cause overflow for integers.
Invokes Peer Type Resolution for the operands.
See also @addWithOverflow.

| ``` 2 + 5 == 7

Wrapping Addition|  ```
a +% b
a +%= b
``` | 

  * Integers

| 

  * Twos-complement wrapping behavior.
  * Invokes Peer Type Resolution for the operands.
  * See also @addWithOverflow.

|  ```
@as(u32, 0xffffffff) +% 1 == 0

Saturating Addition| a +| b a +|= b |

Integers

Invokes Peer Type Resolution for the operands.

| ``` @as(u8, 255) +| 1 == @as(u8, 255)

Subtraction|  ```
a - b
a -= b
``` | 

  * Integers
  * Floats

| 

  * Can cause overflow for integers.
  * Invokes Peer Type Resolution for the operands.
  * See also @subWithOverflow.

|  ```
2 - 5 == -3

Wrapping Subtraction| a -% b a -%= b |

Integers

Twos-complement wrapping behavior.
Invokes Peer Type Resolution for the operands.
See also @subWithOverflow.

| ``` @as(u8, 0) -% 1 == 255

Saturating Subtraction|  ```
a -| b
a -|= b
``` | 

  * Integers

| 

  * Invokes Peer Type Resolution for the operands.

|  ```
@as(u32, 0) -| 1 == 0

Negation| -a |

Integers
Floats

Can cause overflow for integers.

| ``` -1 == 0 - 1

Wrapping Negation|  ```
-%a
``` | 

  * Integers

| 

  * Twos-complement wrapping behavior.

|  ```
-%@as(i8, -128) == -128

Multiplication| a b a = b |

Integers
Floats

Can cause overflow for integers.
Invokes Peer Type Resolution for the operands.
See also @mulWithOverflow.

| ``` 2 5 == 10

Wrapping Multiplication|  ```
a % b
a %= b
``` | 

  * Integers

| 

  * Twos-complement wrapping behavior.
  * Invokes Peer Type Resolution for the operands.
  * See also @mulWithOverflow.

|  ```
@as(u8, 200) % 2 == 144

Saturating Multiplication| a | b a |= b |

Integers

Invokes Peer Type Resolution for the operands.

| ``` @as(u8, 200) | 2 == 255

Division|  ```
a / b
a /= b
``` | 

  * Integers
  * Floats

| 

  * Can cause overflow for integers.
  * Can cause Division by Zero for integers.
  * Can cause Division by Zero for floats in FloatMode.Optimized Mode.
  * Signed integer operands must be comptime-known and positive. In other cases, use @divTrunc, @divFloor, or @divExact instead.
  * Invokes Peer Type Resolution for the operands.

|  ```
10 / 5 == 2

Remainder Division| a % b a %= b |

Integers
Floats

Can cause Division by Zero for integers.
Can cause Division by Zero for floats in FloatMode.Optimized Mode.
Signed or floating-point operands must be comptime-known and positive. In other cases, use @rem or @mod instead.
Invokes Peer Type Resolution for the operands.

| ``` 10 % 3 == 1

Bit Shift Left|  ```
a << b
a <<= b
``` | 

  * Integers

| 

  * Moves all bits to the left, inserting new zeroes at the least-significant bit.
  * `b` must be comptime-known or have a type with log2 number of bits as `a`.
  * See also @shlExact.
  * See also @shlWithOverflow.

|  ```
0b1 << 8 == 0b100000000

Saturating Bit Shift Left| a <<| b a <<|= b |

Integers

See also @shlExact.
See also @shlWithOverflow.

| ``` @as(u8, 1) <<| 8 == 255

Bit Shift Right|  ```
a >> b
a >>= b
``` | 

  * Integers

| 

  * Moves all bits to the right, inserting zeroes at the most-significant bit.
  * `b` must be comptime-known or have a type with log2 number of bits as `a`.
  * See also @shrExact.

|  ```
0b1010 >> 1 == 0b101

Bitwise And| a & b a &= b |

Integers

Invokes Peer Type Resolution for the operands.

| ``` 0b011 & 0b101 == 0b001

Bitwise Or|  ```
a | b
a |= b
``` | 

  * Integers

| 

  * Invokes Peer Type Resolution for the operands.

|  ```
0b010 | 0b100 == 0b110

Bitwise Xor| a ^ b a ^= b |

Integers

Invokes Peer Type Resolution for the operands.

| ``` 0b011 ^ 0b101 == 0b110

Bitwise Not|  ```
~a
``` | 

  * Integers

| |  ```
~@as(u8, 0b10101111) == 0b01010000

Defaulting Optional Unwrap| a orelse b |

Optionals

| If a is null, returns b (“default value”), otherwise returns the unwrapped value of a. Note that b may be a value of type noreturn.| ``` const value: ?u32 = null; const unwrapped = value orelse 1234; unwrapped == 1234

Optional Unwrap|  ```
a.?
``` | 

  * Optionals

| Equivalent to: ```
a orelse unreachable
``` |  ```
const value: ?u32 = 5678;
value.? == 5678

Defaulting Error Unwrap| a catch b a catch |err| b |

Error Unions

| If a is an error, returns b (“default value”), otherwise returns the unwrapped value of a. Note that b may be a value of type noreturn. err is the error and is in scope of the expression b.| ``` const value: anyerror!u32 = error.Broken; const unwrapped = value catch 1234; unwrapped == 1234

Logical And|  ```
a and b
``` | 

  * bool

| If `a` is `false`, returns `false` without evaluating `b`. Otherwise, returns `b`.|  ```
(false and true) == false

Logical Or| a or b |

bool

| If a is true, returns true without evaluating b. Otherwise, returns b.| ``` (false or true) == true

Boolean Not|  ```
!a
``` | 

  * bool

| |  ```
!false == true

Equality| a == b |

Integers
Floats
bool
type

| Returns true if a and b are equal, otherwise returns false. Invokes Peer Type Resolution for the operands.| ``` (1 == 1) == true

Null Check|  ```
a == null
``` | 

  * Optionals

| Returns `true` if a is `null`, otherwise returns `false`.|  ```
const value: ?u32 = null;
(value == null) == true

Inequality| a != b |

Integers
Floats
bool
type

| Returns false if a and b are equal, otherwise returns true. Invokes Peer Type Resolution for the operands.| ``` (1 != 1) == false

Non-Null Check|  ```
a != null
``` | 

  * Optionals

| Returns `false` if a is `null`, otherwise returns `true`.|  ```
const value: ?u32 = null;
(value != null) == false

Greater Than| a > b |

Integers
Floats

| Returns true if a is greater than b, otherwise returns false. Invokes Peer Type Resolution for the operands.| ``` (2 > 1) == true

Greater or Equal|  ```
a >= b
``` | 

  * Integers
  * Floats

| Returns `true` if a is greater than or equal to b, otherwise returns `false`. Invokes Peer Type Resolution for the operands.|  ```
(2 >= 1) == true

Less Than| a < b |

Integers
Floats

| Returns true if a is less than b, otherwise returns false. Invokes Peer Type Resolution for the operands.| ``` (1 < 2) == true

Lesser or Equal|  ```
a <= b
``` | 

  * Integers
  * Floats

| Returns `true` if a is less than or equal to b, otherwise returns `false`. Invokes Peer Type Resolution for the operands.|  ```
(1 <= 2) == true

Array Concatenation| a ++ b |

Arrays

Only available when the lengths of both a and b are compile-time known.

| ``` const mem = @import(“std”).mem; const array1 = []u32{1,2}; const array2 = []u32{3,4}; const together = array1 ++ array2; mem.eql(u32, &together, &[_]u32{1,2,3,4})

Array Multiplication|  ```
a  b
``` | 

  * Arrays

| 

  * Only available when the length of `a` and `b` are compile-time known.

|  ```
const mem = @import(“std”).mem;
const pattern = “ab”  3;
mem.eql(u8, pattern, “ababab”)

Pointer Dereference| a. |

Pointers

| Pointer dereference.| ``` const x: u32 = 1234; const ptr = &x; ptr. == 1234

Address Of|  ```
&a
``` | All types| |  ```
const x: u32 = 1234;
const ptr = &x;
ptr. == 1234

Error Set Merge| a || b |

Error Set Type

| Merging Error Sets| ``` const A = error{One}; const B = error{Two}; (A || B) == error{One, Two}


### Precedence

x() x[] x.y x. x.? a!b x{} !x -x -%x ~x &x ?x * / % ** % | || + - ++ +% -% +| -| << >> <<| & ^ | orelse catch == != < > <= >= and or = = %= |= /= %= += +%= +|= -= -%= -|= <<= <<|= >>= &= ^= |= ```