---
title: Work with arrays
description: An array type is an ordered sequence of values of the same type. Learn how to work with arrays in Flux.
url: https://docs.influxdata.com/flux/v0/data-types/composite/array/
estimated_tokens: 1654
product: Flux
version: v0
publisher: InfluxData
canonical: https://docs.influxdata.com/flux/v0/data-types/composite/array/
date: '2023-11-06T17:08:22-07:00'
lastmod: '2023-11-06T17:08:22-07:00'
---

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

* [Array syntax](#array-syntax)
* [Reference values in an array](#reference-values-in-an-array)
* [Operate on arrays](#operate-on-arrays)

## 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

```js
["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](#iterate-over-an-array)
* [Check if a value exists in an array](#check-if-a-value-exists-in-an-array)
* [Get the length of an array](#get-the-length-of-an-array)
* [Create a stream of tables from an array](#create-a-stream-of-tables-from-an-array)
* [Compare arrays](#compare-arrays)
* [Filter an array](#filter-an-array)
* [Merge two arrays](#merge-two-arrays)
* [Return the string representation of an array](#return-the-string-representation-of-an-array)
* [Include the string representation of an array in a table](#include-the-string-representation-of-an-array-in-a-table)

### Iterate over an array

1. Import the [`experimental/array` package](/flux/v0/stdlib/experimental/array/).
2. Use [`array.map`](/flux/v0/stdlib/experimental/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](/flux/v0/stdlib/universe/contains/) 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](/flux/v0/stdlib/universe/length/) 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](/flux/v0/stdlib/array/).
2. Use [`array.from()`](/flux/v0/stdlib/array/from/) to return a[stream of tables](/flux/v0/get-started/data-model/#stream-of-tables).
   The input array must be an array of [records](/flux/v0/data-types/composite/record/).
   Each key-value pair in the record represents a column and its value.

```js
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

|fname|lname|age|
|-----|-----|---|
|John | Doe |37 |
|Jane | Doe |32 |
|Jack |Smith|56 |

### Compare arrays

Use the `==` [comparison operator](/flux/v0/spec/operators/#comparison-operators)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](/flux/v0/stdlib/experimental/array/).
2. Use [`array.filter`](/flux/v0/stdlib/experimental/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](/flux/v0/stdlib/experimental/array/).
2. Use [`array.concat`](/flux/v0/stdlib/experimental/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()`](/flux/v0/stdlib/universe/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()`](/flux/v0/stdlib/universe/display/) to return Flux literal
representation of an array as a string and include it as a column value.

```js
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]   |

#### Related

* [length() function](/flux/v0/stdlib/universe/length/)
* [array package](/flux/v0/stdlib/array/)

[composite types](/flux/v0/tags/composite-types/)[data types](/flux/v0/tags/data-types/)
| fname | lname | age |
| --- | --- | --- |
| fname | lname | age |
| John | Doe | 37 |
| Jane | Doe | 32 |
| Jack | Smith | 56 |

| _time  (time) | exampleArray  (string) |
| --- | --- |
| _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] |