Header Ads Widget

Ticker

6/recent/ticker-posts

JQ (1) Página del manual

JQ (1) JQ (1)

NAME
jq - Procesador JSON de línea de comandos

SINOPSIS
jq [opciones ...] filtro [archivos ...]

jq puede transformar JSON de varias formas, seleccionando, iterando, reduciendo
y manipulando documentos JSON. Por ejemplo, ejecutando el
comando jq ´map (.price) | add´ tomará una matriz de objetos JSON como
entrada y devolverá la suma de sus campos de "precio".

jq también puede aceptar entrada de texto, pero de forma predeterminada, jq lee un flujo de
entidades JSON (incluidos números y otros literales) de stdin. El
espacio en blanco solo es necesario para separar entidades como 1 y 2, y verdadero y
falso. Se pueden especificar uno o más archivos, en cuyo caso jq leerá la
entrada de esos en su lugar.

Las opciones se describen en la sección INVOKING JQ; se
refieren principalmente al formato de entrada y salida. El filtro está escrito en el idioma jq
y especifica cómo transformar el archivo o documento de entrada.

FILTROS
Un programa jq es un "filtro": toma una entrada y produce una salida.
Hay muchos filtros integrados para extraer un campo particular de
un objeto, o convertir un número en una cadena, 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 recopilar la salida de un filtro en
una matriz.

Algunos filtros producen múltiples resultados, por ejemplo, hay uno que
produce todos los elementos de su matriz de entrada. Al conectar ese filtro en un
segundo, se ejecuta el segundo filtro para cada elemento de la matriz. Generalmente, las
cosas que se harían con bucles e iteraciones en otros lenguajes
se hacen simplemente pegando filtros en jq.

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

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

INVOCACIÓN 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 a la vez. Las salidas 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 citar siempre (con comillas simples) el
programa jq , ya que demasiados caracteres con un significado especial para jq también son metacaracteres de
shell. Por ejemplo, jq ​​"foo" fallará en la mayoría de
shells de Unix porque será lo mismo que jq foo, que generalmente
fallará porque foo no está definido. Cuando se usa el shell de comandos de Windows
(cmd.exe), es mejor usar comillas dobles alrededor de su programa jq cuando se
indica en la línea de comandos (en lugar de la opción -f archivo de programa), pero
luego comillas dobles en jq el programa necesita escapar de la barra invertida.

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

· -versión:

Genere la versión jq y salga con cero.

· –Seq:

Use el esquema de tipo MIME application / json-seq para separar
textos JSON en la entrada y salida de jq. Esto significa que
se imprime un carácter ASCII RS ( separador de registros ) antes de cada valor en la salida y se imprime un
ASCII LF (avance de línea) después de cada salida. Los
textos JSON de entrada que no se pueden analizar se ignoran (pero se les advierte) y se descartan
todas las entradas posteriores hasta el siguiente RS. Este modo también analiza la
salida de jq sin la opción –seq.

· –Corriente:

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
, "a" 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. Úselo
junto con el filtrado y la sintaxis reduce y foreach para reducir
las entradas grandes de forma incremental.

· –Slurp / -s:

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

· –Entrada-cruda / -R:

No analice la entrada como JSON. En cambio, cada línea de texto se pasa
al filtro como una cadena. Si se combina con –slurp,
toda la entrada se pasa al filtro como una sola cadena larga.

· –Entrada-nula / -n:

¡No lea ninguna entrada! En su lugar, el filtro se ejecuta una vez utilizando
nulo como entrada. Esto es útil cuando se usa jq como una calculadora simple
o para construir datos JSON desde cero.

· –Salida-compacta / -c:

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

· –Tab:

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

· –Indentificación 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. Puede
forzarlo a producir color incluso si escribe en una tubería o un archivo
usando -C, y deshabilitar el color con -M.

Los colores se pueden configurar con la variable de entorno JQ_COLORS
(ver más abajo).

· –Ascii-salida / -a:

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

· –Sin búfer

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

· –Claves-ordenadas / -S:

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

· –Salida-cruda / -r:

Con esta opción, si el resultado del filtro es una cadena, se
escribirá directamente en 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.

· –Unir-salida / -j:

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

· -F nombre de archivo / –from-file nombre de archivo:

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

· -Ldirectory / -L directorio:

Anteponer el directorio a la lista de búsqueda de módulos. Si se
usa esta opción, no se usa ninguna lista de búsqueda integrada. Consulte la sección de
módulos a continuación.

· -E / –estado-de-salida:

Establece el estado de salida de jq en 0 si los últimos valores de salida no fueron
falsos ni nulos, 1 si el último valor de salida fue falso o
nulo, o 4 si nunca se produjo un resultado válido. 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ó.

Otra forma de establecer el estado de salida es con la
función incorporada halt_error .

· –Arg valor del nombre:

Esta opción pasa un valor al programa jq como una variable predefinida
Si ejecuta jq con –arg foo bar, entonces $ foo está disponible en
el programa y tiene el valor “bar”. Tenga en cuenta que el valor se
tratará como una cadena, por lo que –arg foo 123 vinculará $ foo a “123”.

Los argumentos con nombre también están disponibles para el programa jq como
$ ARGS.named.

· –Argjson nombre JSON-text:

Esta opción pasa un valor codificado en JSON al programa jq como una
variable predefinida. Si ejecuta jq con –argjson foo 123, $ foo
está disponible en el programa y tiene el valor 123.

· –Slurpfile nombre de variable nombre de archivo:

Esta opción lee todos los textos JSON en el archivo nombrado y vincula una
matriz de los valores JSON analizados a la variable global dada. Si
ejecuta jq con –argfile foo bar, entonces $ foo está disponible en el
programa y tiene una matriz cuyos elementos corresponden a los textos en
el archivo llamado bar.

· –Argfile nombre de variable nombre de archivo:

No utilice. Utilice –slurpfile en su lugar.

(Esta opción es como –slurpfile, pero cuando el archivo tiene solo un
texto, entonces se usa ese; de ​​lo contrario, se usa una matriz de textos como en
–slurpfile).

· –Args:

Los argumentos restantes son argumentos de cadena posicionales. Están
disponibles para el programa jq como $ ARGS.positional [].

· –Jsonargs:

Los argumentos restantes son argumentos de texto JSON posicionales. Están
disponibles para el programa jq como $ ARGS.positional [].

· –Run-tests [nombre de 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, líneas vacías y líneas de programa
seguidas de una línea de entrada, tantas líneas de salida como se espera
(una por salida) y una línea vacía final. Las
pruebas de falla de compilación comienzan con una línea que contiene solo "%% FAIL", luego una línea que
contiene el programa a 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 forma incompatible.

FILTROS BÁSICOS
Identidad:.
El filtro más simple absoluto es. Este es un filtro que toma su
entrada y la produce sin cambios como salida. Es decir, este es el
operador de identidad.

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

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

Object Identifier-Index: .foo, .foo.bar
El filtro útil más simple es .foo. Cuando se le da un objeto JSON (también conocido como diccionario
o hash) como entrada, produce el valor en la clave "foo", o
nulo si no hay ninguno presente.

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

Esta sintaxis solo funciona para claves simples similares a identificadores, es decir, claves
que están compuestas por caracteres alfanuméricos y guiones bajos, y que
no comienzan con un dígito.

Si la clave contiene caracteres especiales, debe rodearla con
comillas dobles como esta:. ”Foo $”, o bien. [“Foo $”].

Por ejemplo. [“Foo :: bar”] y. [“Foo.bar”] funcionan mientras que .foo :: bar
no, y .foo.bar significa. [“Foo”]. [“Bar”].

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

jq ´.foo´
{"notfoo": verdadero, "alsonotfoo": falso}
=> nulo

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

Identificador-índice de objeto opcional: .foo?
Al igual que .foo, pero ni siquiera genera un error cuando. no es una
matriz ni un objeto.

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

jq ´.foo? ´
{"notfoo": verdadero, "alsonotfoo": falso}
=> nulo

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

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

Índice de objeto genérico:. []
También puede buscar campos de un objeto usando una sintaxis como. [“Foo”]
(.foo arriba es una versión abreviada de esto, pero solo para
cadenas de tipo identificador ).

Índice de matriz:. [2]
Cuando el valor del índice es un número entero,. [] puede indexar matrices. Las matrices
están basadas en cero, por lo que [2] devuelve el tercer elemento.

Se permiten índices negativos, donde -1 se refiere al último elemento, -2 se
refiere al penúltimo elemento, y así sucesivamente.

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] ´
[1,2,3]
=> 2

Array / String Slice:. [10:15]
La sintaxis. [10:15] se puede usar para devolver un subarreglo de un arreglo o una
subcadena de una cadena. La matriz devuelta por. [10:15] tendrá una longitud de
5 y contendrá los elementos del índice 10 (incluido) 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 al final de la matriz).

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”]

Iterador de valor de matriz / objeto:. []
Si usa la sintaxis. [Índice], pero omite el índice por completo,
devolverá todos los elementos de una matriz. Ejecutar. [] 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

. []?
Como. [], Pero no se generarán errores si. no es una matriz u objeto.

Coma :,
Si dos filtros están separados por una coma, entonces la misma entrada se
alimentará en ambos y los flujos de valor de salida de los dos filtros se concatenarán
en orden: primero, todas las salidas producidas por la
expresión de la izquierda , y luego todas las salidas producidas por la derecha. Por
ejemplo, filter .foo, .bar, produce tanto los campos "foo" como los campos "bar"
como salidas separadas.

jq ´.foo, .bar´
{“foo”: 42, “bar”: “algo más”, “baz”: verdadero}
=> 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”

Tubería: |
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á para cada uno de esos resultados. Entonces, la expresión. [] | .foo
recupera el campo "foo" de cada elemento de la matriz de entrada.

Tenga en cuenta que .abc es lo mismo que .a | .b | .C.

Tenga en cuenta también eso. es el valor de entrada en la etapa particular en una "tubería
", específicamente: donde el. aparece la expresión. Por lo tanto .a | .b
es lo mismo que .ab, ya que. en el medio se refiere a cualquier valor .a
producido.

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

Paréntesis Los
paréntesis funcionan como un operador de agrupación como en cualquier
lenguaje de programación típico .

jq ´ (. + 2) * 5´
1
=> 15

TIPOS Y VALORES
jq admite el mismo conjunto de tipos de datos que JSON: números, cadenas, valores
booleanos, matrices, objetos (que en JSON-speak son hashes 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 una expresión jq válida que toma
una entrada, la ignora y devuelve 42 en su lugar.


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

Una vez que comprenda el operador ",", puede ver la sintaxis de la matriz de jq
bajo una luz diferente: la expresión [1,2,3] no usa una
sintaxis incorporada para matrices separadas por comas, sino que aplica el operador []
(recopilar resultados) a la expresión 1,2,3 (que produce tres
resultados diferentes).

Si tiene un filtro X que produce cuatro resultados, entonces la expresión
[X] producirá un solo resultado, una matriz de cuatro elementos.

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

jq ´ [. [] | * 2] ´
[1, 2, 3]
=> [2, 4, 6]

Construcción de objetos: {}
Al igual que JSON, {} es para construir objetos (también conocidos como diccionarios o hash),
como en: {“a”: 42, “b”: 17}.

Si las claves son "similares a un identificador", entonces las comillas pueden omitirse, como
en {a: 42, b: 17}. Las claves generadas por expresiones deben estar entre paréntesis
, por ejemplo, {(“a” + ”b”): 59}.

El valor puede ser cualquier expresión (aunque puede que tengas que ponerlo entre
paréntesis si es complicado), que se aplica a la
entrada de la expresión {} (recuerda, todos los filtros tienen una entrada y una salida).

{foo: .bar}

producirá el objeto JSON {"foo": 42} si se le da el objeto JSON
{"bar": 42, "baz": 43} como entrada. 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", puedes escribir

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

Debido a que es tan común, hay una sintaxis de acceso directo para ello: {usuario,
título}.

Si una de las expresiones produce varios resultados, se producirán varios diccionarios
Si la entrada

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

luego la expresión

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

producirá dos salidas:

{"Usuario": "stedolan", "título": "JQ Primer"}
{"usuario": "stedolan", "título": "Más JQ"}

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

{(.usuario): .titles}

produce

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

jq ´ {usuario, título: .titles []} ´
{“usuario”: ”stedolan”, ”títulos”: [“JQ Primer”, “Más JQ”]}
=> {“usuario”: ”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"]}

Descenso recursivo: .. Descenso
recursivo., Produciendo cada valor. Es lo mismo que el
recursivo incorporado de argumento cero (ver más abajo). Tiene la intención de parecerse
al operador XPath //. Tenga en cuenta que ..a no funciona; utilice .. | .a en su lugar.
En el siguiente ejemplo usamos .. | .a? para encontrar todos los valores de las
claves de objeto "a" en cualquier objeto que se encuentre "debajo" ..

Esto es particularmente útil junto con la ruta (EXP) (ver también más
abajo) y el? operador.

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

FUNCIONES Y OPERADORES INTEGRADOS
Algunos operadores jq (por ejemplo, +) hacen cosas diferentes dependiendo del
tipo de sus argumentos (matrices, números, etc.). Sin embargo, jq ​​nunca realiza
conversiones de tipo implícitas. Si intenta agregar una cadena a un objeto,
obtendrá un mensaje de error y ningún resultado.

Suma: +
El operador + toma dos filtros, los aplica a la misma entrada
y suma los resultados. Lo que significa "agregar" depende de los tipos
involucrados:

· Los números se suman mediante aritmética normal.

· Las matrices se agregan concatenadas en una matriz más grande.

· Las cadenas se agregan uniéndose en una cadena más grande.

· Los 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 la misma clave, el objeto a la derecha
de + gana. (Para una combinación recursiva, use el operador *).

null 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 + null´
{“a”: 1}
=> 1

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

jq ´ {a: 1} + {b: 2} + {c: 3} + {a: 42} ´
null
=> {“a”: 42, “b”: 2, “c”: 3}

Resta: -
Además de la resta aritmética normal en números, el operador - se
puede usar 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, módulo: *, / y%
Estos operadores infijos se comportan como se esperaba cuando se les dan dos números. La división
por cero genera un error. x% y calcula x módulo y.

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

Dividir una cuerda 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 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

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

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

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

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

· La longitud del nulo es cero.

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

utf8bytelength
La función incorporada utf8bytelength genera el número de bytes usados ​​para
codificar una cadena en UTF-8.

jq ´utf8bytelength´
“\ u03bc”
=> 2

keys, keys_unsorted
Las teclas de función incorporadas, cuando se les da un objeto, devuelven sus claves en una
matriz.

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

Cuando a las claves se le da una matriz, devuelve los índices válidos para esa
matriz: los números enteros de 0 a longitud-1.

La función keys_unsorted es como keys, pero si la entrada es un
objeto, las claves no se ordenarán, sino que estarán aproximadamente
en orden de inserción.

jq ´keys´
{“abc”: 1, “abcd”: 2, “Foo”: 3}
=> [“Foo”, “abc”, “abcd”]

jq ´keys´
[42,3,35]
=> [0,1,2]

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

has ($ key) tiene el mismo efecto que comprobar si $ key es un miembro de
la matriz devuelta por keys, aunque has será más rápido.

jq ´map (has (“foo”)) ´
[{“foo”: 42}, {}]
=> [verdadero, falso]

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

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

jq ´. [] | in ({“foo”: 42}) ´
[“foo”, “bar”]
=> verdadero, falso

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

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

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

map (x) es equivalente a [. [] | X]. De hecho, así se define.
De manera 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}

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

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

path (exact_path_expression) producirá la representación de matriz de
la expresión de ruta incluso si no existe en., if. es nulo o una
matriz o un objeto.

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

Tenga en cuenta que las expresiones de ruta no son diferentes de las expresiones normales
La expresión ruta (.. | select (type == ”boolean”)) genera todas las
rutas a valores booleanos en., Y solo esas rutas.

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

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

del (path_expression)
La función incorporada del 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”]

getpath (PATHS)
La función incorporada getpath genera los valores en. encontrado en cada camino
en CAMINOS.

jq ´getpath ([“a”, ”b”]) ´
null
=> null

jq ´ [getpath ([“a”, ”b”], [“a”, ”c”])] ´
{“a”: {“b”: 0, “c”: 1}}
=> [0 , 1]

setpath (PATHS; VALUE)
La función incorporada setpath establece los PATHS en. valorar.

jq ´setpath ([“a”, ”b”]; 1) ´
null
=> {“a”: {“b”: 1}}

jq ´setpath ([“a”, ”b”]; 1) ´
{“a”: {“b”: 0}}
=> {“a”: {“b”: 1}}

jq ´setpath ([0, ”a”]; 1) ´
null
=> [{“a”: 1}]

delpaths (PATHS)
La función incorporada delpaths establece los PATHS en. PATHS debe ser una
matriz de rutas, donde cada ruta es una matriz de cadenas y números.

jq ´delpaths ([[“a”, ”b”]]) ´
{“a”: {“b”: 1}, ”x”: {“y”: 2}}
=> {“a”: { }, ”X”: {“y”: 2}}

to_entries, from_entries, with_entries
Estas funciones convierten entre un objeto y una matriz de
pares clave-valor Si se pasa un objeto a to_entries, entonces, para cada entrada k: v en
la entrada, la matriz de salida incluye {“clave”: k, “valor”: v}.

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

jq ´to_entries´
{“a”: 1, “b”: 2}
=> [{“clave”: ”a”, “valor”: 1}, {“clave”: ”b”, “valor”: 2 }]

jq ´from_entries´
[{“clave”: ”a”, “valor”: 1}, {“clave”: ”b”, “valor”: 2}]
=> {“a”: 1, “b”: 2}

jq ´with_entries (.key | = “KEY_” +.) ´
{“a”: 1, “b”: 2}
=> {“KEY_a”: 1, “KEY_b”: 2}

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

Es útil para filtrar listas: [1,2,3] | map (seleccione (.> = 2)) le
dará [2,3].

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

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

matrices, objetos, iterables, booleanos, números, normales, finitos, cadenas,
nulos, valores, escalares
Estos incorporados seleccionan solo entradas que son matrices, objetos, iterables
(matrices u objetos), booleanos, números, números normales, números finitos ,
cadenas, valores nulos, no nulos 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, al igual que .a aplicado a valores distintos a los nulos y los
objetos, pero con el mensaje dado como valor del error. Los errores
se pueden detectar con try / catch; vea abajo.

halt
Detiene el programa jq sin más salidas. jq saldrá con el
estado de salida 0.

halt_error, halt_error (exit_code)
Detiene el programa jq sin más salidas. La entrada se imprimirá
en stderr como salida sin formato (es decir, las cadenas no tendrán comillas dobles)
sin decoración, ni siquiera una nueva línea.

El exit_code dado (predeterminado en 5) será el estado de salida de jq.

Por ejemplo, "Error: algo salió mal \ n" | halt_error (1).

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

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

rutas, rutas (node_filter), leaf_paths
rutas genera las rutas a todos los elementos en su entrada (excepto que
no muestra la lista vacía, que se representa a sí mismo).

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

leaf_paths es un alias de rutas (escalares); leaf_paths está obsoleto y
se eliminará en la próxima versión principal.

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

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 sumados. Esto podría significar sumados, concatenados
o fusionados según los tipos de elementos de la matriz de entrada;
las reglas son las mismas que las del operador + (descritas anteriormente).

Si la entrada es una matriz vacía, agregar devuelve nulo.

jq ´add´
[“a”, ”b”, ”c”]
=> “abc”

jq ´add´
[1, 2, 3]
=> 6

jq ´add´
[]
=> nulo

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

Si la entrada es una matriz vacía, any devuelve falso.

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

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

jq ´any´
[verdadero, falso]
=> verdadero

jq ´any´
[falso, falso]
=> falso

jq ´any´
[]
=> falso

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

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

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

Si la entrada es una matriz vacía, todo devuelve verdadero.

jq ´all´
[verdadero, falso]
=> falso

jq ´all´
[verdadero, verdadero]
=> verdadero

jq ´all´
[]
=> cierto

aplanar, aplanar (profundidad)
El filtro aplanar toma como entrada una matriz de matrices anidadas y
produce una matriz plana en la 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.

flatten (2) es como aplanar, pero solo llega a dos niveles de profundidad.

jq ´flatten´
[1, [2], [[3]]]
=> [1, 2, 3]

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

jq ´flatten´
[[]]
=> []

jq ´flatten´
[{“foo”: “bar”}, [{“foo”: “baz”}]]
=> [{“foo”: “bar”}, {“foo”: “baz”}]

rango (hasta), rango (desde; hasta) rango (desde; hasta; por)
La función de rango produce un rango de números. range (4; 10) produce 6
números, desde 4 (inclusive) hasta 10 (exclusivo). Los números se producen
como salidas independientes. Utilice [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 del desde al hasta con un
incremento de 1.

La forma de tres argumentos genera números desde hasta hasta con un incremento
de por.

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

jq ´ [rango (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 función piso devuelve el piso de su entrada numérica.

jq ´floor´
3.14159
=> 3

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

jq ´sqrt´
9
=> 3

tonumber
La función tonumber analiza su entrada como un número. Convertirá
cadenas con el formato correcto en su equivalente numérico, dejará los números en
paz y dará un error en todas las demás entradas.

jq ´. [] | tonumber´
[1, “1”]
=> 1, 1

tostring
La función tostring imprime su entrada como una cadena. Las cadenas no se
modifican y todos los demás valores están codificados en JSON.

jq ´. [] | tostring´
[1, “1”, [1]]
=> “1”, “1”, “[1]”

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

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

infinito, nan, isinfinito, isnan, isfinite, isnormal
Algunas operaciones aritméticas pueden producir infinitos y
valores de “no un número” (NaN). El incorporado isinfinite devuelve verdadero si su entrada es infinita
El isnan incorporado devuelve verdadero si su entrada es un NaN. El
infinito incorporado devuelve un valor infinito positivo. El nan incorporado devuelve
un NaN. El comando interno isnormal 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 generan
errores.

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

jq ´infinite, nan | type´
null
=> "número", "número"

sort, sort_by (path_expression)
Las funciones sort ordena su entrada, que debe ser una matriz. Los valores se
ordenan en el siguiente orden:

· nulo

· Falso

· cierto

· 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 se comparan 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 ´sort´
[8,3, null, 6]
=> [null, 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 (path_expression)
group_by (.foo) toma como entrada una matriz, agrupa los elementos que tienen el
mismo campo .foo en matrices separadas y produce todas estas matrices
como elementos de una matriz más grande, ordenados por el valor del campo .foo .

Cualquier expresión jq, no solo un acceso de campo, puede usarse en lugar de
.foo. El orden de clasificación es el mismo que se describe en la función de clasificació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, max, min_by (path_exp), max_by (path_exp)
Encuentra el elemento mínimo o máximo de la matriz de entrada.

Las funciones min_by (path_exp) y max_by (path_exp) le permiten especificar
un campo o propiedad en particular para examinar, por ejemplo, min_by (.foo) encuentra
el objeto con el campo foo más pequeño.

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

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

unique, unique_by (path_exp)
La función única toma como entrada una matriz y produce una matriz de
los mismos elementos, en orden ordenado, con los duplicados eliminados.

La función unique_by (path_exp) mantendrá solo un elemento por cada
valor obtenido al aplicar el argumento. Piense en ello como hacer una matriz
tomando un elemento de cada grupo producido por grupo.

jq ´unique´
[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 (largo) ´
[“grueso”, “tocino”, “gatito”, “cigarra”, “espárragos”]
=> [“tocino”, “grueso”, “espárragos”]

reverse
Esta función invierte una matriz.

jq ´reverse´
[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. Una 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 está contenido en el objeto A
si todos los valores de B están contenidos en el valor de A con la misma
clave. Se supone que todos los demás tipos están contenidos entre sí si
son iguales.

jq ´contains (“bar”) ´
“foobar”
=> verdadero

jq ´contains ([“baz”, “bar”]) ´
[“foobar”, “foobaz”, “blarp”]
=> verdadero

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

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

jq ´contains ({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 formato. donde ocurre s. La entrada
puede ser una matriz, en cuyo caso, si s es una matriz, la salida de los índices
será aquella en la que estén todos los elementos. coinciden con los del s.

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

jq ´indices (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]

index (s), rindex (s)
Emite el índice de la primera (índice) o última (rindex) aparición de s
en la entrada.

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

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

inside
El filtro inside (b) producirá verdadero si la entrada está completamente contenida
dentro de b. 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

startswith (str) Da como
resultado verdadero si. comienza con el argumento de cadena dado.

jq ´ [. [] | startswith (“foo”)] ´
[“fo”, “foo”, “barfoo”, “foobar”, “barfoob”]
=> [falso, verdadero, falso, verdadero, falso]

termina con (str)
Salida verdadera 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)
Envía 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 ´explode´
“foobar”
=> [102,111,111,98,97,114]

implosión
El inverso de explotar.

jq ´implode´
[65, 66, 67]
=> “ABC”

split (str)
Divide una cadena de entrada en el argumento del separador.

jq ´split (“,“) ´
“a, b, c, d, e,”
=> [“a”, ”b, c, d”, ”e”, ””]

join (str)
Une la matriz de elementos dados como entrada, usando el argumento como separador
Es lo inverso de split: es decir, ejecutar split ("foo") |
join ("foo") sobre cualquier cadena de entrada devuelve dicha cadena de entrada.

Los números y valores booleanos de la entrada se convierten en cadenas. Los valores nulos
se tratan como cadenas vacías. No se
admiten matrices y objetos en la entrada .

jq ´join (“,“) ´
[“a”, ”b, c, d”, ”e”]
=> “a, b, c, d, e”

jq ´join (”“) ´
[“a”, 1,2.3, true, null, false]
=> “a 1 2.3 true false”

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

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

Tenga en cuenta que while (cond; update) se define internamente como una
función jq recursiva Las llamadas recursivas dentro de while no consumirán memoria adicional
si la actualización produce como máximo una 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 función hasta (cond; siguiente) le permite aplicar repetidamente la
expresión siguiente, inicialmente a. luego a su propia salida, hasta que cond sea
verdadera. 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 Las llamadas recursivas dentro de until () no consumirán
memoria adicional si next produce como máximo una salida para cada entrada. Consulte los
temas avanzados a continuación.

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

recurse (f), recurse, recurse (f; condition), recurse_down
La función recurse (f) 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": "/ bin", "niños": [
{"nombre": "/ bin / ls", "niños": []},
{ "Nombre": "/ bin / sh", "niños": []}]},
{"nombre": "/ hogar", "niños": [
{"nombre": "/ hogar / stephen", "niños ”: [
{“ Nombre ”:“ / home / stephen / jq ”,“ niños ”: []}]}]}]}

Ahora suponga que desea extraer todos los nombres de archivo presentes. Necesita
recuperar .name, .children []. Name, .children []. Children []. Name, y
así sucesivamente. Puedes hacer esto con:

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

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

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

recurse (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. Por ejemplo, para generar todos los números
enteros, al menos en principio, se podría escribir recurse (. + 1; true).

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

Las llamadas recursivas en recursivo no consumirán memoria adicional
siempre que f produzca como máximo una salida única para cada entrada.

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

jq ´recurse´
{“a”: 0, ”b”: [1]}
=> {“a”: 0, ”b”: [1]}, 0, [1], 1

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

walk (f)
La función walk (f) se aplica f recursivamente a cada componente de la
entidad de entrada. Cuando se encuentra una matriz, primero se aplica f a sus
elementos y luego a la propia matriz; cuando se encuentra un objeto,
primero se aplica a todos los valores y luego al objeto. En la práctica,
f normalmente probará el tipo de entrada, como se ilustra en los
siguientes ejemplos. El primer ejemplo destaca la utilidad de
procesar los elementos de una matriz de matrices antes de procesar la matriz en
sí. El segundo ejemplo muestra cómo todas las claves de todos los objetos
dentro de la entrada se pueden considerar para alteración.

jq ´walk (si escribe == “matriz”, luego ordene más. end) ´
[[4, 1, 7], [8, 5, 2], [3, 6, 9]]
=> [[1,4 , 7], [2,5,8], [3,6,9]]

jq ´walk (si type == “object” then with_entries (.key | = sub (“^ _ +”; “”)) else. end) ´
[{“_a”: {“__b”: 2}}]
=> [{“A”: {“b”: 2}}]

$ ENV, env
$ ENV es un objeto que representa las variables de entorno establecidas cuando se
inició el programa jq.

env genera un objeto que representa el entorno actual de jq.

Por el momento, no existe una función incorporada para configurar las variables de entorno.

jq ´ $ ENV.PAGER´
null
=> “menos”

jq ´env.PAGER´
null
=> “menos”

transponer
Transponer una matriz posiblemente irregular (una matriz de matrices). Las filas se
rellenan con nulos, por lo que el resultado siempre es rectangular.

jq ´transpose´
[[1], [2,3]]
=> [[1,2], [null, 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 está ordenada, devolverá (-1 -
ix) donde ix es un punto de inserción de modo que la matriz todavía se ordenaría
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 ´bsearch (0) ´
[0,1]
=> 0

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

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

Interpolación de cadenas - \ (foo)
Dentro de una cadena, puede poner una expresión dentro de paréntesis después de una
barra invertida Lo que sea que devuelva la expresión se interpolará 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 a / desde JSON
Los valores incorporados tojson y fromjson descargan valores como textos JSON o analizan
textos JSON en valores, respectivamente. El incorporado tojson difiere de
tostring en que tostring devuelve 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”]]
=> [1, ”foo”, [“foo ”]]

Formatear cadenas y escapar
La sintaxis @foo se utiliza 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 por sí solo, los posibles escapes
son:

@texto:

Llamadas a cadena, consulte esa función para obtener más detalles.

@json:

Serializa la entrada como JSON.

@html:

Aplica el escape HTML / XML, asignando los caracteres <> & ´ ”a
sus entidades equivalentes <,>, &, ',".

@uri:

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

@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 tabuladores ). Cada matriz de entrada se imprimirá como una sola
línea. Los campos están separados por una sola pestaña (ascii 0x09). Los
caracteres de entrada de alimentación de línea (ascii 0x0a), retorno de carro (ascii 0x0d),
tab (ascii 0x09) y barra invertida (ascii 0x5c) se generarán como
secuencias de escape \ 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 la entrada 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.

@ base64d:

Lo inverso de @ base64, la entrada se decodifica según lo especificado por RFC
4648. Nota: Si la cadena decodificada no es UTF-8, los resultados
no están definidos.

Esta sintaxis se puede combinar con la interpolación de cadenas de una manera útil.
Puede seguir un token @foo con un literal de cadena. El contenido de la
cadena literal no se escapará. 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 {"búsqueda": "¿qué es
jq?"}:

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

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

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

jq ´@sh “echo \(.)”´
“O´Hara´s Ale”
=> “echo ´O´\\´´Hara´\\´´s Ale´”

jq ´@base64´
“This is a message”
=> “VGhpcyBpcyBhIG1lc3NhZ2U=”

jq ´@base64d´
“VGhpcyBpcyBhIG1lc3NhZ2U=”
=> “This is a message”

Dates
jq provides some basic date handling functionality, with some
high-level and low-level builtins. In all cases these builtins deal
exclusively with time in UTC.

The fromdateiso8601 builtin parses datetimes in the ISO 8601 format to
a number of seconds since the Unix epoch (1970-01-01T00:00:00Z). The
todateiso8601 builtin does the inverse.

The fromdate builtin parses datetime strings. Currently fromdate only
supports ISO 8601 datetime strings, but in the future it will attempt
to parse datetime strings in more formats.

The todate builtin is an alias for todateiso8601.

The now builtin outputs the current time, in seconds since the Unix
epoch.

También se proporcionan interfaces jq de bajo nivel para las funciones de tiempo de la biblioteca C
: strptime, strftime, strflocaltime, mktime, gmtime y local‐
time. Consulte la documentación de su sistema operativo host para conocer las
cadenas de formato utilizadas por strptime y strftime. Nota: estas no son necesariamente
interfaces estables en jq, particularmente en cuanto a su
funcionalidad de localización .

El gmtime incorporado consume una cantidad de segundos desde la época de Unix
y genera una representación de "tiempo desglosado" de Greenwhich Meridian
time como una matriz de números que representan (en este orden): el año, el
mes (basado en cero), el día del mes (basado en uno), la hora del
día, el minuto de la hora, el segundo del minuto, el día de la
semana y el día del año, todos basados ​​en uno a menos que se indique lo contrario.
El número de día de la semana puede ser incorrecto en algunos sistemas para fechas
anteriores al 1 de marzo de 1900 o posteriores al 31 de diciembre de 2099.

El incorporado localtime funciona como el incorporado gmtime, pero usando la
configuración de zona horaria local.

El incorporado mktime consume representaciones de "tiempo desglosado" de la
salida de tiempo por gmtime y strptime.

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

El formato incorporado strftime (fmt) formatea una hora (GMT) con el formato dado.
Strflocaltime hace lo mismo, pero usando la configuración de zona horaria local.

Las cadenas de formato para strptime y strftime se describen en la
documentación típica de la biblioteca de C. La cadena de formato para 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
En particular, los especificadores% u y% j para strptime (fmt) no son
compatibles con macOS.

jq ´fromdate´
“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

Operadores de estilo SQL
jq proporciona algunos operadores de estilo SQL.

ÍNDICE (flujo; expresión_índice):

This builtin produces an object whose keys are computed by the
given index expression applied to each value from the given
stream.

JOIN($idx; stream; idx_expr; join_expr):

This builtin joins the values from the given stream to the given
index. The index´s keys are computed by applying the given index
expression to each value from the given stream. An array of the
value in the stream and the corresponding value from the index
is fed to the given join expression to produce each result.

JOIN($idx; stream; idx_expr):

Same as JOIN($idx; stream; idx_expr; .).

JOIN($idx; idx_expr):

Este incorporado se une a la entrada. al índice dado, aplicando la
expresión de índice dada a. para calcular la clave de índice. La
operación de unión es como se describe arriba.

En s):

Esta salida incorporada es verdadero si. aparece en la secuencia dada, de lo
contrario, da como resultado falso.

IN (fuente; s):

Esta función incorporada da como resultado verdadero si
aparece algún valor en el flujo de origen en el segundo flujo; de lo contrario, da como resultado falso.

builtins
Devuelve una lista de todas las funciones integradas en el formato nombre / aridad. Dado que las
funciones con el mismo nombre pero diferentes aridades se consideran
funciones separadas , todas / 0, todas / 1 y todas / 2 estarían presentes en la
lista.

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

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

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

if-then-else
if A then B else C end actuará de la misma manera que B si A produce un valor
distinto de falso o nulo, pero actuará igual que C en caso contrario.

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 que deseas: no puedes probar
si, por ejemplo, una cadena está vacío usando if .name luego A else B end,
necesitará algo más como if (.name | length)> 0 luego A else B
end en su lugar.

Si la condición A produce varios resultados, entonces B se evalúa una vez
para cada resultado que no sea falso o nulo, y C se evalúa una vez para
cada falso o nulo.

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

jq ´if. == 0 entonces

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

>,> =, <=, <Los operadores de comparación>,> =, <=, <devuelven si su argumento izquierdo es mayor, mayor o igual que, menor o igual o menor que su argumento derecho ( respectivamente). El orden es el mismo que el descrito anteriormente para ordenar. jq ´. <5´ 2 => verdadero

and/or/not
jq supports the normal Boolean operators and/or/not. They have the same
standard of truth as if expressions – false and null are considered
“false values”, and anything else is a “true value”.

If an operand of one of these operators produces multiple results, the
operator itself will produce a result for each input.

not is in fact a builtin function rather than an operator, so it is
called as a filter to which things can be piped rather than with spe‐
cial syntax, as in .foo and .bar | not.

These three only produce the values “true” and “false”, and so are only
useful for genuine Boolean operations, rather than the common
Perl/Python/Ruby idiom of “value_that_may_be_null or default”. If you
want to use this form of “or”, picking between two values rather than
evaluating a condition, see the “//” operator below.

jq ´42 and “a string”´
null
=> true

jq ´(true, false) or false´
null
=> true, false

jq ´(true, true) and (true, false)´
null
=> true, false, true, false

jq ´ [verdadero, falso | not] ´
null
=> [falso, verdadero]

Operador alternativo: //
Un filtro de la forma a // b produce los mismos resultados que a, si a
produce resultados distintos de falso y nulo. De lo contrario, a // b produce los
mismos resultados que b.

Esto es útil para proporcionar valores predeterminados: .foo // 1 evaluará a 1 si
no hay ningún elemento .foo en la entrada. Es similar a cómo se
usa a veces o en Python (el operador jq o está reservado para
operaciones estrictamente booleanas ).

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

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

try-catch Los
errores pueden detectarse utilizando try EXP catch EXP. Se
ejecuta la primera expresión y, si falla, la segunda se ejecuta con el
mensaje de error La salida del controlador, si la hubiera, se envía como si hubiera sido
la salida de la expresión a intentar.

El formulario try EXP utiliza vacío como controlador de excepciones.

jq ´intentar .a coger “. no es un objeto ”´
verdadero
=>“. no es un objeto "

jq ´ [. [] | intente .a] ´
[{}, verdadero, {“a”: 1}]
=> [nulo, 1]

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

Romper las estructuras de control
Un uso conveniente de try / catch es romper las estructuras de control
como reduce, foreach, while, etc.

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) captura. == ”romper” y luego vacíe el error;

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

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

The break $label_name expression will cause the program to to act as
though the nearest (to the left) label $label_name produced empty.

The relationship between the break and corresponding label is lexical:
the label has to be “visible” from the break.

To break out of a reduce, for example:
label $out | reduce .[] as $item (null; if .==false then break $out else … end)

The following jq program produces a syntax error:

break $out

because no label $out is visible.

Error Suppression / Optional Operator: ?
The ? operator, used as EXP?, is shorthand for try EXP.

jq ´[.[]|(.a)?]´
[{}, true, {“a”:1}]
=> [null, 1]

EXPRESIONES REGULARES (PCRE)
jq utiliza 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 jq regex se definen para que se puedan usar usando uno de
estos patrones:

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

donde: * STRING, REGEX y FLAGS son cadenas jq y están sujetas a
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 prueba, coincidencia o captura, como se
describe a continuación.

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

· G - Búsqueda global (encuentra 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, por ejemplo

· 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.

test (val), test (regex; flags)
Como coincidencia, pero no devuelve objetos coincidentes, solo verdadero o falso para
si la expresión regular coincide o no con la entrada.

jq ´test (“foo”) ´
“foo”
=> verdadero

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

match (val), match (regex; flags)
match genera un objeto por cada coincidencia que encuentra. Los partidos tienen los
siguientes campos:

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

· Longitud - longitud en puntos de código UTF-8 del partido

· Cadena: la cadena que coincide

· Capturas: una serie de objetos que representan grupos de captura.

La captura de objetos de grupo tiene los siguientes campos:

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

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

· Cadena: la cadena que se capturó

· 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”: []} , {"Desplazamiento": 8, "longitud": 3, "cadena": "FOO", "capturas": []}

jq ´match (“foo (?bar)? foo ”; "Ig") ´
"foo bar foo foo foo"
=> {"desplazamiento": 0, "longitud": 11, "cadena": "foo bar foo", "capturas": [{"desplazamiento": 4, " longitud ”: 3,“ cadena ”:“ barra ”,“ nombre ”:“ barra123 ”}]}, {“ desplazamiento ”: 12,“ longitud ”: 8,“ cadena ”:“ foo foo ”,“ capturas ”: [{"Offset": -1, "length": 0, "string": null, "name": "bar123"}]}

jq ´ [coincidencia (“.”; “g”)] | length´
“abc”
=> 3

capture (val), capture (regex; flags)
Recopila las capturas con nombre en un objeto JSON, con el nombre de cada
captura como clave y la cadena coincidente como valor correspondiente.

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

scan (regex), scan (regex; flags)
Emite un flujo de subcadenas no superpuestas de la entrada que coinciden con
la expresión regular de acuerdo con las banderas, si se ha especificado alguna. Si
no hay ninguna coincidencia, la secuencia está vacía. Para capturar todas las coincidencias para
cada cadena de entrada, use el modismo [expr], por ejemplo, [scan (regex)].

split (regex; flags)
Para compatibilidad con versiones anteriores, divida divisiones en una cadena, no en una expresión regular.

splits (regex), splits (regex; flags)
Estos proporcionan los mismos resultados que sus contrapartes divididas, pero como una
secuencia en lugar de una matriz.

sub (regex; tostring) sub (regex; string; flags)
Emite la cadena obtenida reemplazando la primera coincidencia de regex en la
cadena de entrada con tostring, después de la interpolación. tostring debe ser una
cadena jq y puede contener referencias a capturas con nombre. El capitán nombrado
se presentan, en efecto, como un objeto JSON (construido por
captura) a tostring, por lo que una referencia a una variable capturada llamada "x"
tomaría la forma: "(.x)".

gsub (expresión regular; cadena), gsub (expresión regular; cadena; banderas)
gsub es como sub pero todas las apariciones no superpuestas de la expresión regular
son reemplazadas por la cadena, después de la interpolación.

CARACTERÍSTICAS AVANZADAS
Las variables son una necesidad absoluta en la mayoría de los lenguajes de programación, pero
están relegadas a una “característica avanzada” en jq.

En la mayoría de los lenguajes, las variables son el único medio de transmitir datos.
Si calcula un valor y desea utilizarlo más de una vez,
deberá 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.

It is also possible to define functions in jq, although this is is a
feature whose biggest use is defining jq´s standard library (many jq
functions such as map and find are in fact written in jq).

jq has reduction operators, which are very powerful but a bit tricky.
Again, these are mostly used internally, to define some useful bits of
jq´s standard library.

Puede que no sea obvio al principio, pero jq se trata de generadores (sí, como
se encuentra a menudo en otros idiomas). Se proporcionan algunas utilidades para ayudar
deal with generators.

Alguna compatibilidad mínima de E / S (además de leer JSON desde la entrada estándar y
writing JSON to standard output) is available.

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

Operador de vinculación variable / simbólica:… as $ identifier | 
En jq, todos los filtros tienen una entrada y una salida, por lo que
no es necesaria la instalación manual para pasar un valor de una parte de un programa a la siguiente.
Muchas expresiones, por ejemplo a + b, pasan su entrada a dos
subexpresiones distintas (aquí a y b se les pasa la misma entrada), por lo que las variables
no suelen ser necesarias para usar un valor dos veces.

Por ejemplo, calcular el valor promedio de una matriz de números
requiere algunas variables en la mayoría de los idiomas, al menos una para contener la
matriz, quizás una para cada elemento o para un contador de bucle. En jq, es
simplemente sumar / longitud: a la expresión sumar se le da la matriz y
produce su suma, y ​​a la expresión de longitud se le da 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 como $ variable. Todos los
nombres de variables comienzan con $. Aquí hay 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 facilite la vida.

Supongamos que tenemos una serie de publicaciones de blog, con
campos de "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í:

{"Publicaciones": [{"título": "primer psot", "autor": "anon"},
{"título": "Un artículo bien escrito", "autor": "persona1"}],
"nombres reales ”: {“ Anon ”:“ Cobarde anónimo ”,
“ persona1 ”:“ Persona McPherson ”}}

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

{"Título": "Primer psot", "autor": "Cobarde anónimo"}
{"título": "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 adelante cuando busquemos los nombres de usuario del autor:

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

La expresión exp como $ x | … Significa: para cada valor de expresión exp,
ejecutar el resto de la canalización con toda la entrada original y con
$ x establecido en ese valor. Así, as funciona como una especie de bucle foreach.

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

Se pueden declarar múltiples variables usando una sola expresión como al proporcionar
un patrón que coincida 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 (por ejemplo, como [$ primero, $
segundo]) se unen a los elementos de la matriz desde el elemento en el índice
cero en adelante, en orden. Cuando no hay ningún valor en el índice para un
elemento de patrón de matriz , se vincula nulo 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 [.author]}

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; solo se puede configurar un nuevo enlace con
el mismo nombre, pero que no será visible donde estaba el anterior.

jq ´.bar como $ x | .foo | + $ x´
{"foo": 10, "barra": 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 de funciones
Puede asignar un nombre a un filtro utilizando la sintaxis "def":

def incremento:. + 1;

A partir de ese momento, el incremento se puede utilizar como un filtro al igual que una función incorporada
(de hecho, así es como se definen muchas de las funciones incorporadas). Una función
puede tomar argumentos:

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

Los argumentos se pasan como filtros (funciones sin argumentos), no como
valores. Se puede hacer referencia al mismo argumento varias veces con diferentes
entradas (aquí se ejecuta f 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.
Es importante comprender esto. Considerar:

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

El resultado será 20 porque f es. * 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. Los argumentos de la función son filtros y los filtros esperan
una entrada cuando se invocan.

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

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

O usa la abreviatura:

def addvalue ($ f):…;

Con cualquier definición, addvalue (.foo) agregará el
campo .foo de la entrada actual a cada elemento de la matriz. Tenga en cuenta que llamar a
addvalue (. []) Hará que la parte del mapa (. + $ F) se evalúe una vez por
valor en el valor de. en el sitio de la llamada.

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

jq ´def addvalue (f):. + [f]; map (addvalue (. [0])) ´
[[1,2], [10,20]]
=> [[1,2,1], [10,20,10]]

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

Alcance
Hay dos tipos de símbolos en jq: enlaces de valores (también conocidos como “variables
”) y funciones. Ambos tienen un alcance léxico, y las expresiones
pueden referirse solo a símbolos que se han definido "a la
izquierda" de ellos. La única excepción a esta regla es que las funciones pueden
referirse a sí mismas para poder crear funciones recursivas.

Por ejemplo, en la siguiente expresión hay una encuadernación
visible "a la derecha",… | . * 3 como $ veces_tres | [. +
$ veces_tres] | …, Pero no “a la izquierda”. Considere esta expresión
ahora,… | (. * 3 como $ veces_tres | [. + $ Veces_tres]) | …: Aquí el
enlace $ times_three no es visible más allá del paréntesis de cierre.

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

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

Para cada resultado que. [] Produce,. + $ item 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

isempty (exp)
Devuelve verdadero si exp no produce salidas, falso en caso contrario.

jq ´isempty (vacío) ´
null
=> verdadero

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

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

first (expr), last (expr), nth (n; expr)
Las funciones first (expr) y last (expr) extraen el primer y último
valor de expr, respectivamente.

La función n-ésima (n; expr) extrae el valor n-ésimo generado por expr. Esto
se puede definir como def nth (n; expr): last (limit (n + 1; expr)) ;. Tenga en cuenta
que nth (n; expr) no admite valores negativos de n.

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

first, last, nth (n)
La primera y la última función extraen el primer y último valor de cualquier
matriz en ..

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

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

foreach
La sintaxis de foreach es similar a reduce, pero está destinada a permitir la
construcción de límites y reductores que produzcan resultados intermedios (ver
ejemplo).

El formulario es para cada EXP como $ var (INIT; UPDATE; EXTRACT). Al igual que reduce,
INIT se evalúa una vez para producir un valor de estado, luego cada salida de
EXP está vinculada a $ var, UPDATE se evalúa para cada salida de EXP con
el estado actual y con $ var visible. Cada valor generado por UPDATE
reemplaza el estado anterior. Finalmente, EXTRACT se evalúa para cada nuevo
estado para extraer una salida de foreach.

Esto es principalmente útil solo para construir funciones de tipo reducción y límite
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]), [ ]] end; if $ item == null then. [1] else empty end)] ´
[1,2,3,4, null, ”a”, ”b”, null]
=> [[1,2, 3,4], ["a", "b"]]

Recursión
Como se describió anteriormente, la recursividad utiliza la recursividad y cualquier función jq puede ser
recursiva. El while incorporado también se implementa en términos de recursividad.

Las llamadas de cola se optimizan siempre que la expresión a la izquierda de la
llamada recursiva genera su último valor. En la práctica, esto significa que la
expresión a la izquierda de la llamada recursiva no debería producir más
de una salida para cada entrada.

Por ejemplo:

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

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

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

Generadores e 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 otros lenguajes de programación 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 la expresión a la izquierda de la coma, luego para cada uno de
ellos, los valores generados por la expresión a la derecha de la coma.

El incorporado vacío es el generador que produce cero salidas. El
builtin vacío retrocede hasta la expresión generadora anterior.

Todas las funciones de jq pueden ser generadores simplemente usando generadores integrados. También
es posible definir nuevos generadores usando solo la recursividad y el
operador de coma. Si las llamadas recursivas están “en posición de cola”,
entonces el generador será eficiente. En el siguiente ejemplo, la
llamada recurrente de _range a sí mismo está en la posición final. El ejemplo muestra
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; _mientras; [mientras (. <100;. * 2)] ´ 1 => [1,2,4,8,16,32,64]

MATH
jq actualmente solo tiene
soporte de número de punto flotante de doble precisión (64 bits) IEEE754 .

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

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

Funciones matemáticas en C de una entrada: acos acosh asin asinh atan atanh cbrt ceil
cos cosh erf erfc exp exp10 exp2 expm1 fabs floor gamma j0 j1 lgamma
log log10 log1p log2 logb nearint pow10 rint round significand sin
sinh sqrt tan tanh tgamma trunc y0 y1.

Funciones matemáticas de C de dos entradas: atan2 copysign drem fdim fmax fmin fmod frexp
hypot jn ldexp modf nextafter nexttoward pow resto scalb
scalbln yn.

Funciones matemáticas C de tres entradas: fma.

Consulte el manual de su sistema para obtener más información sobre cada uno de estos.

E / S
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, entrada y entradas, que leen de las mismas fuentes (por ejemplo, stdin,
archivos nombrados en la línea de comandos) que jq. Estos dos elementos incorporados, y
las propias acciones de lectura de jq, se pueden intercalar entre sí.

Dos incorporados proporcionan capacidades de salida mínimas, depuración y stderr.
(Recuerde que los valores de salida de un programa jq siempre se generan como
textos JSON en stdout.) El debug incorporado puede tener un
comportamiento específico de la aplicación , como para los ejecutables que usan la API libjq C pero no son
el ejecutable jq en sí. El stderr incorporado genera su entrada en
modo raw a stder sin decoración adicional, ni siquiera una nueva línea.

La mayoría de las incorporaciones jq son referencialmente transparentes y producen
flujos de valor constantes y repetibles cuando se aplican a entradas constantes. Esto no es
cierto para las incorporaciones de E / S.

entrada
Emite una nueva entrada.

entradas
Emite todas las entradas restantes, una por una.

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

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

stderr
Imprime su entrada en modo raw y compacto en stderr sin
decoración adicional , ni siquiera una nueva línea.

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

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

TRANSMISIÓN
Con la opción –stream, jq puede analizar los textos de entrada en una forma de transmisión
, permitiendo que los programas jq comiencen a procesar grandes textos JSON
inmediatamente en lugar de después de que se complete el análisis. Si tiene un solo
texto JSON de 1 GB de tamaño, transmitirlo le permitirá procesarlo
mucho más rápidamente.

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 las corrientes.

Los ejemplos siguientes utilizan la forma transmitida de [0, [1]], que 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). Las versiones futuras de jq que se ejecuten con –stream y
-seq pueden generar formularios adicionales como [“mensaje de error”] 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 (stream_expression) Muestra los
valores correspondientes a las salidas de la expresión del flujo.

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

tostream
El tostream incorporado 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 distingue entre referencias y copias de
algo: dos objetos o matrices son iguales o no iguales, 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 .bar, y agrega
algo a .foo, entonces .bar no aumentará de tamaño, incluso si ha
establecido previamente .bar = .foo. Si estás acostumbrado a programar en lenguajes
como Python, Java, Ruby, Javascript, etc., entonces puedes pensar en ello como
si jq hiciera una copia completa y profunda de cada objeto antes de realizar la
asignación (para el rendimiento, en realidad no haz eso, pero esa es la
idea general).

Esto significa que es imposible construir valores circulares en jq (como
una matriz cuyo primer elemento es él mismo). Esto es bastante intencionado y
garantiza que cualquier cosa que pueda producir un programa jq pueda representarse en
JSON.

Todos los operadores de asignación en jq tienen expresiones de ruta en el
lado izquierdo (LHS). El lado derecho (RHS) proporciona valores para establecer
las rutas nombradas por las expresiones de ruta LHS.

Los valores en jq son siempre inmutables. Internamente, la asignación funciona
utilizando una reducción para calcular nuevos valores de reemplazo para. que han
tenido todas las asignaciones deseadas aplicadas a., luego emitiendo el
valor modificado. Esto podría quedar claro con este ejemplo: {a: {b: {c: 1}}} |
(.ab | = 3), .. Esto generará {"a": {"b": 3}} y {"a": {"b": {"c": 1}}}
porque el último sub -expresión,., ve el valor original, no el
valor modificado.

La mayoría de los usuarios querrán utilizar operadores de asignación de modificación, como
| = o + =, en lugar de =.

Tenga en cuenta que el LHS de los operadores de asignación se refiere a un valor en .. Por lo tanto,
$ var.foo = 1 no funcionará como se esperaba ($ var.foo no es una
expresión de ruta válida o útil en.); use $ var | .foo = 1 en su lugar.

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

Asignación de actualización: | =
Este es el operador de “actualización” ´ | = ´. 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, .bar) | =. + 1 construirá un objeto con el campo "foo" configurado en
la entrada "foo" más 1, y el campo "bar" configurado en la entrada " bar ”
más 1.

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

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.); use $ var | .foo | =. + 1 en su lugar.

Si el lado derecho no genera ningún valor (es decir, vacío), entonces
se eliminará la ruta del lado izquierdo, como con del (ruta).

Si el lado derecho genera múltiples valores, solo se usará el primero
(NOTA DE COMPATIBILIDAD: en jq 1.5 y versiones anteriores, solía
ser que solo se usaba el último).

jq ´ (.. | select (type == ”boolean”)) | = if. luego 1 else 0 end´
[verdadero, falso, [5, verdadero, [verdadero, [falso]], falso]]
=> [1,0, [5,1, [1, [0]], 0]]

Actualización-asignación aritmética: + =, - =, * =, / =,% =, // =
jq tiene algunos operadores de la forma a op = b, que son todos equivalentes a
a | =. op b. Entonces, + = 1 se puede usar para incrementar valores, siendo lo mismo
que | =. + 1.

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

Asignación simple: =
Este es el operador de asignación simple. A diferencia de los demás, la entrada
del lado derecho (RHS) es la misma que la entrada del
lado izquierdo (LHS) en lugar del valor en la ruta LHS, y todos los
valores emitidos por el RHS serán utilizado (como se muestra a continuación).

Si el RHS de ´ = ´ produce múltiples valores, entonces para cada uno de esos valores jq
establecerá las rutas del lado izquierdo al valor y luego generará
el modificado. Por ejemplo, (.a, .b) = range (2) produce
{"a": 0, "b": 0}, luego {"a": 1, "b": 1}. Los formularios de asignación de “actualización” (ver
arriba) no hacen esto.

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, "b": 20}. Este último establecerá
el campo "a" de la entrada en el campo "b" del campo "a", produciendo
{"a": 10, "b": 20}.

Otro ejemplo de la diferencia entre ´ = ´ y ´ | = ´:

nulo | (.a, .b) = rango (3)

salidas ´ {“a”: 0, ”b”: 0} ´, ´ {“a”: 1, ”b”: 1} ´, y ´ {“a”: 2, ”b”: 2} ´, mientras

nulo | (.a, .b) | = rango (3)

salidas solo ´ {“a”: 0, ”b”: 0} ´.

Tareas complejas
Se permiten muchas más cosas en el lado izquierdo de una tarea jq
que en la mayoría de los idiomas. Ya hemos visto accesos de campo simples en el
lado izquierdo, y no es de extrañar que los accesos a matrices funcionen igual de
bien:

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

Lo que puede sorprender 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
de "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 una parte del documento de entrada mientras ejecuta a. Esta
ruta se usa para encontrar qué parte de la entrada cambiar mientras se
ejecuta la asignación. Se puede usar cualquier filtro en el lado izquierdo de
un igual; cualquier ruta que seleccione de la entrada será donde
se realice la asignación.

Esta es una operación muy poderosa. Supongamos que quisiéramos agregar un comentario
a las publicaciones del blog, utilizando 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 uno de los posts 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). Las directivas de importación e inclusión 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 "$ ORIGIN".

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

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 a la
opción de línea de comandos -L , en caso contrario [“~ / .jq”, “$ ORIGIN /../ lib / jq”, “$ ORIGIN /../ lib”].

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

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

No se permiten componentes consecutivos con el mismo nombre para evitar
ambigüedades (por ejemplo, "foo / foo").

Por ejemplo, con -L $ HOME / .jq se puede encontrar un módulo foo en
$ HOME / .jq / foo.jq y $ HOME / .jq / foo / foo.jq.

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

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

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

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

incluir RelativePathString [];
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 estuviera incluido en su lugar. Se agregará un sufijo ".jq"
a la cadena de ruta relativa. Los símbolos del módulo se importan
al espacio de nombres de la persona que llama como si el contenido del módulo se hubiera
incluido directamente.

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

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

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

La clave de "búsqueda" en los metadatos, si está presente, debe tener una cadena o
un valor de matriz (matriz de cadenas); 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 un correcto funcionamiento
Solo tiene el propósito de proporcionar metadatos que se pueden
leer con el módulo incorporado.

Los metadatos deben ser una expresión jq constante. Debe ser un objeto
con claves como "página de inicio". En este momento jq no usa estos metadatos,
pero están disponibles para los usuarios a través del módulo incorporado.

modulemeta
Toma un nombre de módulo como entrada y genera los metadatos del módulo como un
objeto, con 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, por ejemplo, buscar, descargar e instalar las
dependencias faltantes .

COLORES
Para configurar colores alternativos, simplemente establezca la
variable de entorno JQ_COLORS en una lista delimitada por dos puntos de secuencias de escape de terminales parciales
como "1; 31", en este orden:

· Color para nulo

· Color para falso

· Color de verdad

· Color para números

· Color para cuerdas

· Color para matrices

· Color para objetos

El esquema de color predeterminado es el mismo que el de la configuración “JQ_COL‐
ORS = 1; 30: 0; 39: 0; 39: 0; 39: 0; 32: 1; 39: 1; 39”.

Este no es un manual para escapes VT100 / ANSI. Sin embargo, cada una de estas
especificaciones de color debe constar de dos números separados por un punto
y coma, donde el primer número es uno de estos:

· 1 (brillante)

· 2 (tenue)

· 4 (subrayado)

· 5 (parpadear)

· 7 (reverso)

· 8 (oculto)

y el segundo es uno de estos:

· 30 (negro)

· 31 (rojo)

· 32 (verde)

· 33 (amarillo)

· 34 (azul)

· 35 (magenta)

· 36 (cian)

· 37 (blanco)

ERRORES
Presumiblemente. Infórmelos o discútalos en:

https://github.com/stedolan/jq/issues

AUTOR
Stephen Dolan

Diciembre de 2017 JQ (1)

Publicar un comentario

0 Comentarios