108 lines
4.4 KiB
Plaintext
108 lines
4.4 KiB
Plaintext
---
|
|
page_title: Operators - Configuration Language
|
|
description: >-
|
|
Operators transform or combine expressions. Learn about arithmetic, logical,
|
|
equality, and comparison operators.
|
|
---
|
|
|
|
# Arithmetic and Logical Operators
|
|
|
|
An _operator_ is a type of expression that transforms or combines one or more
|
|
other expressions. Operators either combine two values in some way to
|
|
produce a third result value, or transform a single given value to
|
|
produce a single result.
|
|
|
|
Operators that work on two values place an operator symbol between the two
|
|
values, similar to mathematical notation: `1 + 2`. Operators that work on
|
|
only one value place an operator symbol before that value, like
|
|
`!true`.
|
|
|
|
The Terraform language has a set of operators for both arithmetic and logic,
|
|
which are similar to operators in programming languages such as JavaScript
|
|
or Ruby.
|
|
|
|
When multiple operators are used together in an expression, they are evaluated
|
|
in the following order of operations:
|
|
|
|
1. `!`, `-` (multiplication by `-1`)
|
|
1. `*`, `/`, `%`
|
|
1. `+`, `-` (subtraction)
|
|
1. `>`, `>=`, `<`, `<=`
|
|
1. `==`, `!=`
|
|
1. `&&`
|
|
1. `||`
|
|
|
|
Use parentheses to override the default order of operations. Without
|
|
parentheses, higher levels will be evaluated first, so Terraform will interpret
|
|
`1 + 2 * 3` as `1 + (2 * 3)` and _not_ as `(1 + 2) * 3`.
|
|
|
|
The different operators can be gathered into a few different groups with
|
|
similar behavior, as described below. Each group of operators expects its
|
|
given values to be of a particular type. Terraform will attempt to convert
|
|
values to the required type automatically, or will produce an error message
|
|
if automatic conversion is impossible.
|
|
|
|
## Arithmetic Operators
|
|
|
|
The arithmetic operators all expect number values and produce number values
|
|
as results:
|
|
|
|
* `a + b` returns the result of adding `a` and `b` together.
|
|
* `a - b` returns the result of subtracting `b` from `a`.
|
|
* `a * b` returns the result of multiplying `a` and `b`.
|
|
* `a / b` returns the result of dividing `a` by `b`.
|
|
* `a % b` returns the remainder of dividing `a` by `b`. This operator is
|
|
generally useful only when used with whole numbers.
|
|
* `-a` returns the result of multiplying `a` by `-1`.
|
|
|
|
Terraform supports some other less-common numeric operations as
|
|
[functions](/language/expressions/function-calls). For example, you can calculate exponents
|
|
using
|
|
[the `pow` function](/language/functions/pow).
|
|
|
|
## Equality Operators
|
|
|
|
The equality operators both take two values of any type and produce boolean
|
|
values as results.
|
|
|
|
* `a == b` returns `true` if `a` and `b` both have the same type and the same
|
|
value, or `false` otherwise.
|
|
* `a != b` is the opposite of `a == b`.
|
|
|
|
Because the equality operators require both arguments to be of exactly the
|
|
same type in order to decide equality, we recommend using these operators only
|
|
with values of primitive types or using explicit type conversion functions
|
|
to indicate which type you are intending to use for comparison.
|
|
|
|
Comparisons between structural types may produce surprising results if you
|
|
are not sure about the types of each of the arguments. For example,
|
|
`var.list == []` may seem like it would return `true` if `var.list` were an
|
|
empty list, but `[]` actually builds a value of type `tuple([])` and so the
|
|
two values can never match. In this situation it's often clearer to write
|
|
`length(var.list) == 0` instead.
|
|
|
|
## Comparison Operators
|
|
|
|
The comparison operators all expect number values and produce boolean values
|
|
as results.
|
|
|
|
* `a < b` returns `true` if `a` is less than `b`, or `false` otherwise.
|
|
* `a <= b` returns `true` if `a` is less than or equal to `b`, or `false`
|
|
otherwise.
|
|
* `a > b` returns `true` if `a` is greater than `b`, or `false` otherwise.
|
|
* `a >= b` returns `true` if `a` is greater than or equal to `b`, or `false` otherwise.
|
|
|
|
## Logical Operators
|
|
|
|
The logical operators all expect bool values and produce bool values as results.
|
|
|
|
* `a || b` returns `true` if either `a` or `b` is `true`, or `false` if both are `false`.
|
|
* `a && b` returns `true` if both `a` and `b` are `true`, or `false` if either one is `false`.
|
|
* `!a` returns `true` if `a` is `false`, and `false` if `a` is `true`.
|
|
|
|
Terraform does not have an operator for the "exclusive OR" operation. If you
|
|
know that both operators are boolean values then exclusive OR is equivalent
|
|
to the `!=` ("not equal") operator.
|
|
|
|
The logical operators in Terraform do not short-circuit, meaning `var.foo || var.foo.bar` will produce an error message if `var.foo` is `null` because both `var.foo` and `var.foo.bar` are evaluated.
|