Documentation

Work with arrays

An array type is an ordered sequence of values of the same type.

Array syntax

An array literal contains a sequence of values (also known as elements) enclosed in square brackets ([]). Values are comma-separated and must be the same type.

Example arrays
["1st", "2nd", "3rd"]

[1.23, 4.56, 7.89]

[10, 25, -15]

Reference values in an array

Use bracket notation to reference reference a value in an array. Flux arrays use zero-based indexing. Provide the index of the value to reference.

arr = ["1st", "2nd", "3rd"]

arr[0]
// Returns 1st

arr[2]
// Returns 3rd

Operate on arrays

Iterate over an array

  1. Import the experimental/array package.
  2. Use array.map to iterate over elements in an array, apply a function to each element, and then return a new array.
import "experimental/array"

a = [
    {fname: "John", lname: "Doe", age: 42},
    {fname: "Jane", lname: "Doe", age: 40},
    {fname: "Jacob", lname: "Dozer", age: 21},
]

a |> array.map(fn: (x) => ({statement: "${x.fname} ${x.lname} is ${x.age} years old."}))

// Returns
// [
//     {statement: "John Doe is 42 years old."},
//     {statement: "Jane Doe is 40 years old."},
//     {statement: "Jacob Dozer is 21 years old."}
// ]

Check if a value exists in an array

Use the contains function to check if a value exists in an array.

names = ["John", "Jane", "Joe", "Sam"]

contains(value: "Joe", set: names)
// Returns true

Get the length of an array

Use the length function to get the length of an array (number of elements in the array).

names = ["John", "Jane", "Joe", "Sam"]

length(arr: names)
// Returns 4

Create a stream of tables from an array

  1. Import the array package.
  2. Use array.from() to return a stream of tables. The input array must be an array of records. Each key-value pair in the record represents a column and its value.
import "array"

arr = [
    {fname: "John", lname: "Doe", age: "37"},
    {fname: "Jane", lname: "Doe", age: "32"},
    {fname: "Jack", lname: "Smith", age: "56"},
]

array.from(rows: arr)
Output
fnamelnameage
JohnDoe37
JaneDoe32
JackSmith56

Compare arrays

Use the == comparison operator to check if two arrays are equal. Equality is based on values, their type, and order.

[1,2,3,4] == [1,3,2,4]
// Returns false

[12300.0, 34500.0] == [float(v: "1.23e+04"), float(v: "3.45e+04")]
// Returns true

Filter an array

  1. Import the experimental/array package.
  2. Use array.filter to iterate over and evaluate elements in an array with a predicate function and then return a new array with only elements that match the predicate.
import "experimental/array"

a = [1, 2, 3, 4, 5]

a |> array.filter(fn: (x) => x >= 3)
// Returns [3, 4, 5]

Merge two arrays

  1. Import the experimental/array package.
  2. Use array.concat to merge two arrays.
import "experimental/array"

a = [1, 2, 3]
b = [4, 5, 6]

a |> array.concat(v: b)
// Returns [1, 2, 3, 4, 5, 6]

Return the string representation of an array

Use display() to return Flux literal representation of an array as a string.

arr = [1, 2, 3]

display(v: arr)

// Returns "[1, 2, 3]"

Include the string representation of an array in a table

Use display() to return Flux literal representation of an array as a string and include it as a column value.

import "sampledata"

sampledata.string()
    |> map(fn: (r) => ({_time: r._time, exampleArray: display(v: [r.tag, r._value])}))

Output

_time (time)exampleArray (string)
2021-01-01T00:00:00Z[t1, smpl_g9qczs]
2021-01-01T00:00:10Z[t1, smpl_0mgv9n]
2021-01-01T00:00:20Z[t1, smpl_phw664]
2021-01-01T00:00:30Z[t1, smpl_guvzy4]
2021-01-01T00:00:40Z[t1, smpl_5v3cce]
2021-01-01T00:00:50Z[t1, smpl_s9fmgy]
2021-01-01T00:00:00Z[t2, smpl_b5eida]
2021-01-01T00:00:10Z[t2, smpl_eu4oxp]
2021-01-01T00:00:20Z[t2, smpl_5g7tz4]
2021-01-01T00:00:30Z[t2, smpl_sox1ut]
2021-01-01T00:00:40Z[t2, smpl_wfm757]
2021-01-01T00:00:50Z[t2, smpl_dtn2bv]

Was this page helpful?

Thank you for your feedback!


Upgrade to InfluxDB Cloud or InfluxDB 2.0!

InfluxDB Cloud and InfluxDB OSS 2.0 ready for production.