Arrays em

Sobre Arrays

O JSON define um array, ou vetor, como:

Um array é uma coleção ordenada de valores. Um array começa com o colchete esquerdo [ e termina com o colchete direito ]. Os valores são separados por vírgula ,.

Arrays podem conter zero ou mais valores JSON de qualquer tipo. Os elementos de um array não precisam ser todos do mesmo tipo.

Criando arrays

Use colchetes para reunir elementos em um array.

[1, 2, 3]

Os elementos de um stream podem ser capturados em um array ao envolvê-lo entre colchetes.

range(5)     # => a stream of 5 numbers
[range(5)]   # => the array [0, 1, 2, 3, 4]

Tamanho

A função length retorna o número de elementos em um array.

Indexação e fatiamento

A indexação de arrays começa em zero.

Recupere um elemento de um array com uma expressão entre colchetes: .[2] obtém o terceiro elemento.

Índices negativos contam de trás para frente a partir do fim do array: .[-1] obtém o último elemento; .[-2] é o penúltimo.

Um slice é uma subsequência do array. .[10:15] retorna 5 elementos a partir do índice 10; o índice final não é incluído.

Existem algumas funções de conveniência:

• first obtém o primeiro elemento.
• last obtém o último elemento.
• nth(n) obtém o elemento no índice n.

Converter para um stream de elementos

Há situações em que queremos transmitir os elementos de um array individualmente. Para isso, usamos .[].

Suponha que queremos um stream com os comprimentos das strings em um array.

["a", "be", "cat", "door"] | length        # => 4 -- the number of elements in the array
["a", "be", "cat", "door"] | .[] | length  # => 1, 2, 3, 4 -- the lengths of each element

Os colchetes vazios podem ser colocados ao lado da expressão anterior, omitindo o pipe.

["a", "be", "cat", "door"][] | length      # => 1, 2, 3, 4 -- the lengths of each element
# ........................^^

Concatenação e subtração

Use + para concatenar arrays.

[1, 2, 3] + [4, 5]          # => [1, 2, 3, 4, 5]

O operador - remove do array da esquerda os elementos que estão no array da direita.

[range(10)] - [2, 4, 6]     # => [0, 1, 3, 5, 7, 8, 9]

Iteração

O jq oferece muitas funções para cobrir a funcionalidade comum de iteração:

• map(expr) retorna um novo array onde o expr é aplicado a cada elemento, um de cada vez.

  [1, 2, 3] | map(. * 10)    # => [10, 20, 30]
  
  

• select(expr) é uma função que aplica o expr a um único valor; se o resultado da expressão for verdadeiro, o valor é retornado; se o resultado for falso, nada é retornado, não null, mas realmente nada.

  Para aplicar isso a um array, combine com map.

  [range(10)] | map(select(. % 2 == 0))    # => [0, 2, 4, 6, 8]
  

  Como alternativa, aplique select a um stream e colete os resultados.

  [range(10) | select(. % 2 == 0)]    # => [0, 2, 4, 6, 8]
  

• any(condition) e all(condition) retornam um valor booleano indicando se qualquer um ou todos os elementos do array passam na condição.

  [1, 2, 3, 4] | any(. > 4)    # false
  [1, 2, 3, 4] | any(. >= 4)   # true
  
  [1, 2, 3, 4] | all(. >= 4)   # false
  [1, 2, 3, 4] | all(. <= 4)   # true
  

Pertencimento

Podemos testar se um array contém um elemento com index. Essa função retorna o índice do elemento dado se ele estiver no array; caso contrário, a função retorna null.

["carrots", "beef", "potatoes"] | index("beef")    # => 1
["carrots", "beef", "potatoes"] | index("bees")    # => null

Existe uma função inversa chamada IN (sim, em letras maiúsculas). O detalhe com IN é que seu argumento não é um array, mas um stream.

"beef" | IN(["carrots", "beef", "potatoes"][])    # => true
"bees" | IN(["carrots", "beef", "potatoes"][])    # => false

Outras funções (consulte o manual para mais detalhes)

• O Ruby tem um método prático each_with_index que associa o valor do elemento ao seu índice. O Python tem enumerate. O jq tem algo parecido, chamado to_entries. Isso transforma o array em um array de objetos {key: index, value: value}.

  [11, 22, 33, 44] | to_entries
  # => [{key: 0, value: 11}, {key: 1, value: 22}, {key: 2, value: 33}, {key: 3, value: 44}]
  

• sort e sort_by

• group_by

• min, max, min_by, max_by

• unique, unique_by

• flatten