jq - Online en la nube

PROGRAMA:

NOMBRE

jq - Procesador JSON de línea de comandos

SINOPSIS

jq [opciones...] filtrar [archivos...]

jq puede transformar JSON de varias formas, seleccionando, iterando, reduciendo y de otra manera
manipular documentos JSON. Por ejemplo, ejecutar el comando jq ´mapa (.precio) | agregar seguirá
tome una matriz de objetos JSON como entrada y devuelva la suma de sus campos de "precio".

jq también puede aceptar la entrada de texto, pero de forma predeterminada, jq lee un flujo de entidades JSON
(incluidos números y otros literales) de stdin. Solo se necesitan espacios en blanco para separar
entidades como 1 y 2, y verdadero y falso. Uno o mas archivos puede especificarse, en el que
case jq leerá la entrada de esos en su lugar.

La opciones se describen en el INVOCAR JQ sección; se refieren principalmente a insumos y productos
formateo. La filtrar está escrito en el lenguaje jq y especifica cómo transformar el
archivo de entrada o documento.

FILTROS

Un programa jq es un "filtro": toma una entrada y produce una salida. Hay una gran cantidad de
filtros incorporados para extraer un campo particular de un objeto, o convertir un número a
una cuerda, o varias otras tareas estándar.

Los filtros se pueden combinar de varias formas: puede canalizar la salida de un filtro a
otro filtro, o recopile la salida de un filtro en una matriz.

Algunos filtros producen varios resultados, por ejemplo, hay uno que produce todos los
elementos de su matriz de entrada. La tubería de ese filtro en un segundo ejecuta el segundo filtro por
cada elemento de la matriz. Generalmente, las cosas que se harían con bucles e iteraciones
en otros lenguajes se hace simplemente pegando filtros juntos en jq.

Es importante recordar que cada filtro tiene una entrada y una salida. Incluso literales
como "hola" o 42 son filtros: toman una entrada pero siempre producen el mismo literal que
producción. Las operaciones que combinan dos filtros, como la suma, generalmente alimentan la misma entrada
a ambos y combinar los resultados. Por lo tanto, puede implementar un filtro de promediado como add / de largo
- alimentando la matriz de entrada tanto al add filtro y el de largo filtrar y luego realizar
La división.

Pero eso es adelantarnos a nosotros mismos. :) Comencemos con algo más simple:

INVOCAR JQ

Los filtros jq se ejecutan en un flujo de datos JSON. La entrada a jq se analiza como una secuencia de
valores JSON separados por espacios en blanco que se pasan a través del filtro proporcionado uno en un
tiempo. La (s) salida (s) del filtro se escriben en la salida estándar, nuevamente como una secuencia de
datos JSON separados por espacios en blanco.

Nota: es importante tener en cuenta las reglas de cotización del shell. Como regla general, es mejor
cite siempre (con caracteres de comillas simples) el programa jq, ya que hay demasiados caracteres con
El significado especial de jq son también metacaracteres de shell. Por ejemplo, jq "foo" fallará en
la mayoría de los shells de Unix porque será lo mismo que jq foo, que generalmente fallará
porque foo is no se define. Cuando se utiliza el shell de comandos de Windows (cmd.exe) es mejor
use comillas dobles alrededor de su programa jq cuando se indique en la línea de comandos (en lugar de -f
Archivo de programa opción), pero luego las comillas dobles en el programa jq necesitan una barra invertida de escape.

Puede afectar la forma en que jq lee y escribe su entrada y salida usando alguna línea de comando
opciones:

· --versión:

Genere la versión jq y salga con cero.

· --sec:

Ingrese al aplicación / json-seq Esquema de tipo MIME para separar textos JSON en la entrada de jq
y salida. Esto significa que se imprime un carácter ASCII RS (separador de registros) antes
cada valor en la salida y un ASCII LF (avance de línea) se imprime después de cada salida. Aporte
Los textos JSON que no se pueden analizar se ignoran (pero se les advierte), descartando todos
entrada posterior hasta el siguiente RS. Esto más también analiza la salida de jq sin el
--sec .

· --Arroyo:

Analice la entrada en forma de transmisión, generando matrices de valores de ruta y hoja
(escalares y matrices vacías u objetos vacíos). Por ejemplo, "Un" se convierte en [[],"a"]y
[[], "a", ["b"]] se convierte en [[0], []], [[1], "a"]y [[1,0], "b"].

Esto es útil para procesar entradas muy grandes. Use esto junto con
filtrado y el reducir y foreach sintaxis para reducir incrementalmente las entradas grandes.

· --sorber/-s:

En lugar de ejecutar el filtro para cada objeto JSON en la entrada, lea toda la entrada
transmita en una matriz grande y ejecute el filtro solo una vez.

· --Datos crudos/-R:

No analice la entrada como JSON. En cambio, cada línea de texto se pasa al filtro como un
cuerda. Si se combina con --sorber, entonces toda la entrada se pasa al filtro como un
una sola cuerda larga.

· - entrada nula/-n:

¡No lea ninguna entrada! En cambio, el filtro se ejecuta una vez usando nulo como entrada.
Esto es útil cuando se usa jq como una calculadora simple o para construir datos JSON a partir de
rasguño.

· - salida compacta / -c:

De forma predeterminada, jq pretty imprime la salida JSON. El uso de esta opción resultará en más
salida compacta poniendo cada objeto JSON en una sola línea.

· --pestaña:

Utilice una pestaña para cada nivel de sangría en lugar de dos espacios.

· --sangrar n:

Utilice la cantidad de espacios indicada (no más de 8) para la sangría.

· - salida de color / -C y - salida monocromática / -M:

De forma predeterminada, jq genera JSON en color si se escribe en un terminal. Puedes forzarlo a
producir color incluso si se escribe en una tubería o un archivo utilizando -Cy deshabilite el color con -M.

· --ascii-salida / -a:

jq generalmente genera puntos de código Unicode no ASCII como UTF-8, incluso si la entrada especificada
ellos como secuencias de escape (como "\ u03bc"). Con esta opción, puede forzar a jq a
producir una salida ASCII pura con cada carácter no ASCII reemplazado por el equivalente
secuencia de escape.

· - sin búfer

Vacíe la salida después de que se imprima cada objeto JSON (útil si está realizando una canalización lenta
fuente de datos en jq y canalizando la salida de jq en otro lugar).

· --claves de clasificación / -S:

Genere los campos de cada objeto con las claves en orden ordenado.

· - salida en bruto / -r:

Con esta opción, si el resultado del filtro es una cadena, se escribirá directamente
a la salida estándar en lugar de formatearse como una cadena JSON con comillas. Esto puede
ser útil para hacer que los filtros jq se comuniquen con sistemas no basados ​​en JSON.

· --join-salida / -j:

Me gusta -r pero jq no imprimirá una nueva línea después de cada salida.

· -f nombre de archivo / --desde el archivo nombre de archivo:

Lea el filtro desde el archivo en lugar de desde una línea de comando, como la opción -f de awk. usted
también puede usar ´ # ´ para hacer comentarios.

· -Ldirectorio / -L directorio:

Anteponer directorio a la lista de búsqueda de módulos. Si se utiliza esta opción, no
Se utiliza la lista de búsqueda incorporada. Consulte la sección de módulos a continuación.

· -e / --estado de salida:

Establece el estado de salida de jq en 0 si el último valor de salida no fue ninguno false ni nulo,
1 si el último valor de salida fue false or nulo, o 4 si nunca se obtuvo un resultado válido
producido. Normalmente, jq sale con 2 si hubo algún problema de uso o error del sistema, 3
si hubo un error de compilación del programa jq, o 0 si el programa jq se ejecutó.

· --arg nombre propuesta de:

Esta opción pasa un valor al programa jq como una variable predefinida. Si ejecuta jq
--arg foo de caramelos, entonces $ foo está disponible en el programa y tiene el valor "bar".
Tenga en cuenta que propuesta de será tratado como una cadena, por lo que --arg foo 123 se unirá $ foo a "123".

· --argjson nombre JSON-texto:

Esta opción pasa un valor codificado en JSON al programa jq como una variable predefinida. Si
ejecutas jq con --argjson foo 123, entonces $ foo está disponible en el programa y tiene la
propuesta de 123.

· --slurpfile nombre de la variable nombre de archivo:

Esta opción lee todos los textos JSON en el archivo nombrado y enlaza una matriz de
analizó los valores JSON a la variable global dada. Si ejecuta jq con --archivoarg foo de caramelos,
luego $ foo está disponible en el programa y tiene una matriz cuyos elementos corresponden a
los textos en el archivo llamado de caramelos.

· --archivoarg nombre de la variable nombre de archivo:

No utilice. Usar --slurpfile preferiblemente.

(Esta opción es como --slurpfile, pero cuando el archivo tiene solo un texto, es
utilizado, de lo contrario, se utiliza una serie de textos como en --slurpfile.)

· --ejecutar pruebas [nombre del archivo]:

Ejecuta las pruebas en el archivo dado o en la entrada estándar. Esta debe ser la última opción dada
y no respeta todas las opciones anteriores. La entrada consta de líneas de comentarios, vacías
líneas y líneas de programa seguidas de una línea de entrada, tantas líneas de salida como sean
esperado (uno por salida), y una línea vacía de terminación. Pruebas de falla de compilación
comience con una línea que contenga solo "%% FAIL", luego una línea que contenga el programa para
compilar, luego una línea que contiene un mensaje de error para comparar con el real.

Tenga en cuenta que esta opción puede cambiar hacia atrás de manera incompatible.

ED. BÁSICA FILTROS

.
El filtro absolutamente más simple (y menos interesante) es .. Este es un filtro que toma su
entrada y la produce sin cambios como salida.

Dado que jq imprime por defecto toda la salida, este programa trivial puede ser una forma útil de
formatear la salida JSON de, digamos, rizo.

jq´.´
"¡Hola Mundo!"
=> "¡Hola mundo!"

.foo, .foo.bar
Lo más simple eficiente el filtro es .foo. Cuando se le da un objeto JSON (también conocido como diccionario o hash) como
entrada, produce el valor en la tecla "foo", o nulo si no hay ninguno presente.

Si la clave contiene caracteres especiales, debe rodearla con comillas dobles como
modo: . "foo $".

Un filtro de la forma .foo.bar es equivalente a .foo | .bar.

jq´.foo´
{"foo": 42, "bar": "datos menos interesantes"}
=> 42

jq´.foo´
{"notfoo": true, "alsonotfoo": false}
=> nulo

jq ´. ["foo"] ´
{"foo": 42}
=> 42

.foo?
Al igual que .foo, pero no emite ni siquiera un error cuando . no es una matriz ni un objeto.

jq ´.foo? ´
{"foo": 42, "bar": "datos menos interesantes"}
=> 42

jq ´.foo? ´
{"notfoo": true, "alsonotfoo": false}
=> nulo

jq ´. ["foo"]? ´
{"foo": 42}
=> 42

jq ´ [.foo?] ´
[ 1,2 ]
=> []

. [ ], . [2], . [10:15]
También puede buscar campos de un objeto usando una sintaxis como . ["foo"] (.foo arriba es un
versión abreviada de esto). Este también funciona para matrices, si la clave es un número entero.
Las matrices son de base cero (como javascript), por lo que . [2] devuelve el tercer elemento de la matriz.

La . [10:15] La sintaxis se puede utilizar para devolver una submatriz de una matriz o una subcadena de una cadena.
La matriz devuelta por . [10:15] será de longitud 5, conteniendo los elementos del índice 10
(inclusive) al índice 15 (exclusivo). Cualquiera de los índices puede ser negativo (en cuyo caso cuenta
hacia atrás desde el final de la matriz), u omitido (en cuyo caso se refiere al inicio o
final de la matriz).

La . [2] La sintaxis se puede utilizar para devolver el elemento en el índice dado. Los índices negativos son
permitido, con -1 refiriéndose al último elemento, -2 refiriéndose al penúltimo elemento,
y así sucesivamente.

La .foo la sintaxis solo funciona para teclas simples, es decir, teclas que son todos caracteres alfanuméricos.
. [ ] funciona con teclas que contienen caracteres especiales como dos puntos y dos puntos. Para
ejemplo . ["foo :: bar"] y . ["foo.bar"] trabajar mientras .foo :: bar y .foo.bar no lo haría.

La ? "operador" también se puede utilizar con el operador de corte, como en . [10:15]?, que produce
valores donde las entradas se pueden dividir.

jq ´. [0] ´
[{"nombre": "JSON", "bueno": verdadero}, {"nombre": "XML", "bueno": falso}]
=> {"nombre": "JSON", "bueno": verdadero}

jq ´. [2] ´
[{"nombre": "JSON", "bueno": verdadero}, {"nombre": "XML", "bueno": falso}]
=> nulo

jq ´. [2: 4] ´
["a B C D e"]
=> ["c", "d"]

jq ´. [2: 4] ´
"abcdefghi"
=> "cd"

jq ´. [: 3] ´
["a B C D e"]
=> ["a", "b", "c"]

jq ´. [- 2:] ´
["a B C D e"]
=> ["d", "e"]

jq ´. [- 2] ´
[ 1,2,3 ]
=> 2

. []
Si utiliza la opcion de .[índice] sintaxis, pero omite el índice por completo, devolverá todos de las
elementos de una matriz. Corriendo . [] con la entrada [ 1,2,3 ] producirá los números como tres
resultados separados, en lugar de como una única matriz.

También puede usar esto en un objeto y devolverá todos los valores del objeto.

jq ´. [] ´
[{"nombre": "JSON", "bueno": verdadero}, {"nombre": "XML", "bueno": falso}]
=> {"nombre": "JSON", "bueno": verdadero}, {"nombre": "XML", "bueno": falso}

jq ´. [] ´
[]
=>

jq ´. [] ´
{"a": 1, "b": 1}
=> 1, 1

. []?
Me gusta . [], pero no se generarán errores si. no es una matriz u objeto.

,
Si dos filtros están separados por una coma, entonces la entrada se alimentará a ambos y allí
serán múltiples salidas: primero, todas las salidas producidas por la expresión izquierda, y
luego todas las salidas producidas por la derecha. Por ejemplo, filtrar .foo, .Cafetería, produce
tanto los campos "foo" como los campos "bar" como salidas independientes.

jq ´.foo, .bar´
{"foo": 42, "bar": "algo más", "baz": true}
=> 42, "algo más"

jq ´.user, .projects [] ´
{"usuario": "stedolan", "proyectos": ["jq", "wikiflow"]}
=> "stedolan", "jq", "wikiflow"

jq ´. [4,2] ´
["a B C D e"]
=> "e", "c"

|
El | El operador combina dos filtros alimentando la (s) salida (s) del de la izquierda en
la entrada del de la derecha. Es más o menos lo mismo que la tubería del shell de Unix, si
estás acostumbrado a eso.

Si el de la izquierda produce varios resultados, el de la derecha se ejecutará durante
cada uno de esos resultados. Entonces, la expresión . [] | .foo recupera el campo "foo" de cada
elemento de la matriz de entrada.

jq ´. [] | .nombre
[{"nombre": "JSON", "bueno": verdadero}, {"nombre": "XML", "bueno": falso}]
=> "JSON", "XML"

TIPOS E VALORES

jq admite el mismo conjunto de tipos de datos que JSON: números, cadenas, valores booleanos, matrices,
objetos (que en JSON-speak son hash con solo claves de cadena) y "nulo".

Los valores booleanos, nulos, cadenas y números se escriben de la misma forma que en javascript. Al igual que
todo lo demás en jq, estos valores simples toman una entrada y producen una salida - 42 es un
expresión jq válida que toma una entrada, la ignora y devuelve 42 en su lugar.

Formación construcción - []
Como en JSON, [] se utiliza para construir matrices, como en [ 1,2,3 ]. Los elementos de las matrices pueden
ser cualquier expresión jq. Se recopilan todos los resultados producidos por todas las expresiones
en una gran variedad. Puede usarlo para construir una matriz a partir de una cantidad conocida de valores
(como en [.foo, .bar, .baz]) o "recopilar" todos los resultados de un filtro en una matriz (como
in [.items []. nombre])

Una vez que comprenda el operador ",", puede ver la sintaxis de matriz de jq en una
luz: la expresión [ 1,2,3 ] no utiliza una sintaxis incorporada para matrices separadas por comas,
pero en su lugar está aplicando el [] operador (recopilar resultados) a la expresión 1,2,3 (que
produce tres resultados diferentes).

Si tienes un filtro X que produce cuatro resultados, luego la expresión [X] producirá un
resultado único, una matriz de cuatro elementos.

jq ´ [.user, .projects []] ´
{"usuario": "stedolan", "proyectos": ["jq", "wikiflow"]}
=> ["stedolan", "jq", "wikiflow"]

Objetos - {}
Como JSON, {} es para construir objetos (también conocidos como diccionarios o hashes), como en: {"a": 42,
"B": 17/XNUMX/XNUMX}.

Si las teclas son "sensibles" (todos los caracteres alfabéticos), las comillas se pueden omitir.
El valor puede ser cualquier expresión (aunque es posible que deba colocarlo entre paréntesis si es un
complicado), que se aplica a la entrada de la expresión {} (recuerde, todos los filtros
tener una entrada y una salida).

{foo: .bar}

producirá el objeto JSON {"foo": 42/XNUMX/XNUMX} si se le da el objeto JSON {"bar": 42, "baz": 43}.
Puede usar esto para seleccionar campos particulares de un objeto: si la entrada es un objeto con
los campos "usuario", "título", "id" y "contenido" y solo desea "usuario" y "título", puede
escribir

{usuario: .usuario, título:. título}

Debido a que eso es tan común, hay una sintaxis de atajo: {usuario, título}.

Si una de las expresiones produce varios resultados, se utilizarán varios diccionarios.
producido. Si la entrada

{"usuario": "stedolan", "títulos": ["JQ Primer", "Más JQ"]}

luego la expresión

{usuario, título: .titles []}

producirá dos salidas:

{"user": "stedolan", "title": "JQ Primer"}
{"user": "stedolan", "title": "Más JQ"}

Poner paréntesis alrededor de la clave significa que se evaluará como una expresión. Con el
misma entrada que arriba,

{(.usuario): .títulos}

produce

{"stedolan": ["JQ Primer", "Más JQ"]}

jq ´ {usuario, título: .titles []} ´
{"usuario": "stedolan", "títulos": ["JQ Primer", "Más JQ"]}
=> {"user": "stedolan", "title": "JQ Primer"}, {"user": "stedolan", "title": "Más JQ"}

jq ´ {(. usuario): .titles} ´
{"usuario": "stedolan", "títulos": ["JQ Primer", "Más JQ"]}
=> {"stedolan": ["JQ Primer", "Más JQ"]}

INCORPORADO OPERADORES E Las funciones

Algún operador jq (por ejemplo, +) hacen cosas diferentes según el tipo de
argumentos (matrices, números, etc.). Sin embargo, jq ​​nunca realiza conversiones de tipo implícitas. Si
Si intenta agregar una cadena a un objeto, obtendrá un mensaje de error y no obtendrá ningún resultado.

Adición - +
El operador + toma dos filtros, los aplica a la misma entrada y agrega el
resultados juntos. Lo que significa "agregar" depende de los tipos involucrados:

· Números se agregan mediante aritmética normal.

· Matrices se agregan concatenados en una matriz más grande.

· Tangas se agregan al unirse en una cadena más grande.

· Objetos se agregan fusionando, es decir, insertando todos los pares clave-valor de ambos
objetos en un solo objeto combinado. Si ambos objetos contienen un valor para el mismo
clave, el objeto a la derecha de la + gana. (Para una combinación recursiva, use el * operador.)

nulo se puede agregar a cualquier valor y devuelve el otro valor sin cambios.

jq´.a+1´
{"a": 7}
=> 8

jq´.a + .b´
{"a": [1,2], "b": [3,4]}
=> [1,2,3,4]

jq ´.a + nulo´
{"a": 1}
=> 1

jq´.a+1´
{}
=> 1

jq ´ {a: 1} + {b: 2} + {c: 3} + {a: 42} ´
nulo
=> {"a": 42, "b": 2, "c": 3}

Sustracción - -
Además de la resta aritmética normal de números, la - El operador se puede utilizar en matrices
para eliminar todas las apariciones de los elementos de la segunda matriz de la primera matriz.

jq´4 - .a´
{"a": 3}
=> 1

jq ´. - ["xml", "yaml"] ´
["xml", "yaml", "json"]
=> ["json"]

Multiplicación, división, formulario - *, /, y %
Estos operadores infijos se comportan como se esperaba cuando se les dan dos números. La división por cero aumenta
un error. x % y calcula x módulo y.

Multiplicar una cadena por un número produce la concatenación de esa cadena que muchos
veces. "X" * 0 produce nulo.

Dividir una cadena por otra divide la primera utilizando la segunda como separadores.

Multiplicar dos objetos los fusionará de forma recursiva: esto funciona como una suma, pero si ambos
los objetos contienen un valor para la misma clave, y los valores son objetos, los dos se fusionan
con la misma estrategia.

jq ´10 /. * 3´
5
=> 6

jq ´. / "," ´
"a B C D e"
=> ["a", "b, c, d", "e"]

jq ´ {"k": {"a": 1, "b": 2}} * {"k": {"a": 0, "c": 3}} ´
nulo
=> {"k": {"a": 0, "b": 2, "c": 3}}

jq ´. [] | (1 /.)? ´
[1,0, -1]
=> 1, -1

de largo
La función incorporada de largo obtiene la longitud de varios tipos diferentes de valor:

· La longitud de un cadena es el número de puntos de código Unicode que contiene (que será
igual que su longitud codificada en JSON en bytes si es ASCII puro).

· La longitud de un matriz es el número de elementos.

· La longitud de un objeto es el número de pares clave-valor.

· El largo de nulo Es cero.

jq ´. [] | longitud´ [[1,2], "cadena", {"a": 2}, nulo] => 2, 6, 1, 0

llaves, llaves_sin ordenar
La función incorporada claves, cuando se le da un objeto, devuelve sus claves en una matriz.

Las claves están ordenadas "alfabéticamente", por orden de puntos de código Unicode. Esto no es una orden
que tiene un sentido particular en cualquier idioma en particular, pero puede contar con que será el
lo mismo para dos objetos cualesquiera con el mismo conjunto de claves, independientemente de la configuración regional.

Cuándo claves recibe una matriz, devuelve los índices válidos para esa matriz: los enteros
de 0 a longitud-1.

La llaves_sin ordenar la función es como claves, pero si la entrada es un objeto, las teclas
no se ordenarán, en su lugar, las claves estarán aproximadamente en orden de inserción.

jq 'llaves'
{"abc": 1, "abcd": 2, "Foo": 3}
=> ["Foo", "abc", "abcd"]

jq 'llaves'
[ 42,3,35 ]
=> [0,1,2]

tiene (clave)
La función incorporada tiene devuelve si el objeto de entrada tiene la clave dada, o la entrada
array tiene un elemento en el índice dado.

tiene ($ clave) tiene el mismo efecto que comprobar si $ clave es un miembro de la matriz devuelta
by claves, Aunque tiene será más rápido.

jq ´map (tiene ("foo")) ´
[{"foo": 42}, {}]
=> [verdadero, falso]

jq ´map (tiene(2)) ´
[[0,1], ["a", "b", "c"]]
=> [falso, verdadero]

in
La función incorporada in devuelve la clave de entrada está en el objeto dado, o el índice de entrada
corresponde a un elemento en la matriz dada. Es, esencialmente, una versión inversa de
tiene.

jq ´. [] | en ({"foo": 42}) ´
["foo", "bar"]
=> verdadero, falso

jq ´map (en ([0,1])) ´
[2, 0]
=> [falso, verdadero]

ruta (ruta_expresión)
Genera representaciones de matriz de la expresión de ruta dada en .. Las salidas son matrices de
cadenas (claves en objetos0 y / o números (índices de matriz.

Las expresiones de ruta son expresiones jq como .a, pero también . []. Hay dos tipos de camino
expresiones: las que pueden coincidir exactamente y las que no. Por ejemplo, .a B C es un
expresión de ruta de coincidencia exacta, mientras que .a []. b no es.

ruta (expresión_ruta_exacta) producirá la representación de matriz de la expresión de ruta
incluso si no existe en ., Si . is nulo o una matriz o un objeto.

camino (patrón) producirá representaciones de matriz de las rutas que coinciden patrón si el
existen caminos en ..

Tenga en cuenta que las expresiones de ruta no son diferentes de las expresiones normales. La expresion
ruta (.. | seleccionar (tipo == "boolean")) genera todas las rutas a valores booleanos en ., y solo
esos caminos.

jq ´ruta (.a [0] .b) ´
nulo
=> ["a", 0, "b"]

jq ´ [ruta (..)] ´
{"a": [{"b": 1}]}
=> [[], ["a"], ["a", 0], ["a", 0, "b"]]

del (expresión_ruta)
La función incorporada de los elimina una clave y su valor correspondiente de un objeto.

jq ´del (.foo) ´
{"foo": 42, "bar": 9001, "baz": 42}
=> {"bar": 9001, "baz": 42}

jq ´del (. [1, 2]) ´
["foo", "bar", "baz"]
=> ["foo"]

a_entradas, de_entradas, con_entradas
Estas funciones convierten entre un objeto y una matriz de pares clave-valor. Si a_entradas
se pasa un objeto, luego para cada k: v entrada en la entrada, la matriz de salida incluye
{"llave": k, "valor": v}.

de_entradas hace la conversión opuesta, y with_entries (foo) es una abreviatura de
a_entradas | mapa (foo) | de_entradas, útil para realizar alguna operación en todas las teclas y
valores de un objeto. de_entradas acepta clave, clave, nombre, valor y valor como claves.

jq 'a_entradas'
{"a": 1, "b": 2}
=> [{"clave": "a", "valor": 1}, {"clave": "b", "valor": 2}]

jq 'de_entradas'
[{"clave": "a", "valor": 1}, {"clave": "b", "valor": 2}]
=> {"a": 1, "b": 2}

jq ´with_entries (.key | = "KEY_" +.) ´
{"a": 1, "b": 2}
=> {"CLAVE_a": 1, "CLAVE_b": 2}

seleccionar (expresión_booleana)
La función seleccionar (foo) produce su entrada sin cambios si foo devuelve verdadero para esa entrada,
y no produce salida de otra manera.

Es útil para filtrar listas: [ 1,2,3 ] | mapa (seleccione (. >= 2)) Te regalaré [ 2,3 ].

jq ´map (seleccione (.> = 2)) ´
[ 1,5,3,0,7 ]
=> [5,3,7]

jq ´. [] | seleccione (.id == "segundo") ´
[{"id": "primero", "val": 1}, {"id": "segundo", "val": 2}]
=> {"id": "segundo", "val": 2}

matrices, objetos, iterables, booleanos números, normales finitos, instrumentos de cuerda, nulos, valores,
escalares
Estos incorporados seleccionan solo entradas que son matrices, objetos, iterables (matrices o
objetos), booleanos, números, números normales, números finitos, cadenas, nulo, no nulo
valores y no iterables, respectivamente.

jq ´. [] | números´
[[], {}, 1, "foo", nulo, verdadero, falso]
=> 1

vacío
vacío no devuelve ningún resultado. Ninguno en absoluto. Ni siquiera nulo.

Es útil en ocasiones. Sabrás si lo necesitas :)

jq ´1, vacío, 2´
nulo
=> 1, 2

jq ´ [1,2, vacío, 3] ´
nulo
=> [1,2,3]

error(mensaje)
Produce un error, como .a aplicado a valores que no sean nulos y los objetos lo harían, pero
con el mensaje dado como valor del error.

$ __ loc__
Produce un objeto con una clave de "archivo" y una clave de "línea", con el nombre de archivo y el número de línea
donde $ __ loc__ ocurre, como valores.

jq ´intentar error ("\ ($ __ loc__)") captura .´
nulo
=> "{\" archivo \ ": \" \",\"línea 1}"

mapa (x), map_values ​​(x)
Para cualquier filtro x, mapa (x) ejecutará ese filtro para cada elemento de la matriz de entrada, y
producir las salidas de una nueva matriz. mapa (. + 1) incrementará cada elemento de una matriz de
números.

De manera similar, los map_values ​​(x) ejecutará ese filtro para cada elemento, pero devolverá un
objeto cuando se pasa un objeto.

mapa (x) es equivalente a [. [] | x]. De hecho, así es como se define. Similar,
map_values ​​(x) se define como . [] |= x.

jq ´map (. + 1) ´
[ 1,2,3 ]
=> [2,3,4]

jq ´mapa_valores (. + 1) ´
{"a": 1, "b": 2, "c": 3}
=> {"a": 2, "b": 3, "c": 4}

caminos, rutas (filtro_nodo), caminos_hoja
caminos genera las rutas a todos los elementos en su entrada (excepto que no genera la salida
lista vacía, que representa. sí mismo).

caminos (f) genera las rutas a cualquier valor para el que f es verdad. Es decir, caminos (números)
genera las rutas a todos los valores numéricos.

caminos_hoja es un alias de caminos (escalares); caminos_hoja is y será eliminado en
el próximo lanzamiento importante.

jq ´ [caminos] ´
[1, [[], {"a": 2}]]
=> [[0],[1],[1,0],[1,1],[1,1,"a"]]

jq ´ [caminos (escalares)] ´
[1, [[], {"a": 2}]]
=> [[0], [1,1, "a"]]

add
El filtro add toma como entrada una matriz y produce como salida los elementos de la matriz
agregado junto. Esto podría significar sumados, concatenados o fusionados según los tipos de
los elementos de la matriz de entrada - las reglas son las mismas que las de la + operador
(descrito arriba).

Si la entrada es una matriz vacía, add devoluciones nulo.

jq 'agregar'
["a B C"]
=> "abc"

jq 'agregar'
[1, 2, 3]
=> 6

jq 'agregar'
[]
=> nulo

alguna, cualquier (condición), cualquiera (generador; condición)
El filtro cualquier toma como entrada una matriz de valores booleanos y produce verdadero como salida si
cualquiera de los elementos de la matriz es verdadero.

Si la entrada es una matriz vacía, cualquier devoluciones false.

La cualquier (condición) formulario aplica la condición dada a los elementos de la matriz de entrada.

La cualquiera (generador; condición) forma aplica la condición dada a todas las salidas del
generador dado.

jq 'cualquiera'
[verdadero Falso]
=> verdadero

jq 'cualquiera'
[falso, falso]
=> falso

jq 'cualquiera'
[]
=> falso

todos, todo (condición), todos (generador; condición)
El filtro todos toma como entrada una matriz de valores booleanos y produce verdadero como salida si
todos los elementos de la matriz son verdadero.

La todo (condición) formulario aplica la condición dada a los elementos de la matriz de entrada.

La todos (generador; condición) forma aplica la condición dada a todas las salidas del
generador dado.

Si la entrada es una matriz vacía, todos devoluciones verdadero.

jq ´todos´
[verdadero Falso]
=> falso

jq ´todos´
[verdad verdad]
=> verdadero

jq ´todos´
[]
=> verdadero

[Requiere 1.5] aplanar, aplanar (profundidad)
El filtro aplanar toma como entrada una matriz de matrices anidadas y produce una matriz plana en
que todas las matrices dentro de la matriz original han sido reemplazadas recursivamente por sus valores.
Puede pasarle un argumento para especificar cuántos niveles de anidamiento aplanar.

aplanar(2) es como aplanar, pero solo hasta dos niveles de profundidad.

jq 'aplanar'
[1, [2], [[3]]]
=> [1, 2, 3]

jq´aplanar(1) ´
[1, [2], [[3]]]
=> [1, 2, [3]]

jq 'aplanar'
[[]]
=> []

jq 'aplanar'
[{"foo": "bar"}, [{"foo": "baz"}]]
=> [{"foo": "bar"}, {"foo": "baz"}]

rango (hasta), rango (desde; hasta) rango (desde; hasta; por)
La distancia La función produce un rango de números. rango (4; 10) produce 6 números, de 4
(inclusive) a 10 (exclusivo). Los números se producen como salidas independientes. Usar
[rango (4; 10)] para obtener un rango como una matriz.

La forma de un argumento genera números desde 0 hasta el número dado, con un incremento de
1.

La forma de dos argumentos genera números a partir de en a hasta con un incremento de 1.

La forma de tres argumentos genera números en a hasta con un incremento de by.

jq ´rango (2; 4) ´
nulo
=> 2, 3

jq ´ [rango (2; 4)] ´
nulo
=> [2,3]

jq ´ [distancia(4)] ´
nulo
=> [0,1,2,3]

jq ´ [rango (0; 10; 3)] ´
nulo
=> [0,3,6,9]

jq ´ [rango (0; 10; -1)] ´
nulo
=> []

jq ´ [rango (0; -5; -1)] ´
nulo
=> [0,-1,-2,-3,-4]

piso
La piso La función devuelve el piso de su entrada numérica.

jq 'piso'
3.14159
=> 3

sqrt
La sqrt La función devuelve la raíz cuadrada de su entrada numérica.

jq 'raíz cuadrada'
9
=> 3

Al numero
La Al numero La función analiza su entrada como un número. Se convertirá correctamente formateado
cadenas a su equivalente numérico, deje los números en paz y dé un error en todos los demás
entrada.

jq ´. [] | Al numero
[1, "1"]
=> 1, 1

Encadenar
La Encadenar La función imprime su entrada como una cadena. Las cadenas no se modifican y todas
otros valores están codificados en JSON.

jq ´. [] | Encadenar
[1, "1", [1]]
=> "1", "1", "[1]"

tipo
La tipo La función devuelve el tipo de su argumento como una cadena, que es nula,
booleano, número, cadena, matriz u objeto.

jq ´map (tipo) ´
[0, falso, [], {}, nulo, "hola"]
=> ["número", "booleano", "matriz", "objeto", "nulo", "cadena"]

infinito, nan es infinito, isnán, es finito, es normal
Algunas operaciones aritméticas pueden producir infinitos y valores "no un número" (NaN). los
es infinito devoluciones integradas verdadero si su entrada es infinita. los isnan devoluciones integradas verdadero
si su entrada es un NaN. los infinito builtin devuelve un valor infinito positivo. los nan
builtin devuelve un NaN. los es normal builtin devuelve verdadero si su entrada es un número normal.

Tenga en cuenta que la división por cero genera un error.

Actualmente, la mayoría de las operaciones aritméticas que operan en infinitos, NaN y subnormales no
plantear errores.

jq ´. [] | (infinito *.) <0´
[-1, 1]
=> verdadero, falso

jq ´infinite, nan | escribe
nulo
=> "número", "número"

ordenar, sort_by (expresión_ruta)
La sort functions ordena su entrada, que debe ser una matriz. Los valores se ordenan en el
siguiente orden:

· nulo

· false

· verdadero

· Números

· Cadenas, en orden alfabético (por valor de punto de código Unicode)

· Matrices, en orden léxico

· objetos

El orden de los objetos es un poco complejo: primero se comparan comparando sus
conjuntos de claves (como matrices en orden ordenado), y si sus claves son iguales, los valores son
comparado clave por clave.

sort puede usarse para ordenar por un campo particular de un objeto, o aplicando cualquier filtro jq.

sort_by (foo) compara dos elementos comparando el resultado de foo en cada elemento.

jq 'ordenar'
[8,3, nulo, 6]
=> [nulo, 3,6,8]

jq ´sort_by (.foo) ´
[{"foo": 4, "bar": 10}, {"foo": 3, "bar": 100}, {"foo": 2, "bar": 1}]
=> [{"foo": 2, "bar": 1}, {"foo": 3, "bar": 100}, {"foo": 4, "bar": 10}]

group_by (expresión_ruta)
grupo_por (.foo) toma como entrada una matriz, agrupa los elementos que tienen el mismo .foo campo
en matrices separadas, y produce todas estas matrices como elementos de una matriz más grande,
ordenados por el valor de la .foo campo.

Cualquier expresión jq, no solo un acceso de campo, puede usarse en lugar de .foo. La clasificación
El orden es el mismo que se describe en el sort función anterior.

jq ´group_by (.foo) ´
[{"foo": 1, "bar": 10}, {"foo": 3, "bar": 100}, {"foo": 1, "bar": 1}]
=> [[{"foo": 1, "bar": 10}, {"foo": 1, "bar": 1}], [{"foo": 3, "bar": 100}]]

min máx, min_by (ruta_exp), max_by (ruta_exp)
Encuentre el elemento mínimo o máximo de la matriz de entrada.

La min_by (ruta_exp) y max_by (ruta_exp) Las funciones le permiten especificar un particular
campo o propiedad para examinar, p. ej. min_by (.foo) encuentra el objeto con el más pequeño foo
campo.

jq 'min'
[ 5,4,2,7 ]
=> 2

jq ´max_by (.foo) ´
[{"foo": 1, "bar": 14}, {"foo": 2, "bar": 3}]
=> {"foo": 2, "bar": 3}

único, único_por (ruta_exp)
La único La función toma como entrada una matriz y produce una matriz de los mismos elementos, en
orden ordenado, con duplicados eliminados.

La único_por (ruta_exp) La función mantendrá solo un elemento por cada valor obtenido por
aplicando el argumento. Piense en ello como hacer una matriz tomando un elemento de cada
grupo producido por grupo de XNUMX.

jq 'único'
[ 1,2,5,3,5,3,1,3 ]
=> [1,2,3,5]

jq ´unique_by (.foo) ´
[{"foo": 1, "bar": 2}, {"foo": 1, "bar": 3}, {"foo": 4, "bar": 5}]
=> [{"foo": 1, "bar": 2}, {"foo": 4, "bar": 5}]

jq ´unique_by (longitud) ´
["grueso", "tocino", "gatito", "cigarra", "espárragos"]
=> ["tocino", "trozos", "espárragos"]

marcha atrás
Esta función invierte una matriz.

jq 'reversa'
[ 1,2,3,4 ]
=> [4,3,2,1]

contiene (elemento)
El filtro contiene (b) producirá verdadero si b está completamente contenido dentro de la entrada. A
la cadena B está contenida en una cadena A si B es una subcadena de A. Una matriz B está contenida en
una matriz A si todos los elementos de B están contenidos en cualquier elemento de A. Un objeto B es
contenido en el objeto A si todos los valores en B están contenidos en el valor en A con el
misma clave. Se supone que todos los demás tipos están contenidos entre sí si son iguales.

jq ´contains ("barra") ´
"foobar"
=> verdadero

jq ´contiene (["baz", "bar"]) ´
["foobar", "foobaz", "blarp"]
=> verdadero

jq ´contains (["bazzzzz", "bar"]) ´
["foobar", "foobaz", "blarp"]
=> falso

jq ´contiene ({foo: 12, bar: [{barp: 12}]}) ´
{"foo": 12, "bar": [1,2, {"barp": 12, "blip": 13}]}
=> verdadero

jq ´contiene ({foo: 12, bar: [{barp: 15}]}) ´
{"foo": 12, "bar": [1,2, {"barp": 12, "blip": 13}]}
=> falso

índices (s)
Genera una matriz que contiene los índices en . donde s ocurre. La entrada puede ser una matriz, en
cuyo caso si s es una matriz, entonces la salida de los índices serán aquellos donde todos los elementos en .
coincidir con los de s.

jq ´indices (",") ´
"a, b, cd, efg, hijk"
=> [3,7,12]

jq´índices(1) ´
[ 0,1,2,1,3,1,4 ]
=> [1,3,5]

jq ´índices ([1,2]) ´
[ 0,1,2,3,1,4,2,5,1,2,6,7 ]
=> [1,8]

índice (s), rindex (s)
Genera el índice de la primera (índice) o el último (Rindex) Ocurrencia de s en la entrada.

jq ´index (",") ´
"a, b, cd, efg, hijk"
=> 3

jq ´rindex (",") ´
"a, b, cd, efg, hijk"
=> 12

dentro
El filtro adentro (b) producirá verdadero si la entrada está completamente contenida dentro de b. Eso
es, esencialmente, una versión inversa de contiene.

jq ´inside ("foobar") ´
"bar"
=> verdadero

jq ´inside (["foobar", "foobaz", "blarp"]) ´
["baz", "bar"]
=> verdadero

jq ´inside (["foobar", "foobaz", "blarp"]) ´
["bazzzzz", "bar"]
=> falso

jq ´inside ({"foo": 12, "bar": [1,2, {"barp": 12, "blip": 13}]}) ´
{"foo": 12, "bar": [{"barp": 12}]}
=> verdadero

jq ´inside ({"foo": 12, "bar": [1,2, {"barp": 12, "blip": 13}]}) ´
{"foo": 12, "bar": [{"barp": 15}]}
=> falso

empieza con (str)
Salidas verdadero si . comienza con el argumento de cadena dado.

jq ´ [. [] | empieza con ("foo")] ´
["fo", "foo", "barfoo", "foobar", "barfoob"]
=> [falso, verdadero, falso, verdadero, falso]

termina con (str)
Salidas verdadero si . termina con el argumento de cadena dado.

jq ´ [. [] | termina con ("foo")] ´
["foobar", "barfoo"]
=> [falso, verdadero]

combinaciones combinaciones (n)
Muestra todas las combinaciones de los elementos de las matrices en la matriz de entrada. Si se le da un
argumento n, genera todas las combinaciones de n repeticiones de la matriz de entrada.

jq ´combinaciones´
[[1,2], [3, 4]]
=> [1, 3], [1, 4], [2, 3], [2, 4]

jq´combinaciones(2) ´
[0, 1]
=> [0, 0], [0, 1], [1, 0], [1, 1]

ltrimstr (str)
Emite su entrada con la cadena de prefijo dada eliminada, si comienza con ella.

jq ´ [. [] | ltrimstr ("foo")] ´
["fo", "foo", "barfoo", "foobar", "afoo"]
=> ["fo", "", "barfoo", "bar", "afoo"]

rtrimstr (str)
Emite su entrada con la cadena de sufijo dada eliminada, si termina con ella.

jq ´ [. [] | rtrimstr ("foo")] ´
["fo", "foo", "barfoo", "foobar", "foob"]
=> ["fo", "", "bar", "foobar", "foob"]

explotar
Convierte una cadena de entrada en una matriz de números de puntos de código de la cadena.

jq 'explotar'
"foobar"
=> [102,111,111,98,97,114]

implosionar
Lo inverso de explotar.

jq 'implosionar'
[65, 66, 67]
=> "ABC"

dividido
Divide una cadena de entrada en el argumento del separador.

jq ´split (",") ´
"a B C D e, "
=> ["a", "b, c, d", "e", ""]

unirse (str)
Une la matriz de elementos dados como entrada, usando el argumento como separador. Es el
inverso de dividido: es decir, corriendo dividir ("foo") | unirse ("foo") sobre cualquier cadena de entrada
devuelve dicha cadena de entrada.

jq ´unir (",") ´
["a B C D e"]
=> "a, b, c, d, e"

ascii_downcase, ascii_upcase
Emite una copia de la cadena de entrada con sus caracteres alfabéticos (az y AZ) convertidos a
el caso especificado.

while (cond; actualizar)
La while (cond; actualizar) La función le permite aplicar repetidamente una actualización a . hasta cond
Es falso.

Tenga en cuenta que while (cond; actualizar) se define internamente como una función jq recursiva. Recursivo
llamadas dentro mientras no consumirá memoria adicional si actualización produce como máximo uno
salida para cada entrada. Consulte los temas avanzados a continuación.

jq ´ [mientras (. <100;. * 2)] ´
1
=> [1,2,4,8,16,32,64]

hasta (cond; Siguiente)
La hasta (cond; Siguiente) La función le permite aplicar repetidamente la expresión Next,
inicialmente a . luego a su propia salida, hasta cond es verdad. Por ejemplo, esto se puede utilizar
para implementar una función factorial (ver más abajo).

Tenga en cuenta que hasta (cond; Siguiente) se define internamente como una función jq recursiva. Recursivo
llamadas dentro hasta() no consumirá memoria adicional si Next produce como máximo uno
salida para cada entrada. Consulte los temas avanzados a continuación.

jq ´ [., 1] | hasta (. [0] <1; [. [0] - 1,. [1] *. [0]]) |. [1] ´
4
=> 24

recurrente (f), recurrente recurrente (f; condición), recurse_abajo
La recurrente (f) La función le permite buscar a través de una estructura recursiva y extraer
datos interesantes de todos los niveles. Suponga que su entrada representa un sistema de archivos:

{"nombre": "/", "niños": [
{"nombre": "/compartimiento", "niños": [
{"nombre": "/ bin / ls", "niños": []},
{"nombre": "/ Bin / sh", "niños": []}]},
{"nombre": "/ home", "niños": [
{"nombre": "/ home / stephen", "niños": [
{"nombre": "/ home / stephen / jq", "niños": []}]}]}]}

Ahora suponga que desea extraer todos los nombres de archivo presentes. Necesitas recuperar . Nombre,
.niños []. nombre, .niños []. niños []. nombre, etcétera. Puedes hacer esto con:

recurse (.niños []) | .nombre

Cuando se llama sin un argumento, recurrente es equivalente a recurse (. []?).

recurrente (f) es idéntico a recurrente (f; . != nulo) y se puede utilizar sin preocupaciones sobre
profundidad de recursividad.

recurrente (f; condición) es un generador que comienza emitiendo. y luego emite a su vez
. | f,. | f | f,. | f | f | f, ... siempre que el valor calculado satisfaga la condición. Para
ejemplo, para generar todos los enteros, al menos en principio, se podría escribir recurrente (. + 1;
cierto).

Por razones heredadas, recurse_abajo existe como un alias para llamar recurrente sin argumentos.
Este alias se considera y se eliminará en la próxima versión principal.

Las llamadas recursivas en recurrente no consumirá memoria adicional siempre que f produce en
la mayoría de una sola salida para cada entrada.

jq ´recurse (.foo []) ´
{"foo": [{"foo": []}, {"foo": [{"foo": []}]}]}
=> {"foo": [{"foo": []}, {"foo": [{"foo": []}]}]}, {"foo": []}, {"foo": [{"Foo Foo":[]}

jq 'recurso'
{"a": 0, "b": [1]}
=> {"a": 0, "b": [1]}, 0, [1], 1

jq ´recurse (. *.;. <20) ´
2
=> 2, 4, 16

..
Mano corta para recurrente sin argumentos. Esto está destinado a parecerse al XPath //
operador. Tenga en cuenta que ..y No funciona; usar .. | a en lugar de. En el siguiente ejemplo usamos
.. | .a? para encontrar todos los valores de las claves de objeto "a" en cualquier objeto que se encuentre "debajo" ..

jq ´ .. | .a? ´
[[{"a": 1}]]
=> 1

env
Genera un objeto que representa el entorno de jq.

jq 'env.PAGER'
nulo
=> "menos"

transponer
Transponga una matriz posiblemente irregular (una matriz de matrices). Las filas se rellenan con nulos para que el
el resultado es siempre rectangular.

jq 'transponer'
[[1], [2,3]]
=> [[1,2], [nulo, 3]]

bsearch (x)
bsearch (x) realiza una búsqueda binaria de x en la matriz de entrada. Si la entrada está ordenada y
contiene x, entonces bsearch (x) devolverá su índice en la matriz; de lo contrario, si la matriz es
ordenado, devolverá (-1 - ix) donde ix es un punto de inserción tal que la matriz
aún se ordenará después de la inserción de x en ix. Si la matriz no está ordenada, bsearch (x)
devolverá un número entero que probablemente no sea de interés.

jq´buscar(0) ´
[ 0,1 ]
=> 0

jq´buscar(0) ´
[ 1,2,3 ]
=> -1

jq´buscar(4) como $ ix | si $ ix <0 entonces. [- (1 + $ ix)] = 4 más. fin
[ 1,2,3 ]
=> [1,2,3,4]

Cordón interpolación - \ (foo)
Dentro de una cadena, puede poner una expresión dentro de los paréntesis después de una barra invertida. Cualquiera que sea el
Los retornos de expresión se interpolarán en la cadena.

jq ´ "La entrada fue \ (.), que es uno menos que \ (. + 1)" ´
42
=> "La entrada fue 42, que es uno menos que 43"

Convertir hacia / desde JSON
La Tojson y Ubicación:json los valores incorporados volcan como textos JSON o analizan los textos JSON en
valores, respectivamente. El tojson incorporado difiere de tostring en que tostring regresa
cadenas sin modificar, mientras que tojson codifica cadenas como cadenas JSON.

jq ´ [. [] | tostring] ´
[1, "foo", ["foo"]]
=> ["1", "foo", "[\" foo \ "]"]

jq ´ [. [] | tojson] ´
[1, "foo", ["foo"]]
=> ["1", "\" foo \ "", "[\" foo \ "]"]

jq ´ [. [] | tojson | fromjson] ´
[1, "foo", ["foo"]]
=> [1, "foo", ["foo"]]

Formato instrumentos de cuerda y escapar
La @foo La sintaxis se usa para formatear y escapar cadenas, lo cual es útil para crear URL,
documentos en un lenguaje como HTML o XML, etc. @foo se puede utilizar como filtro en
propia, las posibles fugas son:

@texto:

Calls Encadenar, consulte esa función para obtener más detalles.

@json:

Serializa la entrada como JSON.

@html:

Aplica escape HTML / XML, mapeando los caracteres <> & ´ " a su entidad
equivalentes <, >, Y, ', ".

@uri:

Aplica codificación porcentual, asignando todos los caracteres URI reservados a un % XX secuencia.

@csv:

La entrada debe ser una matriz y se representa como CSV con comillas dobles para
cadenas y comillas escapadas por repetición.

@tsv:

La entrada debe ser una matriz y se representa como TSV (valores separados por tabulaciones). Cada
La matriz de entrada se imprimirá como una sola línea. Los campos están separados por una sola pestaña
(ascii) 0x09). Entrada de caracteres de avance de línea (ascii 0x0a), retorno de carro (ascii
0x0d), tabulador (ascii 0x09) y barra invertida (ascii 0x5c) saldrá como escape
secuencias \n, \r, \t, \\ respectivamente.

@sh:

La entrada tiene un escape adecuado para su uso en una línea de comandos para un shell POSIX. Si el
input es una matriz, la salida será una serie de cadenas separadas por espacios.

@ base64:

La entrada se convierte a base64 según lo especificado por RFC 4648.

Esta sintaxis se puede combinar con la interpolación de cadenas de una manera útil. Puedes seguir un
@foo token con una cadena literal. El contenido de la cadena literal será no ser escapado.
Sin embargo, todas las interpolaciones realizadas dentro de ese literal de cadena se escaparán. Por ejemplo,

@uri "https://www.google.com/search?q=\(.search)"

producirá la siguiente salida para la entrada {"buscar": "qué is jq? "}:

"https://www.google.com/search?q=what%20is%20jq%3F"

Tenga en cuenta que las barras, el signo de interrogación, etc. de la URL no se escapan, ya que formaban parte
del literal de cadena.

jq ´ @ html´
"Esto funciona si x <y"
=> "Esto funciona si x <y"

jq ´ @ sh "echo \ (.)" ´
"Ale de O´Hara"
=> "echo ´O´ \\ ´´Hara´ \\ ´´s Ale´"

Fechas
jq proporciona algunas funciones básicas de manejo de fechas, con algunas funciones de alto y bajo nivel
incorporados. En todos los casos, estas incorporaciones tratan exclusivamente con la hora en UTC.

La desdefechaiso8601 incorporado analiza las fechas y horas en el formato ISO 8601 a una cantidad de segundos
desde la época de Unix (1970-01-01T00: 00: 00Z). los hoyiso8601 incorporado hace lo contrario.

La partir de la fecha incorporado analiza las cadenas de fecha y hora. En la actualidad partir de la fecha solo es compatible con ISO 8601
cadenas de fecha y hora, pero en el futuro intentará analizar las cadenas de fecha y hora en más
formatos.

La hasta la fecha incorporado es un alias para hoyiso8601.

La ahora builtin genera la hora actual, en segundos desde la época de Unix.

También se proporcionan interfaces jq de bajo nivel para las funciones de tiempo de la biblioteca C: tiempo de espera,
Strftime, tiempo mky tiempo gm. Consulte la documentación de su sistema operativo host para
cadenas de formato utilizadas por tiempo de espera y Strftime. Nota: estos no son necesariamente estables
interfaces en jq, particularmente en cuanto a su funcionalidad de localización.

La tiempo gm incorporado consume una cantidad de segundos desde la época de Unix y genera un "roto
tiempo de inactividad "representación del tiempo como una matriz de números que representan (en este orden):
año, mes (basado en cero), día del mes, hora del día, minuto del
la hora, el segundo del minuto, el día de la semana y el día del año, todo
uno basado a menos que se indique lo contrario.

La tiempo mk incorporado consume representaciones de "tiempo desglosado" de la salida de tiempo por tiempo gm
y tiempo de espera.

La strptime (fmt) incorporado analiza las cadenas de entrada que coinciden con el fmt argumento. La salida está en
la representación del "tiempo desglosado" consumida por tiempo gm y salida por tiempo mk.

La strftime (fmt) formatos incorporados una hora con el formato dado.

Las cadenas de formato para tiempo de espera y Strftime se describen en la biblioteca C típica
documentación. La cadena de formato para la fecha y hora ISO 8601 es "% Y-% m-% dT% H:% M:% SZ".

Es posible que jq no admita parte o la totalidad de esta funcionalidad de fecha en algunos sistemas.

jq 'desde la fecha'
"2015-03-05T23:51:47Z"
=> 1425599507

jq ´strptime ("% Y-% m-% dT% H:% M:% SZ") ´
"2015-03-05T23:51:47Z"
=> [2015,2,5,23,51,47,4,63]

jq ´strptime ("% Y-% m-% dT% H:% M:% SZ") | mktime´
"2015-03-05T23:51:47Z"
=> 1425599507

CONDICIONALES E COMPARACIONES

==, !=
La expresión ´a == b´ producirá ´verdadero´ si los resultados de ayb son iguales (es decir,
si representan documentos JSON equivalentes) y "falso" en caso contrario. En particular, cadenas
nunca se consideran iguales a números. Si vienes de Javascript, jq´s == es como
Javascript´s === - considerando valores iguales solo cuando tienen el mismo tipo así como
el mismo valor.

! = es "no es igual", y ´a! = b´ devuelve el valor opuesto de ´a == b´

jq ´. [] == 1´
[1, 1.0, "1", "banana"]
=> verdadero, verdadero, falso, falso

si-entonces-otro
if A luego B más C final actuará igual que B if A produce un valor que no es falso o
nulo, pero actúa igual que C de otra manera.

Verificar falso o nulo es una noción de "veracidad" más simple que la que se encuentra en Javascript.
o Python, pero significa que a veces tendrás que ser más explícito sobre la condición
desea: no puede probar si, por ejemplo, una cadena está vacía usando if . Nombre luego A más B final,
necesitarás algo más como if (.nombre | largo) > 0 luego A más B final preferiblemente.

Si la condición A produce varios resultados, se considera "verdadero" si alguno de esos
los resultados no son falsos ni nulos. Si produce cero resultados, se considera falso.

Se pueden agregar más casos a si se usa elif A luego B sintaxis.

jq ´if. == 0 entonces

"cero" elif. == 1 luego "uno" más "muchos" fin´ 2 => "muchos"

>, > =, <=, <
Los operadores de comparación >, >=, <=, < devuelve si su argumento de la izquierda es mayor que,
mayor o igual a, menor o igual o menor que su argumento correcto
(respectivamente).

El orden es el mismo que el descrito para sort, encima.

jq ´. <5´
2
=> verdadero

y / o / no
jq admite los operadores booleanos normales y / o no. Tienen el mismo estándar de verdad
como si las expresiones: falso y nulo se consideraran "valores falsos", y cualquier otra cosa es un
"verdadero valor".

Si un operando de uno de estos operadores produce varios resultados, el propio operador
producirá un resultado para cada entrada.

no es de hecho una función incorporada en lugar de un operador, por lo que se llama como un filtro para
qué cosas se pueden canalizar en lugar de con una sintaxis especial, como en .foo y .Cafetería | no.

Estos tres solo producen los valores "verdadero" y "falso", por lo que solo son útiles para
Operaciones booleanas, en lugar del lenguaje común de Perl / Python / Ruby de
"value_that_may_be_null o default". Si desea utilizar esta forma de "o", elija entre
dos valores en lugar de evaluar una condición, consulte el operador "//" a continuación.

jq ´42 y "una cadena" ´
nulo
=> verdadero

jq ´ (verdadero, falso) o falso´
nulo
=> verdadero, falso

jq ´ (verdadero, verdadero) y (verdadero, falso) ´
nulo
=> verdadero, falso, verdadero, falso

jq ´ [verdadero, falso | no
nulo
=> [falso, verdadero]

Alternative operador - //
Un filtro de la forma a // b produce los mismos resultados que a, Si a produce resultados otros
que false y nulo. De otra manera, a // b produce los mismos resultados que b.

Esto es útil para proporcionar valores predeterminados: .foo // 1 evaluará a 1 si no hay .foo
elemento en la entrada. Es similar a como or a veces se usa en Python (jq´s or operador
está reservado para operaciones estrictamente booleanas).

jq ´.foo // 42´
{"foo": 19}
=> 19

jq ´.foo // 42´
{}
=> 42

trata de atraparlo
Los errores se pueden detectar utilizando try EXP coger EXP. Se ejecuta la primera expresión, y si
falla entonces el segundo se ejecuta con el mensaje de error. La salida del controlador, si
any, se emite como si hubiera sido el resultado de la expresión para probar.

La try EXP usos de la forma vacío como controlador de excepciones.

jq ´try .a catch ". no es un objeto" ´
verdadero
=> ". no es un objeto"

jq ´ [. [] | intente .a] ´
[{}, cierto, {"a": 1}]
=> [nulo, 1]

jq ´intentar error ("alguna excepción") captura .´
verdadero
=> "alguna excepción"

Ruptura salir of control estructuras
Un uso conveniente de try / catch es romper estructuras de control como reducir, foreach,
mientras, Y así sucesivamente.

Por ejemplo:

# Repita una expresión hasta que muestre "break" como un
# error, luego deje de repetir sin volver a generar el error.
# Pero si el error detectado no es "romper", vuelva a subirlo.
intente repetir (exp) coger. == "romper" y luego vaciar de lo contrario error;

jq tiene una sintaxis para etiquetas léxicas con nombre para "romper" o "volver a":

label $ out | ... romper $ ...

La romper $ label_name expresión hará que el programa actúe como si el más cercano
(A la izquierda) Label $ label_name producido vacío.

La relación entre el romper y correspondiente Label es léxico: la etiqueta tiene que ser
"visible" desde el descanso.

Para salir de un reducir, Por ejemplo:

label $ out | reducir. [] como $ elemento (nulo; si. == falso entonces separe $ fuera más ... fin)

El siguiente programa jq produce un error de sintaxis:

romper $ out

porque no hay etiqueta $ fuera es visible.

? operador
La ? operador, usado como ¿EXP?, es la abreviatura de try EXP.

jq ´ [. [] | (.a)?] ´
[{}, cierto, {"a": 1}]
=> [nulo, 1]

REGULAR EXPRESIONES (PCRE)

jq usa la biblioteca de expresiones regulares de Oniguruma, al igual que php, ruby, TextMate, Sublime Text,
etc, por lo que la descripción aquí se centrará en los detalles de jq.

Los filtros de expresiones regulares jq se definen para que se puedan usar usando uno de estos patrones:

STRING | FILTRO (REGEX)
STRING | FILTRO (REGEX; BANDERAS)
STRING | FILTRO ([REGEX])
STRING | FILTRO ([REGEX, BANDERAS])

donde: * STRING, REGEX y FLAGS son cadenas jq y están sujetas a la interpolación de cadenas jq; *
REGEX, después de la interpolación de cadenas, debe ser una expresión regular de PCRE válida; * FILTRO es uno de test,
partidoo capturar, como se describe abajo.

FLAGS es una cadena que consta de una o más de las banderas admitidas:

· g - Búsqueda global (encuentre todas las coincidencias, no solo la primera)

· i - Búsqueda que no distingue entre mayúsculas y minúsculas

· m - Modo multilínea (´.´ coincidirá con las nuevas líneas)

· n - Ignorar coincidencias vacías

· p - Ambos modos s y m están habilitados

· s - Modo de línea única (´ ^ ´ -> ´ \ A´, ´ $ ´ -> ´ \ Z´)

· l - Encuentra coincidencias más largas posibles

· x - Formato de expresión regular extendido (ignore los espacios en blanco y los comentarios)

Para hacer coincidir los espacios en blanco en un patrón x, use un escape como \ s, p. Ej.

· Prueba ("a \ sb", "x").

Tenga en cuenta que ciertas banderas también pueden especificarse dentro de REGEX, p. Ej.

· Jq -n ´ ("prueba", "PRUEBA", "PRUEBA", "PRUEBA") | prueba ("(? i) te (? - i) st") ´

se evalúa como: verdadero, verdadero, falso, falso.

[Requiere 1.5] prueba (val), prueba (regex; banderas)
Me gusta partido, pero no devuelve objetos coincidentes, solo verdadero or false por si el
regex coincide con la entrada.

jq ´test ("foo") ´
"foo"
=> verdadero

jq ´. [] | test ("abc # espacios son ignorados"; "ix") ´
["xabcd", "ABC"]
=> verdadero, verdadero

[Requiere 1.5] partido (val), coincidir (regex; banderas)
partido genera un objeto para cada coincidencia que encuentra. Los partidos tienen los siguientes campos:

· compensar - desplazamiento en puntos de código UTF-8 desde el principio de la entrada

· de largo - longitud en puntos de código UTF-8 de la coincidencia

· cadena - la cuerda que combinó

· capturas - una matriz de objetos que representan grupos de captura.

La captura de objetos de grupo tiene los siguientes campos:

· compensar - desplazamiento en puntos de código UTF-8 desde el principio de la entrada

· de largo - longitud en puntos de código UTF-8 de este grupo de captura

· cadena - la cuerda que fue capturada

· nombre - el nombre del grupo de captura (o nulo si no tenía nombre)

La captura de grupos que no coinciden con nada devuelve un desplazamiento de -1

jq ´match ("(abc) +"; "g") ´
"abc abc"
=> {"desplazamiento": 0, "longitud": 3, "cadena": "abc", "capturas": [{"desplazamiento": 0, "longitud": 3, "cadena": "abc", " nombre ": nulo}]}, {" desplazamiento ": 4," longitud ": 3," cadena ":" abc "," capturas ": [{" desplazamiento ": 4," longitud ": 3," cadena " : "abc", "nombre": nulo}]}

jq ´match ("foo") ´
"foo bar foo"
=> {"desplazamiento": 0, "longitud": 3, "cadena": "foo", "capturas": []}

jq ´match (["foo", "ig"]) ´
"foo bar FOO"
=> {"offset": 0, "length": 3, "string": "foo", "captures": []}, {"offset": 8, "length": 3, "string": "FOO "," capturas ": []}

jq ´match ("foo (? bar)? foo ";" ig ") ´
"foo bar foo foo foo"
=> {"offset": 0, "length": 11, "string": "foo bar foo", "captures": [{"offset": 4, "length": 3, "string": "bar" , "name": "bar123"}]}, {"offset": 12, "length": 8, "string": "foo foo", "captures": [{"offset": -1, "length" : 0, "cadena": nulo, "nombre": "bar123"}]}

jq ´ [coincidencia ("."; "g")] | largo
"a B C"
=> 3

[Requiere 1.5] capturar (val), capturar (regex; banderas)
Recopila las capturas con nombre en un objeto JSON, con el nombre de cada captura como clave,
y la cadena coincidente como el valor correspondiente.

jq ´capture ("(? [az] +) - (? [0-9] +) ") ´
"xyzzy-14"
=> {"a": "xyzzy", "n": "14"}

[Requiere 1.5] escanear (regex), escanear (regex; banderas)
Emite una secuencia de subcadenas no superpuestas de la entrada que coinciden con la expresión regular en
de acuerdo con las banderas, si se han especificado. Si no hay coincidencia, la secuencia es
vacío. Para capturar todas las coincidencias para cada cadena de entrada, use el modismo [ expr ], p.ej [
escanear (regex) ].

dividir (expresión regular; banderas)
Para compatibilidad con versiones anteriores, dividido se divide en una cadena, no en una expresión regular.

[Requiere 1.5] divisiones (expresiones regulares), divisiones (regex; banderas)
Estos proporcionan los mismos resultados que sus dividido contrapartes, sino como una corriente en lugar de una
formación.

[Requiere 1.5] sub (expresión regular; Encadenar) sub (expresión regular; cuerda; banderas)
Emite la cadena obtenida reemplazando la primera coincidencia de regex en la cadena de entrada con
Encadenar, después de la interpolación. Encadenar debe ser una cadena jq y puede contener referencias
a capturas con nombre. Las capturas nombradas se presentan, en efecto, como un objeto JSON (como
construido por capturar) A Encadenar, por lo que una referencia a una variable capturada llamada "x"
tomar la forma: "(.x)".

[Requiere 1.5] gsub (expresión regular; cuerda), gsub (expresión regular; cuerda; banderas)
g-sub es como por debajo pero todas las ocurrencias no superpuestas de la expresión regular son reemplazadas por la
cadena, después de la interpolación.

ADVANCED CATEGORIAS

Las variables son una necesidad absoluta en la mayoría de los lenguajes de programación, pero están relegadas
a una "función avanzada" en jq.

En la mayoría de los lenguajes, las variables son el único medio de transmitir datos. Si calcula un
value, y quieres usarlo más de una vez, necesitarás almacenarlo en una variable. Para
pasar un valor a otra parte del programa, necesitará esa parte del programa para
definir una variable (como un parámetro de función, miembro de objeto o lo que sea) en la que colocar
los datos.

También es posible definir funciones en jq, aunque esta es una característica cuya mayor
el uso es definir la biblioteca estándar de jq (muchas funciones de jq como mapa y encontrar de hecho
escrito en jq).

jq tiene operadores de reducción, que son muy poderosos pero un poco complicados. De nuevo, estos son
se utiliza principalmente internamente, para definir algunos bits útiles de la biblioteca estándar de jq.

Puede que no sea obvio al principio, pero jq se trata de generadores (sí, como se encuentra a menudo en
otros idiomas). Se proporcionan algunos servicios públicos para ayudar a lidiar con los generadores.

Alguna compatibilidad mínima de E / S (además de leer JSON desde la entrada estándar y escribir JSON en
salida estándar) está disponible.

Finalmente, hay un sistema de módulo / biblioteca.

Variables
En jq, todos los filtros tienen una entrada y una salida, por lo que la plomería manual no es necesaria para
pasar un valor de una parte de un programa a la siguiente. Muchas expresiones, por ejemplo a + b,
pasar su entrada a dos subexpresiones distintas (aquí a y b ambos se pasan lo mismo
input), por lo que las variables no suelen ser necesarias para utilizar un valor dos veces.

Por ejemplo, calcular el valor promedio de una matriz de números requiere algunos
variables en la mayoría de los idiomas: al menos una para contener la matriz, tal vez una para cada elemento
o para un contador de bucle. En jq, es simplemente add / de largo - el add expresión se le da la
matriz y produce su suma, y ​​la de largo expresión recibe la matriz y produce su
longitud.

Entonces, generalmente hay una manera más limpia de resolver la mayoría de los problemas en jq que definir variables.
Aún así, a veces facilitan las cosas, por lo que jq le permite definir variables usando
expresión as $ variable. Todos los nombres de variables comienzan con $. Aquí tienes una versión un poco más fea.
del ejemplo de promedio de matriz:

longitud como $ array_length | agregar / $ array_length

Necesitaremos un problema más complicado para encontrar una situación en la que el uso de variables
nos facilita la vida.

Supongamos que tenemos una serie de publicaciones de blog, con los campos "autor" y "título", y otro
objeto que se utiliza para asignar nombres de usuario de autor a nombres reales. Nuestra entrada se ve así:

{"posts": [{"title": "Frist psot", "author": "anon"},
{"title": "Un artículo bien escrito", "autor": "persona1"}],
"realnames": {"anon": "Cobarde anónimo",
"person1": "Persona McPherson"}}

Queremos producir las publicaciones con el campo de autor que contiene un nombre real, como en:

{"title": "Primer psot", "autor": "Cobarde anónimo"}
{"title": "Un artículo bien escrito", "autor": "Persona McPherson"}

Usamos una variable, $ names, para almacenar el objeto de nombres reales, de modo que podamos referirnos a él más tarde.
al buscar nombres de usuario de autor:

.realnames como $ nombres | .posts [] | {título, autor: $ nombres [.autor]}

La expresion exp as $x | ... significa: para cada valor de expresión exp, ejecuta el resto de
la tubería con toda la entrada original, y con $x establecido en ese valor. Por lo tanto as
funciona como una especie de bucle foreach.

Así como {foo} es una forma práctica de escribir {foo: .foo}, asi que {$ foo} es una forma práctica de escribir
{foo: $ foo}.

Se pueden declarar múltiples variables usando un solo as expresión proporcionando un patrón
que coincide con la estructura de la entrada (esto se conoce como "desestructuración"):

. como {nombres reales: $ nombres, publicaciones: [$ primero, $ segundo]} | ...

Las declaraciones de variables en patrones de matriz (p. Ej., . as [$ primero, $ segundo]) se unen al
elementos de la matriz desde el elemento en el índice cero en adelante, en orden. Cuando no hay
valor en el índice de un elemento de patrón de matriz, nulo está vinculado a esa variable.

Las variables tienen un alcance sobre el resto de la expresión que las define, por lo que

.realnames como $ nombres | (.posts [] | {título, autor: $ nombres [.author]})

funcionará, pero

(.realnames como $ nombres | .posts []) | {título, autor: $ nombres [.autor]}

no lo hará.

Para los teóricos del lenguaje de programación, es más exacto decir que las variables jq son
enlaces de ámbito léxico. En particular, no hay forma de cambiar el valor de un enlace;
uno solo puede configurar un nuevo enlace con el mismo nombre, pero que no será visible donde
el viejo era.

jq ´.bar como $ x | .foo | . + $ x´
{"foo": 10, "bar": 200}
=> 210

jq ´. como $ i | [(. * 2 |. como $ i | $ i), $ i] ´
5
=> [10,5]

jq ´. como [$ a, $ b, {c: $ c}] | $ a + $ b + $ c´
[2, 3, {"c": 4, "d": 5}]
=> 9

jq ´. [] como [$ a, $ b] | {a: $ a, b: $ b} ´
[[0], [0, 1], [2, 1, 0]]
=> {"a": 0, "b": null}, {"a": 0, "b": 1}, {"a": 2, "b": 1}

Definición Clave
Puedes darle un nombre a un filtro usando la sintaxis "def":

def incremento:. + 1;

A partir de entonces, incremento se puede utilizar como un filtro al igual que una función incorporada (de hecho, este
así es como se definen algunas de las incorporaciones). Una función puede tomar argumentos:

def mapa (f): [. [] | F];

Los argumentos se pasan como filtros, no como valores. Se puede hacer referencia al mismo argumento
varias veces con diferentes entradas (aquí f se ejecuta para cada elemento de la matriz de entrada).
Los argumentos de una función funcionan más como devoluciones de llamada que como argumentos de valor. Este es
importante de entender. Considerar:

def foo (f): f | f;
5 | foo (. * 2)

El resultado será 20 porque f is . * 2, y durante la primera invocación de f . será 5,
y la segunda vez será 10 (5 * 2), por lo que el resultado será 20. Argumentos de función
son filtros, y los filtros esperan una entrada cuando se invocan.

Si desea el comportamiento de argumento de valor para definir funciones simples, puede usar un
variable:

def agregarvalor (f): f como $ f | mapa (. + $ f);

O usa la abreviatura:

def agregarvalor ($ f): ...;

Con cualquiera de las dos definiciones, agregar valor (.foo) agregará la entrada actual .foo campo a cada uno
elemento de la matriz.

Se permiten varias definiciones con el mismo nombre de función. Cada redefinición reemplaza
el anterior para el mismo número de argumentos de función, pero solo para referencias de
funciones (o programa principal) posteriores a la redefinición.

jq ´def addvalue (f):. + [f]; mapa (añadir valor (. [0])) ´
[[1,2], [10,20]]
=> [[1,2,1], [10,20,10]]

jq ´def añadir valor (f): f como $ x | mapa (. + $ x); agregarvalor (. [0]) ´
[[1,2], [10,20]]
=> [[1,2,1,2], [10,20,1,2]]

La disminución
La reducir la sintaxis en jq le permite combinar todos los resultados de una expresión por
acumulándolos en una sola respuesta. Como ejemplo, pasaremos [ 3,2,1 ] a este
expresión:

reducir. [] como $ elemento (0;. + $ elemento)

Por cada resultado que . [] produce, . + $ artículo se ejecuta para acumular un total acumulado,
comenzando desde 0. En este ejemplo, . [] produce los resultados 3, 2 y 1, por lo que el efecto es
similar a ejecutar algo como esto:

0 | (3 como $ artículo |. + $ Artículo) |
(2 como $ artículo |. + $ Artículo) |
(1 como $ artículo |. + $ Artículo)

jq ´reduce. [] as $ item (0;. + $ item) ´
[ 10,2,5,3 ]
=> 20

límite (n; Exp)
La límitar función extrae hasta n salidas de exp.

jq ´ [límite (3;. [])] ´
[ 0,1,2,3,4,5,6,7,8,9 ]
=> [0,1,2]

primero (expr), último (expr), nth (n; expr)
La primero (expr) y último (expr) funciones extraen el primer y último valor de expr,
respectivamente.

La nth (n; expr) La función extrae el enésimo valor emitido por expr. Esto se puede definir como
def nth (n; expresión): último (límite (n + 1; expr));. Tenga en cuenta que nth (n; expr) no es compatible
valores negativos de n.

jq ´ [primero (rango (.)), último (rango (.)), n-ésimo (./ 2; rango (.))] ´
10
=> [0,9,5]

primero, último, nth (n)
La la primera y pasado Las funciones extraen el primer y último valor de cualquier matriz en ..

La nth (n) La función extrae el enésimo valor de cualquier matriz en ..

jq ´ [rango (.)] | [primero, último, nth(5)] ´
10
=> [0,9,5]

foreach
La foreach la sintaxis es similar a reducir, pero destinado a permitir la construcción de límitar
y reductores que producen resultados intermedios (ver ejemplo).

La forma es foreach EXP as $ var (EN ESO; ACTUALIZAR; EXTRAER). Como reducir, INIT es evaluado
una vez para producir un valor de estado, luego cada salida de EXP está obligado a $ var, ACTUALIZAR is
evaluado para cada salida de EXP con el estado actual y con $ var visible. Cada valor
salida por ACTUALIZAR reemplaza el estado anterior. Finalmente, EXTRAER se evalúa para cada nuevo
estado para extraer una salida de foreach.

Esto es principalmente útil solo para construir reducir- y límitar-como funciones. Pero es
mucho más general, ya que permite reducciones parciales (ver el ejemplo a continuación).

jq ´ [foreach. [] as $ item ([[], []]; si $ item == null entonces [[],. [0]] else [(. [0] + [$ item]), [ ]] fin; si $ item == null entonces. [1] de lo contrario fin vacío)] ´
[1,2,3,4, XNUMX, XNUMX, XNUMX, nulo, "a", "b", nulo]
=> [[1,2,3,4], ["a", "b"]]

La recursividad
Como se describió anteriormente, recurrente usa la recursividad, y cualquier función jq puede ser recursiva. los
mientras builtin también se implementa en términos de recursividad.

Las llamadas de cola se optimizan siempre que la expresión a la izquierda de las salidas de llamadas recursivas
su último valor. En la práctica, esto significa que la expresión a la izquierda del recursivo
La llamada no debe producir más de una salida para cada entrada.

Por ejemplo:

def recurse (f): def r:., (f | select (.! = null) | r); r;

def mientras (cond; actualizar):
def _mientras:
if cond then., (update | _ while) else empty end;
_tiempo;

def repetir (exp):
def _repetir:
exp, _repetir;
_repetir;

Generadores y iteradores
Algunos operadores y funciones jq son en realidad generadores en el sentido de que pueden producir cero,
uno o más valores para cada entrada, tal como cabría esperar en otra programación
lenguajes que tienen generadores. Por ejemplo, . [] genera todos los valores en su entrada
(que debe ser una matriz o un objeto), rango (0; 10). genera los enteros entre 0 y
10 y así sucesivamente.

Incluso el operador de coma es un generador, generando primero los valores generados por el
expresión a la izquierda de la coma, luego, para cada uno de ellos, los valores generados por el
expresión a la derecha de la coma.

La vacío incorporado es el generador que produce cero salidas. los vacío incorporado
retrocede a la expresión generadora anterior.

Todas las funciones de jq pueden ser generadores simplemente usando generadores incorporados. También es posible
para definir nuevos generadores usando solo la recursividad y el operador de coma. Si el recursivo
la (s) llamada (s) está (están) "en posición de cola", entonces el generador será eficiente. En el ejemplo
debajo de la llamada recursiva de _distancia a sí mismo está en posición de cola. El ejemplo se luce
tres temas avanzados: recursividad de cola, construcción del generador y subfunciones.

jq ´def range (init; upto; by): def _range: if (by> 0 and. <upto) or (by <0 and.> upto) then., ((. + by) | _range) else. fin; si por == 0 entonces init else init | _range end | seleccione ((por> 0 y. <hasta) o (por <0 y.> hasta)); rango (0; 10; 3) ´
nulo
=> 0, 3, 6, 9

jq ´def while (cond; actualizar): def _ while: if cond then., (update | _ while) else empty end; _tiempo; [mientras (. <100;. * 2)] ´
1
=> [1,2,4,8,16,32,64]

MATEMÁTICAS

jq actualmente solo tiene compatibilidad con números de punto flotante de doble precisión (754 bits) IEEE64.

Además de operadores aritméticos simples como +, jq también tiene la mayoría de las funciones matemáticas estándar
de la biblioteca de matemáticas de C. Funciones matemáticas de C que toman un solo argumento de entrada (p. Ej., sin ())
están disponibles como funciones jq de argumento cero. Funciones matemáticas de C que toman dos entradas
argumentos (por ejemplo, pow ()) están disponibles como funciones jq de dos argumentos que ignoran ..

La disponibilidad de funciones matemáticas estándar depende de la disponibilidad del correspondiente
funciones matemáticas en su sistema operativo y biblioteca matemática C. Funciones matemáticas no disponibles
se definirá pero generará un error.

I / O

En este momento, jq ​​tiene un soporte mínimo para E / S, principalmente en forma de control sobre cuándo
se leen las entradas. Se proporcionan dos funciones integradas para esto, Las opciones de entrada y entradas, que leyó
de las mismas fuentes (p. ej., stdin, archivos nombrados en la línea de comandos) como jq. Estas
dos incorporados, y las acciones de lectura propias de jq, se pueden intercalar entre sí.

Uno incorporado proporciona capacidades de salida mínimas, depurar. (Recuerde que un programa de jq
los valores de salida siempre se emiten como textos JSON en stdout.) Los depurar incorporado puede tener
comportamiento específico de la aplicación, como para ejecutables que usan la API de libjq C pero no
el ejecutable jq en sí.

Las opciones de entrada
Produce una nueva entrada.

entradas
Emite todas las entradas restantes, una por una.

Esto es principalmente útil para reducciones sobre las entradas de un programa.

depurar
Provoca un mensaje de depuración basado en el valor de entrada que se generará. El ejecutable jq se envuelve
el valor de entrada con ["DEPURAR:", ] e imprime eso y una nueva línea en stderr,
de forma compacta. Esto puede cambiar en el futuro.

nombre_de_archivo_de_entrada
Devuelve el nombre del archivo cuya entrada se está filtrando actualmente. Tenga en cuenta que esto
no funciona bien a menos que jq se esté ejecutando en una configuración regional UTF-8.

número_línea_entrada
Devuelve el número de línea de la entrada que se está filtrando actualmente.

STREAMING

Con la --Arroyo La opción jq puede analizar los textos de entrada en forma de transmisión, lo que permite que jq
programas para comenzar a procesar grandes textos JSON inmediatamente en lugar de después del análisis
completa. Si tiene un solo texto JSON de 1 GB de tamaño, transmitirlo le permitirá
para procesarlo mucho más rápido.

Sin embargo, la transmisión no es fácil de manejar, ya que el programa jq tendrá [ ,
] (y algunas otras formas) como entradas.

Se proporcionan varias incorporaciones para facilitar el manejo de los flujos.

Los ejemplos siguientes utilizan la forma transmitida de [0, [1]], cual es
[[0],0],[[1,0],1],[[1,0]],[[1]].

Los formularios de transmisión incluyen [ , ] (para indicar cualquier valor escalar, matriz vacía,
u objeto vacío), y [ ] (para indicar el final de una matriz u objeto). Futuro
versiones de jq se ejecutan con --Arroyo y -sec puede generar formularios adicionales como ["error
mensaje"] cuando un texto de entrada no se puede analizar.

truncate_stream (stream_expression)
Consume un número como entrada y trunca el número correspondiente de elementos de ruta de
la izquierda de las salidas de la expresión de transmisión dada.

jq ´[1|truncate_stream([[0],1],[[1,0],2],[[1,0]],[[1]])]´
1
=> [[[0], 2], [[0]]]

fromstream (expresión_corriente)
Valores de salida correspondientes a las salidas de la expresión de flujo.

jq ´fromstream(1|truncate_stream([[0],1],[[1,0],2],[[1,0]],[[1]]))´
nulo
=> [2]

para transmitir
La para transmitir builtin genera la forma transmitida de su entrada.

jq ´. como $ dot | fromstream ($ dot | tostream) |. == $ dot´
[0, [1, {"a": 1}, {"b": 2}]]
=> verdadero

ASIGNACIÓN

La asignación funciona de manera un poco diferente en jq que en la mayoría de los lenguajes de programación. jq no
distinguir entre referencias y copias de algo: dos objetos o matrices son
sea ​​igual o no igual, sin ninguna otra noción de ser "el mismo objeto" o "no
el mismo objeto ".

Si un objeto tiene dos campos que son matrices, .foo y .Cafeteríay agregas algo a
.foo, entonces .Cafetería no se hará más grande. Incluso si acabas de configurar .Cafetería = .foo. Si estas usado
a programar en lenguajes como Python, Java, Ruby, Javascript, etc., entonces puedes pensar
de él como si jq hiciera una copia completa y profunda de cada objeto antes de hacer la asignación
(para el rendimiento, en realidad no hace eso, pero esa es la idea general).

Todos los operadores de asignación en jq tienen expresiones de ruta en el lado izquierdo.

=
El filtro .foo = 1 tomará como entrada un objeto y producirá como salida un objeto con el
campo "foo" establecido en 1. No existe la noción de "modificar" o "cambiar" algo en jq -
todos los valores de jq son inmutables. Por ejemplo,

.foo = .bar | .foo.baz = 1

no tendrá el efecto secundario de establecer .bar.baz en 1, ya que el aspecto similar
programa en Javascript, Python, Ruby u otros lenguajes. A diferencia de estos idiomas (pero
como Haskell y algunos otros lenguajes funcionales), no existe la noción de dos matrices o
los objetos son "la misma matriz" o "el mismo objeto". Pueden ser iguales o no iguales, pero
si cambiamos uno de ellos en ninguna circunstancia cambiará el otro a nuestras espaldas.

Esto significa que es imposible construir valores circulares en jq (como una matriz cuyo
el primer elemento es él mismo). Esto es bastante intencional y asegura que cualquier cosa que un jq
El programa puede producir se puede representar en JSON.

Tenga en cuenta que el lado izquierdo de ´ = ´ se refiere a un valor en .. Así $ var.foo = 1 no funcionará
como se esperaba ($ var.foo no es una expresión de ruta válida o útil en .); usar $ var | .foo = 1
preferiblemente.

Si el lado derecho de ´ = ´ produce múltiples valores, entonces para cada uno de esos valores jq
establezca las rutas en el lado izquierdo al valor y luego generará el modificado ..
Por ejemplo, (.a, .b) =distancia(2) salidas {"a": 0, "b": 0}, entonces {"a": 1, "b": 1}. La actualización"
Los formularios de asignación (ver más abajo) no hacen esto.

Tenga en cuenta también que .a, .b = 0 no establece .a y .b, pero (.a, .b) = 0 establece ambos.

|=
Además del operador de asignación ´ = ´, jq proporciona el operador de "actualización" ´ | = ´, que
toma un filtro en el lado derecho y calcula el nuevo valor para la propiedad de .
siendo asignado al ejecutar el valor antiguo a través de esta expresión. Por ejemplo, .foo | =
. + 1 construirá un objeto con el campo "foo" establecido en la entrada "foo" más 1.

Este ejemplo debería mostrar la diferencia entre ´ = ´ y ´ | = ´:

Proporcione la entrada ´ {"a": {"b": 10}, "b": 20} ´ a los programas:

.a = .b .a | = .b

El primero establecerá el campo "a" de la entrada en el campo "b" de la entrada y producirá
la salida {"a": 20}. Este último establecerá el campo "a" de la entrada en el campo "a"
campo "b", produciendo {"a": 10}.

El lado izquierdo puede ser cualquier expresión de ruta general; ver camino().

Tenga en cuenta que el lado izquierdo de ´ | = ´ se refiere a un valor en .. Así $ var.foo |= . + 1 no
trabajar como se esperaba$ var.foo no es una expresión de ruta válida o útil en .); usar $ var | .foo
|= . + 1 preferiblemente.

Si el lado derecho genera varios valores, solo se utilizará el último.

jq ´ (.. | select (type == "boolean")) | = if. luego 1 más 0 fin´
[verdadero, falso, [5, verdadero, [verdadero, [falso]], falso]]
=> [1,0,[5,1,[1,[0]],0]]

+ =, - =, * =, / =, % =, // =
jq tiene algunos operadores de la forma a op = b, que son todos equivalentes a a |= . op b. Asi que,
+= 1 se puede utilizar para incrementar valores.

jq ´.foo + = 1´
{"foo": 42}
=> {"foo": 43}

Complejo asignaciones
Se permiten muchas más cosas en el lado izquierdo de una asignación jq que en la mayoría
Idiomas. Ya hemos visto accesos de campo simples en el lado izquierdo, y no es
Sorprende que los accesos a la matriz funcionen igual de bien:

.posts [0] .title = "Manual de JQ"

Lo que puede resultar sorprendente es que la expresión de la izquierda puede producir múltiples
resultados, refiriéndose a diferentes puntos en el documento de entrada:

.posts []. comentarios | =. + ["esto es genial"]

Ese ejemplo agrega la cadena "esto es genial" a la matriz "comentarios" de cada publicación en
la entrada (donde la entrada es un objeto con un campo "publicaciones" que es una matriz de publicaciones).

Cuando jq encuentra una asignación como ´a = b´, registra la "ruta" tomada para seleccionar un
parte del documento de entrada mientras se ejecuta un. Esta ruta se usa luego para encontrar qué parte de
la entrada para cambiar mientras se ejecuta la asignación. Se puede utilizar cualquier filtro en el
lado izquierdo de un igual: cualquier ruta que seleccione de la entrada estará donde el
se realiza la asignación.

Esta es una operación muy poderosa. Supongamos que quisiéramos agregar un comentario a las publicaciones del blog, usando
la misma entrada de "blog" anterior. En esta ocasión, solo queremos comentar las publicaciones escritas por
"stedolan". Podemos encontrar esas publicaciones usando la función "seleccionar" descrita anteriormente:

.posts [] | seleccionar (.author == "stedolan")

Las rutas proporcionadas por esta operación apuntan a cada una de las publicaciones que escribió "stedolan", y
podemos comentar cada uno de ellos de la misma forma que lo hacíamos antes:

(.posts [] | select (.author == "stedolan") | .comments) | =
. + ["terrible"]

MÓDULOS

jq tiene un sistema de biblioteca / módulo. Los módulos son archivos cuyos nombres terminan en .jq.

Los módulos importados por un programa se buscan en una ruta de búsqueda predeterminada (ver más abajo). El
importar y incluir Las directivas permiten al importador modificar esta ruta.

Las rutas en una ruta de búsqueda están sujetas a varias sustituciones.

Para las rutas que comienzan con "~ /", el directorio de inicio del usuario se sustituye por "~".

Para las rutas que comienzan con "$ ORIGIN /", la ruta del ejecutable jq se sustituye por
"$ ORIGEN".

Para rutas que comienzan con "./" o rutas que son ".", La ruta del archivo incluido es
sustituido para ".". Para los programas de nivel superior dados en la línea de comandos, el actual
se utiliza el directorio.

Las directivas de importación pueden especificar opcionalmente una ruta de búsqueda a la que se agrega el valor predeterminado.

La ruta de búsqueda predeterminada es la ruta de búsqueda dada al -L opción de línea de comandos, de lo contrario
["~ / .jq", "$ ORIGIN /../ lib / jq", "$ ORIGEN / ../ lib"].

Los elementos de ruta de cadena vacía y nula terminan el procesamiento de la ruta de búsqueda.

Se buscaría una dependencia con la ruta relativa "foo / bar" en "foo / bar.jq" y
"foo / bar / bar.jq" en la ruta de búsqueda dada. Esto está destinado a permitir la colocación de módulos
en un directorio junto con, por ejemplo, archivos de control de versiones, archivos README, etc.
sino también para permitir módulos de un solo archivo.

No se permiten componentes consecutivos con el mismo nombre para evitar ambigüedades (p. Ej.,
"Foo Foo").

Por ejemplo, con -L $ INICIO / .jq un modulo foo puede encontrarse en $ INICIO / .jq / foo.jq y
$ INICIO / .jq / foo / foo.jq.

Si "$ HOME / .jq" es un archivo, se origina en el programa principal.

importar RelativePathStringRelativePathString as NOMBRE [ ];
Importa un módulo que se encuentra en la ruta dada en relación con un directorio en una ruta de búsqueda. Un ".jq"
El sufijo se agregará a la cadena de ruta relativa. Los símbolos del módulo tienen el prefijo
"NOMBRE::".

Los metadatos opcionales deben ser una expresión jq constante. Debería ser un objeto con llaves.
como "página de inicio" y así sucesivamente. En este momento, jq ​​solo usa la clave / valor de "búsqueda" del
metadatos. Los metadatos también están disponibles para los usuarios a través del módulo meta incorporado.

La clave "buscar" en los metadatos, si está presente, debe tener una cadena o un valor de matriz (matriz
de cuerdas); esta es la ruta de búsqueda que se antepone a la ruta de búsqueda de nivel superior.

incluir RelativePathStringRelativePathString [ ];
Importa un módulo que se encuentra en la ruta dada en relación con un directorio en una ruta de búsqueda como si
fueron incluidos en su lugar. Se agregará un sufijo ".jq" a la cadena de ruta relativa. El
Los símbolos del módulo se importan al espacio de nombres de la persona que llama como si el contenido del módulo tuviera
ha sido incluido directamente.

Los metadatos opcionales deben ser una expresión jq constante. Debería ser un objeto con llaves.
como "página de inicio" y así sucesivamente. En este momento, jq ​​solo usa la clave / valor de "búsqueda" del
metadatos. Los metadatos también están disponibles para los usuarios a través del módulo meta incorporado.

importar RelativePathStringRelativePathString as $ NAME [ ];
Importa un archivo JSON que se encuentra en la ruta dada en relación con un directorio en una ruta de búsqueda. A
Se agregará el sufijo ".json" a la cadena de ruta relativa. Los datos del archivo serán
disponible como $ NAME :: NAME.

Los metadatos opcionales deben ser una expresión jq constante. Debería ser un objeto con llaves.
como "página de inicio" y así sucesivamente. En este momento, jq ​​solo usa la clave / valor de "búsqueda" del
metadatos. Los metadatos también están disponibles para los usuarios a través del módulo meta incorporado.

La clave "buscar" en los metadatos, si está presente, debe tener una cadena o un valor de matriz (matriz
de cuerdas); esta es la ruta de búsqueda que se antepone a la ruta de búsqueda de nivel superior.

módulo ;
Esta directiva es completamente opcional. No es necesario para su correcto funcionamiento. Sirve
solo el propósito de proporcionar metadatos que se puedan leer con el módulo meta incorporado.

Los metadatos deben ser una expresión jq constante. Debería ser un objeto con claves como
"página principal". En este momento jq no usa estos metadatos, pero están disponibles para los usuarios.
mediante el módulo meta incorporado.

módulo meta
Toma un nombre de módulo como entrada y genera los metadatos del módulo como un objeto, con el
las importaciones del módulo (incluidos los metadatos) como un valor de matriz para la clave "deps".

Los programas pueden usar esto para consultar los metadatos de un módulo, que luego podrían usar para, para
Por ejemplo, busque, descargue e instale las dependencias que faltan.

Use jq en línea usando los servicios de onworks.net