---
title: Operators in the Flux language
description: Flux supports many types of operators including arithmetic operators, comparison operators, function operators, and others.
url: https://docs.influxdata.com/flux/v0/spec/operators/
estimated_tokens: 2799
product: Flux
version: v0
publisher: InfluxData
canonical: https://docs.influxdata.com/flux/v0/spec/operators/
date: '2023-11-06T17:08:22-07:00'
lastmod: '2023-11-06T17:08:22-07:00'
---

Flux includes the following types of operators:

* [Arithmetic operators](#arithmetic-operators)
* [Comparison operators](#comparison-operators)
* [Logical operators](#logical-operators)
* [Assignment operators](#assignment-operators)
* [Function operators](#function-operators)
* [String Operators](#string-operators)
* [Literal constructors](#literal-constructors)
* [Miscellaneous operators](#miscellaneous-operators)

*Also see:*

* [Operator precedence](#operator-precedence)

## Arithmetic operators

Arithmetic operators take two numerical values (either literals or variables) and
perform a calculation that returns a single numerical value.

|Operator| Description  |Example |Result|
|--------|--------------|--------|------|
|  `+`   |   Addition   |`1 + 1` | `2`  |
|  `-`   | Subtraction  |`3 - 2` | `1`  |
|  `*`   |Multiplication|`2 * 3` | `6`  |
|  `/`   |   Division   |`9 / 3` | `3`  |
|  `^`   |Exponentiation|`2 ^ 3` | `8`  |
|  `%`   |    Modulo    |`10 % 5`| `0`  |

> [!Note]
> In the current version of Flux, values used in arithmetic operations must
> be of the same numeric type (integer or float).
> Operations with values of different numeric types will result in a type error.

## Comparison operators

Comparison operators compare expressions and return true or false based on the comparison.

|Operator|          Description          |      Example      |Result |
|--------|-------------------------------|-------------------|-------|
|  `==`  |           Equal to            | `"abc" == "abc"`  |`true` |
|  `!=`  |         Not equal to          | `"abc" != "def"`  |`true` |
|  `<`   |           Less than           |      `1 < 2`      |`true` |
|  `>`   |         Greater than          |      `1 > 2`      |`false`|
|  `<=`  |      Less than or equal       |     `1 <= 2`      |`true` |
|  `>=`  |     Greater than or equal     |     `1 >= 2`      |`false`|
|  `=~`  |  Equal to regular expression  |`"abc" =~ /[a-z]*/`|`true` |
|  `!~`  |Not equal to regular expression|`"abc" !~ /[0-9]*/`|`true` |

> [!Note]
> The `>` and `<` operators also [compare the lexicographic order of strings](#string-operators).

## Logical operators

|Operator|                               Description                                |
|--------|--------------------------------------------------------------------------|
| `not`  | Returns `true` if right operand is `false`. Otherwise, returns `false`.  |
|`exists`|Returns `false` if right operand is ***null***. Otherwise, returns `true`.|
| `and`  |  Returns `true` if both operands are true. Otherwise, returns `false`.   |
|  `or`  |    Returns `true` if any operand is true. Otherwise, returns `false`.    |

#### Short-circuit evaluation

Flux logical operators observe the short-circuiting behavior seen in other programming languages.
The evaluation of the left-hand (LH) operand determines if the right-hand (RH) operand is evaluated.

* When the operator is `and` and the LH operand evaluates to `false`, the evaluation
  returns `false` without evaluating the RH operand.
* When the operator is `or` and the LH operand evaluates to `true`, the evaluation
  returns `true` without evaluating the RH operand.

## Assignment operators

An assignment operator assigns a value to its left operand based on the value of its right operand.

|Operator|                    Description                    |Example|Meaning|
|--------|---------------------------------------------------|-------|-------|
|  `=`   |Assign value of left expression to right expression|`x = y`| x = y |

## Function operators

Function operators facilitate the creation of functions and control the flow of data through operations.

|Operator| Description |          Examples           |                                                                                Meaning                                                                                |
|--------|-------------|-----------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|  `|>`  |Pipe‑forward |    `data |> function()`     |                                                 Tables contained in the “data” variable are piped into the function.                                                  |
|  `<-`  |Pipe‑receive |         `tables=<-`         |The “tables” variable or parameter is assigned to data piped into the operation. *This operator is used for any data type passed into a function; not just table data.*|
|  `=>`  |    Arrow    |`(r) => r.tag1 == "tagvalue"`|                                                   The arrow passes a record or parameters into function operations.                                                   |
|  `()`  |Function call|         `top(n:10)`         |                                   Call the `top` function setting the `n` parameter to `10` and perform the associated operations.                                    |

*See [Define custom functions](/flux/v0/define-functions/) for examples of function operators is use.*

## String Operators

String operators concatenate or compare string values.

|Operator|            Description            |   Examples    |Result |
|--------|-----------------------------------|---------------|-------|
|  `+`   |           Concatenation           | `"ab" + "c"`  |`"abc"`|
|  `<`   | Less than in lexicographic order  |`"ant" < "bee"`|`true` |
|  `>`   |Greater than in lexicographic order|`"ant" > "bee"`|`false`|

## Literal constructors

Literal constructors define fixed values.

|Operator|Description |
|--------|------------|
| `[ ]`  |List / array|
| `{ }`  |   Record   |
|  `""`  |   String   |

## Miscellaneous operators

|Operator|         Description         |          Example          |
|--------|-----------------------------|---------------------------|
| `( )`  |      Logical grouping       |`r._value / (r._value * 2)`|
|  `,`   |     Sequence delimiter      |   `item1, item2, item3`   |
|  `:`   |     Key-value separator     |      `{name: "Bob"}`      |
|  `.`   |Member access / dot reference|     `r._measurement`      |

## Operator precedence

The table below outlines operator precedence.
Operators with a lower number have higher precedence.

|Precedence|     Operator     |            Description             |
|----------|------------------|------------------------------------|
|    1     |      `a()`       |           Function call            |
|          |      `a[]`       |       Member or index access       |
|          |       `.`        |           Member access            |
|    2     |       `|>`       |            Pipe forward            |
|    3     |    `() => 1`     |          FunctionLiteral           |
|    4     |       `^`        |           Exponentiation           |
|    5     |   `*` `/` `%`    |Multiplication, division, and modulo|
|    6     |     `+` `-`      |      Addition and subtraction      |
|    7     |    `==` `!=`     |        Comparison operators        |
|          |     `<` `<=`     |                                    |
|          |     `>` `>=`     |                                    |
|          |    `=~` `!~`     |                                    |
|    8     |      `not`       |       Unary logical operator       |
|          |     `exists`     |        Null check operator         |
|    9     |      `and`       |            Logical AND             |
|    10    |       `or`       |             Logical OR             |
|    11    |`if` `then` `else`|            Conditional             |

[Expressions](/flux/v0/spec/expressions/)[Packages](/flux/v0/spec/packages/)

[operators](/flux/v0/tags/operators/)
| Operator | Description | Example | Result |
| --- | --- | --- | --- |
| Operator | Description | Example | Result |
| + | Addition | 1 + 1 | 2 |
| - | Subtraction | 3 - 2 | 1 |
| * | Multiplication | 2 * 3 | 6 |
| / | Division | 9 / 3 | 3 |
| ^ | Exponentiation | 2 ^ 3 | 8 |
| % | Modulo | 10 % 5 | 0 |

| Operator | Description | Example | Result |
| --- | --- | --- | --- |
| Operator | Description | Example | Result |
| == | Equal to | "abc" == "abc" | true |
| != | Not equal to | "abc" != "def" | true |
| < | Less than | 1 < 2 | true |
| > | Greater than | 1 > 2 | false |
| <= | Less than or equal | 1 <= 2 | true |
| >= | Greater than or equal | 1 >= 2 | false |
| =~ | Equal to regular expression | "abc" =~ /[a-z]*/ | true |
| !~ | Not equal to regular expression | "abc" !~ /[0-9]*/ | true |

| Operator | Description |
| --- | --- |
| Operator | Description |
| not | Returns  true  if right operand is  false . Otherwise, returns  false . |
| exists | Returns  false  if right operand is  null . Otherwise, returns  true . |
| and | Returns  true  if both operands are true. Otherwise, returns  false . |
| or | Returns  true  if any operand is true. Otherwise, returns  false . |

| Operator | Description | Example | Meaning |
| --- | --- | --- | --- |
| Operator | Description | Example | Meaning |
| = | Assign value of left expression to right expression | x = y | x = y |

| Operator | Description | Examples | Meaning |
| --- | --- | --- | --- |
| Operator | Description | Examples | Meaning |
| |> | Pipe‑forward | data |> function() | Tables contained in the “data” variable are piped into the function. |
| <- | Pipe‑receive | tables=<- | The “tables” variable or parameter is assigned to data piped into the operation.  This operator is used for any data type passed into a function; not just table data. |
| => | Arrow | (r) => r.tag1 == "tagvalue" | The arrow passes a record or parameters into function operations. |
| () | Function call | top(n:10) | Call the  top  function setting the  n  parameter to  10  and perform the associated operations. |

| Operator | Description | Examples | Result |
| --- | --- | --- | --- |
| Operator | Description | Examples | Result |
| + | Concatenation | "ab" + "c" | "abc" |
| < | Less than in lexicographic order | "ant" < "bee" | true |
| > | Greater than in lexicographic order | "ant" > "bee" | false |

| Operator | Description |
| --- | --- |
| Operator | Description |
| [ ] | List / array |
| { } | Record |
| "" | String |

| Operator | Description | Example |
| --- | --- | --- |
| Operator | Description | Example |
| ( ) | Logical grouping | r._value / (r._value * 2) |
| , | Sequence delimiter | item1, item2, item3 |
| : | Key-value separator | {name: "Bob"} |
| . | Member access / dot reference | r._measurement |

| Precedence | Operator | Description |
| --- | --- | --- |
| Precedence | Operator | Description |
| 1 | a() | Function call |
|  | a[] | Member or index access |
|  | . | Member access |
| 2 | |> | Pipe forward |
| 3 | () => 1 | FunctionLiteral |
| 4 | ^ | Exponentiation |
| 5 | *   /   % | Multiplication, division, and modulo |
| 6 | +   - | Addition and subtraction |
| 7 | ==   != | Comparison operators |
|  | <   <= |  |
|  | >   >= |  |
|  | =~   !~ |  |
| 8 | not | Unary logical operator |
|  | exists | Null check operator |
| 9 | and | Logical AND |
| 10 | or | Logical OR |
| 11 | if   then   else | Conditional |