Compra de veículo

Comparar

Comparar números

Em jq, os números podem ser comparados com os seguintes operadores relacionais e de igualdade.

O resultado da comparação é sempre um valor boolean, ou seja, true ou false.

1 < 3,      # => true
2 != 2,     # => false
1 == 1.0    # => true
            # All numbers are floating-points, so this is different syntax
            # for the exact same value.

Comparar strings

Os operadores de comparação acima também podem ser usados para comparar strings. Nesse caso, aplica-se uma ordem de dicionário (lexicográfica). A ordenação é pelo valor do ponto de código Unicode.

"Apple" > "Pear",   # => false
"a" < "above",      # => true
"a" == "A"          # => false

Tens de ter cuidado quando comparas duas variáveis que parecem conter valores numéricos mas são do tipo string. Devido à ordem de dicionário, o resultado não será o mesmo que comparar valores do tipo number.

10 < 2,     # => false
"10" < "2"  # => true (because "1" comes before "2")

Igualdade "estrita"

O operador == do jq é como o === do Javascript, no sentido em que coisas que "parecem" iguais mas são de tipos diferentes não são iguais.

"3" == 3    # => false
            # the value on the left has type string,
            # the value on the right has type number.

Comparar arrays

Dois arrays são iguais se todos os elementos correspondentes forem iguais.

[1, 2, 3] == [1, 2, 3]      # => true
[1, 2, 3] == [1, 3, 2]      # => false, different order
[1, 2, 3] == [1, 2, "3"]    # => false, different types

Comparar objetos

Dois objetos são iguais se tiverem os mesmos pares chave-valor.

{name: "Joe", age: 42} == {age: 42, name: "Joe"}                # => true
{name: "Joe", age: 42} == {age: 42, name: "Jane"}               # => false
{name: "Joe", age: 42} == {age: "42", name: "Joe"}              # => false
{name: "Joe", age: 42} == {age: 42, name: "Joe", height: 175}   # => false

# comparisons will drill down as deeply as required
{a: {b: {c: [1, 2]}}} == {a: {b: {c: [1, 2]}}}                  # => true
{a: {b: {c: [1, 2]}}} == {a: {b: {c: [1, 2, 3]}}}               # => false

Condicionais

Expressão if

A expressão condicional do jq é if A then B else C end.

O if-then-else é um filtro, como todos os builtins do jq: recebe um valor e produz um valor.

Se a expressão A produzir um valor "truthy", o filtro if avalia B. Caso contrário, avalia C. O valor de entrada do filtro if é passado a B ou a C.

42 | if . < 50 then "small" else "big" end      # => "small"

5 | if . % 2 == 0 then . / 2 else . * 4 end     # => 20

if A then B else . end
if A then B end

Condicionais aninhados

Podes acrescentar mais condições com elif.

42 | if . < 33 then "small"
     elif . < 66 then "medium"
     else "big"
     end
# => "medium"

Usa tantas cláusulas elif quantas precisares.

Veracidade

Os únicos valores "falsos" em jq são: false e null. Tudo o resto é "verdadeiro", até mesmo o número zero e a string, o array e o objeto vazios.

Operadores Boolean

Os operadores Boolean and e or podem ser usados para construir consultas complexas.

42 | if . < 33 or . > 66 then "big or small"
     else "medium"
     end

Para negar, usa not. Isto é um filtro, não um operador.

42 | if (. < 33 or . > 66 | not) then "medium"
     else "big or small"
     end

Operador alternativo

O operador alternativo permite-te especificar um valor "por omissão" se uma expressão for false ou null.

A // B

# This is identical to
if A then A else B end

Para demonstrar:

[3, 5, 18] | add / 2       # => 13
[]         | add / 2       # => error: null (null) and number (2) cannot be divided
[]         | add // 0 / 2  # => 0