jq - Online w chmurze

PROGRAM:

IMIĘ

jq - Procesor JSON wiersza poleceń

STRESZCZENIE

jq [Opcje...] filtrować [pliki...]

jq może przekształcać JSON na różne sposoby, wybierając, iterując, redukując i w inny sposób
manipulowanie dokumentami JSON. Na przykład uruchomienie polecenia jq ´mapa(.cena) | Dodaj będzie
weź tablicę obiektów JSON jako dane wejściowe i zwróć sumę ich pól „cena”.

jq może również akceptować wprowadzanie tekstu, ale domyślnie, jq odczytuje strumień jednostek JSON
(w tym cyfry i inne literały) od stdin. Biała spacja jest potrzebna tylko do oddzielenia
jednostki takie jak 1 i 2 oraz prawda i fałsz. Jeden lub więcej pliki można określić, w którym
walizka jq zamiast tego odczyta dane wejściowe z nich.

Połączenia Opcje są opisane w WYWOŁYWANIE JQ Sekcja; dotyczą głównie wejścia i wyjścia
formatowanie. filtrować jest napisany w języku jq i określa, jak przekształcić
plik wejściowy lub dokument.

FILTRY

Program jq jest „filtrem”: pobiera dane wejściowe i generuje dane wyjściowe. Jest dużo
wbudowane filtry do wyodrębniania określonego pola obiektu lub konwertowania liczby na
ciąg znaków lub różne inne standardowe zadania.

Filtry można łączyć na różne sposoby - możesz połączyć wyjście jednego filtra do
inny filtr lub zbierz dane wyjściowe filtru do tablicy.

Niektóre filtry dają wiele wyników, na przykład jeden daje wszystkie
elementy jego tablicy wejściowej. Rurociąg tego filtra do drugiego uruchamia drugi filtr przez
każdy element tablicy. Ogólnie rzecz biorąc, rzeczy, które można zrobić za pomocą pętli i iteracji
w innych językach po prostu skleja się filtry w jq.

Należy pamiętać, że każdy filtr ma wejście i wyjście. Nawet literały
np. "hello" lub 42 to filtry - pobierają dane wejściowe, ale zawsze tworzą ten sam dosłowny co
wyjście. Operacje, które łączą dwa filtry, takie jak dodawanie, zazwyczaj dostarczają te same dane wejściowe
do obu i połączyć wyniki. Możesz więc zaimplementować filtr uśredniający jako Dodaj / długość
- zasilanie tablicy wejściowej zarówno do Dodaj filtr i długość filtrować, a następnie wykonywać
Dywizja.

Ale to wyprzedza nas. :) Zacznijmy od czegoś prostszego:

WYWOŁYWANIE JQ

Filtry jq działają na strumieniu danych JSON. Dane wejściowe do jq są analizowane jako ciąg
wartości JSON oddzielone spacjami, które są przepuszczane przez dostarczony filtr jeden w a
czas. Wyjście(a) filtra są zapisywane do standardowego wyjścia, ponownie jako sekwencja
dane JSON rozdzielane spacjami.

Uwaga: ważne jest, aby pamiętać o zasadach cytowania powłoki. Z reguły najlepiej
zawsze cytuj (z pojedynczymi cudzysłowami) program jq, ponieważ za dużo znaków z
specjalne znaczenie dla jq mają również meta-znaki powłoki. Na przykład, jq "bla" nie powiedzie się
większość powłok Uniksa, ponieważ będzie to to samo, co jq bla, który generalnie się nie powiedzie
bo bla is nie zdefiniowane. Podczas korzystania z powłoki poleceń systemu Windows (cmd.exe) najlepiej:
używaj podwójnych cudzysłowów wokół swojego programu jq, gdy podajesz je w wierszu poleceń (zamiast -f
plik programu opcja), ale wtedy podwójne cudzysłowy w programie jq wymagają ucieczki odwrotnym ukośnikiem.

Możesz wpłynąć na to, jak jq odczytuje i zapisuje swoje dane wejściowe i wyjściowe za pomocą wiersza poleceń
opcje:

· --wersja:

Wypisz wersję jq i zakończ z zerem.

· --nast:

Użyj aplikacja/json-seq Schemat typu MIME do oddzielania tekstów JSON w danych wejściowych jq
i wyjście. Oznacza to, że znak ASCII RS (separator rekordów) jest wypisywany przed
każda wartość na wyjściu i ASCII LF (wysuw wiersza) są drukowane po każdym wyjściu. Wejście
Teksty JSON, których nie można przeanalizować, są ignorowane (ale ostrzegane), odrzucając wszystkie
kolejne wejście aż do następnego RS. To więcej analizuje również wyjście jq bez
--nast opcja.

· --strumień:

Przetwarzaj dane wejściowe w sposób strumieniowy, wyświetlając tablice wartości ścieżek i liści
(skalary i puste tablice lub puste obiekty). Na przykład, "za" staje się [[],"a"],
[[],"a",["b"]] staje się [[0], []], [[1],"a"], [[1,0],"b"].

Jest to przydatne do przetwarzania bardzo dużych danych wejściowych. Użyj tego w połączeniu z
filtrowanie i zmniejszyć i foreach składnia do stopniowego zmniejszania dużych danych wejściowych.

· -- siorbanie/-s:

Zamiast uruchamiać filtr dla każdego obiektu JSON w danych wejściowych, odczytaj całe dane wejściowe
przesyłać strumieniowo do dużej tablicy i uruchamiać filtr tylko raz.

· --surowe dane wejściowe/-R:

Nie analizuj danych wejściowych jako JSON. Zamiast tego każdy wiersz tekstu jest przekazywany do filtra jako a
strunowy. W połączeniu z -- siorbanie, wtedy całe dane wejściowe są przekazywane do filtra jako a
pojedynczy długi ciąg.

· --null-wejście/-n:

W ogóle nie czytaj żadnych danych wejściowych! Zamiast tego filtr jest uruchamiany po użyciu zero jako wejście.
Jest to przydatne, gdy używasz jq jako prostego kalkulatora lub do konstruowania danych JSON z
zadraśnięcie.

· --kompaktowe-wyjście / -c:

Domyślnie jq pretty-printuje dane wyjściowe JSON. Użycie tej opcji spowoduje więcej
kompaktowe dane wyjściowe, zamiast tego umieszczając każdy obiekt JSON w jednym wierszu.

· --patka:

Użyj tabulatora dla każdego poziomu wcięcia zamiast dwóch spacji.

· --akapit n:

Użyj podanej liczby spacji (nie więcej niż 8) do wcięcia.

· --kolor-wyjście / -C i --monochromatyczne-wyjście / -M:

Domyślnie jq wyświetla kolorowy kod JSON podczas pisania do terminala. Możesz go zmusić do
produkować kolor, nawet jeśli piszesz do potoku lub pliku za pomocą -Ci wyłącz kolor za pomocą -M.

· --ascii-wyjście / -a:

jq zwykle wypisuje punkty kodowe spoza ASCII Unicode jako UTF-8, nawet jeśli dane wejściowe są określone
je jako sekwencje specjalne (np. „\u03bc”). Używając tej opcji, możesz zmusić jq do
generować czysty wynik ASCII z każdym znakiem spoza ASCII zastępowanym przez odpowiednik
sekwencja ewakuacyjna.

· --niebuforowane

Opróżnij dane wyjściowe po wydrukowaniu każdego obiektu JSON (przydatne, jeśli przesyłasz powolne
źródło danych do jq i rurociągi wyjściowe jq w innym miejscu).

· --klawisze sortowania / -S:

Wypisz pola każdego obiektu z kluczami w kolejności posortowanej.

· --surowe wyjście / -r:

Dzięki tej opcji, jeśli wynikiem filtra jest łańcuch, zostanie on zapisany bezpośrednio
na standardowe wyjście, a nie jako ciąg JSON z cudzysłowami. To może
być przydatne, aby filtry jq komunikowały się z systemami innymi niż JSON.

· --join-wyjście / -j:

Jak -r ale jq nie wypisze znaku nowej linii po każdym wyjściu.

· -f filename / --z pliku filename:

Czytaj filtr z pliku, a nie z wiersza poleceń, jak opcja -f w awk. ty
może również używać '#' do komentowania.

· -Lkatalog / -L katalog:

Przedstaw katalog do listy wyszukiwania modułów. Jeśli ta opcja jest używana, to nie
używana jest wbudowana lista wyszukiwania. Zobacz sekcję dotyczącą modułów poniżej.

· -e / --stan-wyjścia:

Ustawia kod wyjścia jq na 0, jeśli ostatnie wartości wyjściowe nie były żadne fałszywy ani zero,
1, jeśli ostatnia wartość wyjściowa była albo fałszywy or zero, lub 4, jeśli nigdy nie uzyskano prawidłowego wyniku
wytworzony. Normalnie jq kończy działanie z 2, jeśli wystąpił jakiś problem z użytkowaniem lub błąd systemu, 3
jeśli wystąpił błąd kompilacji programu jq, lub 0, jeśli program jq działał.

· --arg Nazwa wartość:

Ta opcja przekazuje wartość do programu jq jako predefiniowaną zmienną. Jeśli uruchomisz jq
w --arg bla bar, następnie $ foo jest dostępny w programie i ma wartość "bar".
Należy pamiętać, że wartość będzie traktowany jako ciąg, więc --arg bla 123 zwiąże $ foo do "123".

· --argjson Nazwa Tekst-JSON:

Ta opcja przekazuje wartość zakodowaną w formacie JSON do programu jq jako predefiniowaną zmienną. Jeśli
biegasz jq z --argjson bla 123, następnie $ foo jest dostępny w programie i ma
wartość 123.

· --slurpplik nazwa-zmiennej filename:

Ta opcja odczytuje wszystkie teksty JSON w nazwanym pliku i wiąże tablicę
przeanalizował wartości JSON do danej zmiennej globalnej. Jeśli uruchomisz jq z --plik arg bla bar,
następnie $ foo jest dostępny w programie i ma tablicę, której elementy odpowiadają
teksty w pliku o nazwie bar.

· --plik arg nazwa-zmiennej filename:

Nie używaj. Posługiwać się --slurpplik zamiast.

(Ta opcja jest jak --slurpplik, ale jeśli plik zawiera tylko jeden tekst, to jest
używany, inaczej tablica tekstów jest używana jako in --slurpplik.)

· --uruchom-testy [Nazwa pliku]:

Uruchamia testy w podanym pliku lub standardowym wejściu. To musi być ostatnia podana opcja
i nie uwzględnia wszystkich poprzednich opcji. Wejście składa się z wierszy komentarza, pustych
wierszy i wierszy programu, po których następuje jeden wiersz wejściowy, tyle wierszy wyjściowych, ile jest
oczekiwane (jeden na wyjście) i kończący pustą linię. Testy awarii kompilacji
zacznij od linii zawierającej tylko "%%FAIL", a następnie linię zawierającą program do
skompilować, a następnie wiersz zawierający komunikat o błędzie do porównania z rzeczywistym.

Ostrzegamy, że ta opcja może się zmienić w sposób niekompatybilny wstecz.

BASIC FILTRY

.
Absolutnie najprostszym (i najmniej interesującym) filtrem jest .. To jest filtr, który bierze
dane wejściowe i produkuje je bez zmian jako dane wyjściowe.

Ponieważ jq domyślnie pretty-wypisuje wszystkie dane wyjściowe, ten trywialny program może być użytecznym sposobem
formatowanie danych wyjściowych JSON z, powiedzmy, curl.

jq `.`
"Witaj świecie!"
=> "Witaj świecie!"

.bla, .foo.bar
Najprostszy użyteczny filtr jest .bla. Po otrzymaniu obiektu JSON (aka słownika lub skrótu) jako
input, generuje wartość przy klawiszu „foo” lub null, jeśli nie ma żadnego.

Jeśli klucz zawiera znaki specjalne, należy go otoczyć podwójnymi cudzysłowami, takimi jak
to: "foo$".

Filtr formularza .foo.bar odpowiada .foo|.bar.

jq „.foo”.
{"foo": 42, "bar": "mniej interesujące dane"}
=> 42

jq „.foo”.
{"notfoo": prawda, "alsonotfoo": fałsz}
=> null

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

.bla?
Tak jak .bla, ale nie wyświetla nawet błędu, gdy . nie jest tablicą ani obiektem.

jq „.foo?”
{"foo": 42, "bar": "mniej interesujące dane"}
=> 42

jq „.foo?”
{"notfoo": prawda, "alsonotfoo": fałsz}
=> null

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

jq „[.foo?]”.
[1,2]
=> []

.[ ], [2], [10:15]
Możesz także wyszukiwać pola obiektu za pomocą składni takiej jak .["bla"] (.foo powyżej to
skrócona wersja tego). Ten działa również dla tablic, jeśli klucz jest liczbą całkowitą.
Tablice są liczone od zera (jak javascript), więc . [2] zwraca trzeci element tablicy.

Połączenia [10:15] składnia może być użyta do zwrócenia podtablicy tablicy lub podłańcucha łańcucha.
Tablica zwrócona przez [10:15] będzie miał długość 5, zawierającą elementy z indeksu 10
(włącznie) do indeksu 15 (wyłącznie). Każdy indeks może być ujemny (w takim przypadku się liczy
wstecz od końca tablicy) lub pominięte (w takim przypadku odnosi się do początku lub
koniec tablicy).

Połączenia . [2] składnia może być użyta do zwrócenia elementu o podanym indeksie. Ujemne indeksy to
dozwolone, gdzie -1 odnosi się do ostatniego elementu, -2 odnosi się do przedostatniego elementu,
i tak dalej.

Połączenia .bla składnia działa tylko dla prostych kluczy, tj. kluczy, które są wyłącznie znakami alfanumerycznymi.
.[ ] działa z klawiszami zawierającymi znaki specjalne, takie jak dwukropki i kropki. Do
przykład .["foo::bar"] i .["foo.bar"] pracować podczas .foo::bar i .foo.bar nie.

Połączenia ? "operator" może być również używany z operatorem plastra, jak w [10:15]?, który wychodzi
wartości, w których dane wejściowe można wycinać.

jq `.[0]`
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> {"name":"JSON", "good":true}

jq `.[2]`
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> null

jq ’.[2:4]’
["a","b","c","d","e"]
=> ["c", "d"]

jq ’.[2:4]’
„abcdefghi”
=> "płyta"

jq `.[:3]'
["a","b","c","d","e"]
=> ["a", "b", "c"]

jq `.[-2:]'
["a","b","c","d","e"]
=> ["d", "e"]

jq `.[-2]'
[1,2,3]
=> 2

.[]
Jeśli używasz .[indeks] składnia, ale pomiń indeks całkowicie, to zwróci cała kolekcja ukończenia
elementy tablicy. Bieganie .[] z wejściem [1,2,3] da liczby jako trzy
oddzielne wyniki, a nie jako pojedynczą tablicę.

Możesz również użyć tego na obiekcie, a zwróci wszystkie wartości obiektu.

jq `.[]`
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> {"name":"JSON", "good":true}, {"name":"XML", "good":false}

jq `.[]`
[]
=>

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

.[]?
Jak .[], ale jeśli . nie jest tablicą ani obiektem.

,
Jeśli dwa filtry są oddzielone przecinkiem, to dane wejściowe zostaną podane do obu i tam
będzie wiele wyjść: po pierwsze, wszystkie wyjścia wytworzone przez lewe wyrażenie i
następnie wszystkie wyjścia produkowane przez prawo. Na przykład filtr .bla, .Kawiarnia, produkuje
oba pola "foo" i "bar" jako oddzielne wyjścia.

jq `.foo, .bar'
{"foo": 42, "bar": "coś innego", "baz": prawda}
=> 42, "coś innego"

jq ´.użytkownik, .projekty[]´
{"user":"stedolan", "projekty": ["jq", "wikiflow"]}
=> "stedolan", "jq", "wikiflow"

jq `.[4,2]`
["a","b","c","d","e"]
=> "e", "c"

|
| operator łączy dwa filtry, wprowadzając dane wyjściowe tego po lewej do
wejście tego po prawej. To prawie to samo, co rura powłoki uniksowej, jeśli
jesteś do tego przyzwyczajony.

Jeśli ten po lewej daje wiele wyników, ten po prawej zostanie uruchomiony dla
każdy z tych wyników. Tak więc wyrażenie .[] | .bla pobiera pole "foo" każdego z nich
element tablicy wejściowej.

jq ´.[] | .Nazwa
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> "JSON", "XML"

TYPY ROLNICZE WARTOŚCI

jq obsługuje ten sam zestaw typów danych co JSON - liczby, łańcuchy, wartości logiczne, tablice,
obiekty (które w języku JSON są skrótami zawierającymi tylko klucze łańcuchowe) i „null”.

Boole's, null, stringi i liczby są zapisywane w taki sam sposób jak w javascript. Tak jak
wszystko inne w jq, te proste wartości pobierają dane wejściowe i dają wynik - 42 jest
poprawne wyrażenie jq, które pobiera dane wejściowe, ignoruje je i zamiast tego zwraca 42.

Szyk Budowa - []
Jak w JSON, [] służy do konstruowania tablic, jak in [1,2,3]. Elementy tablic mogą:
być dowolnym wyrażeniem jq. Zbierane są wszystkie wyniki uzyskane przez wszystkie wyrażenia
w jedną dużą tablicę. Możesz go użyć do skonstruowania tablicy ze znanej ilości wartości
(jak w [.bla, .bar, .baz]) lub "zebrać" wszystkie wyniki filtra w tablicę (jak
in [.elementy[].nazwa])

Gdy zrozumiesz operator ",", możesz spojrzeć na składnię tablicy jq w inny sposób
światło: wyrażenie [1,2,3] nie używa wbudowanej składni dla tablic rozdzielanych przecinkami,
ale zamiast tego stosuje [] operator (zbierz wyniki) do wyrażenia 1,2,3 (co
daje trzy różne wyniki).

Jeśli masz filtr X co daje cztery wyniki, to wyrażenie [X] wyprodukuje
pojedynczy wynik, tablica czterech elementów.

jq ´[.użytkownik, .projekty[]]´
{"user":"stedolan", "projekty": ["jq", "wikiflow"]}
=> ["stedolan", "jq", "wikiflow"]

Obiekty - {}
Jak JSON, {} służy do konstruowania obiektów (inaczej słowników lub skrótów), jak w: {"a": 42,
"b": 17}.

Jeśli klawisze są „rozsądne” (wszystkie znaki alfabetyczne), cudzysłowy można pominąć.
Wartośćmoże byćdowolnym wyrażeniem (chociaż może być konieczne umieszczenie go w nawiasach, jeśli tak jest
skomplikowany), który zostaje zastosowany do wejścia wyrażenia {} (pamiętaj, że wszystkie filtry
mają wejście i wyjście).

{foo: .bar}

wytworzy obiekt JSON {"bla": 42} jeśli podano obiekt JSON {"pasek":42, "baz":43}.
Możesz użyć tego do wybrania określonych pól obiektu: jeśli dane wejściowe to obiekt z
pola „użytkownik”, „tytuł”, „id” i „treść”, a chcesz tylko „użytkownik” i „tytuł”, możesz
napisać

{użytkownik: .użytkownik, tytuł: .tytuł}

Ponieważ jest to tak powszechne, istnieje składnia skrótów: {użytkownik, tytuł}.

Jeśli jedno z wyrażeń daje wiele wyników, wiele słowników będzie
wytworzony. Jeśli dane wejściowe

{"user":"stedolan","titles":["JQ Primer", "More JQ"]}

to wyrażenie

{użytkownik, tytuł: .titles[]}

wygeneruje dwa produkty:

{"user":"stedolan", "title": "JQ Primer"}
{"user":"stedolan", "title": "Więcej JQ"}

Umieszczenie klucza w nawiasach oznacza, że ​​będzie on oceniany jako wyrażenie. Z
to samo wejście co powyżej,

{(.użytkownik): .tytuły}

produkuje

{"stedolan": ["JQ Primer", "Więcej JQ"]}

jq ´{użytkownik, tytuł: .titles[]}´
{"user":"stedolan","titles":["JQ Primer", "More JQ"]}
=> {"user":"stedolan", "title": "JQ Primer"}, {"user":"stedolan", "title": "More JQ"}

jq ´{(.użytkownik): .tytuły}´
{"user":"stedolan","titles":["JQ Primer", "More JQ"]}
=> {"stedolan": ["JQ Primer", "Więcej JQ"]}

WBUDOWANE OPERATORZY ROLNICZE FUNKCJE

Jakiś operator jq (na przykład +) robić różne rzeczy w zależności od ich rodzaju
argumenty (tablice, liczby itp.). Jednak jq nigdy nie wykonuje niejawnych konwersji typów. Jeśli
spróbujesz dodać ciąg do obiektu, otrzymasz komunikat o błędzie i brak wyniku.

Dodatek - +
Operator + pobiera dwa filtry, stosuje je oba do tego samego wejścia i dodaje
wyniki razem. Co oznacza „dodawanie” zależy od zaangażowanych typów:

· Liczby są dodawane przez zwykłą arytmetykę.

· Tablice są dodawane przez połączenie w większą tablicę.

· Smyczki są dodawane przez połączenie w większy ciąg.

· Obiekty są dodawane przez scalenie, czyli wstawienie wszystkich par klucz-wartość z obu
obiekty w jeden połączony obiekt. Jeśli oba obiekty zawierają wartość tego samego
klucz, obiekt po prawej stronie + wygrywa. (Dla scalania rekurencyjnego użyj * operator.)

zero można dodać do dowolnej wartości i zwraca drugą wartość bez zmian.

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

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

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

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

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

Odejmowanie - -
Oprócz normalnego odejmowania arytmetycznego na liczbach, - operator może być używany na tablicach
aby usunąć wszystkie wystąpienia elementów drugiej tablicy z pierwszej tablicy.

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

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

Mnożenie, podział, Modulo - *, /, i %
Te operatory wrostkowe zachowują się zgodnie z oczekiwaniami, gdy podano dwie liczby. Dzielenie przez zero podwyżek
błąd. x % y oblicza x modulo y.

Pomnożenie ciągu przez liczbę daje konkatenację tego ciągu tyle
razy. „x” * 0 produkuje zero.

Dzielenie ciągu przez inny dzieli pierwszy, używając drugiego jako separatora.

Mnożenie dwóch obiektów połączy je rekursywnie: działa to jak dodawanie, ale jeśli oba
obiekty zawierają wartość dla tego samego klucza, a wartości są obiektami, oba są połączone
z tą samą strategią.

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}}´
zero
=> {"k": {"a": 0, "b": 2, "c": 3}}

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

długość
Wbudowana funkcja długość pobiera długość różnych typów wartości:

· Długość a ciąg to liczba zawartych w nim punktów kodowych Unicode (która będzie
taka sama jak długość zakodowana w JSON w bajtach, jeśli jest to czysty ASCII).

· Długość an szyk to liczba elementów.

· Długość an przedmiot to liczba par klucz-wartość.

· Długość zero wynosi zero.

jq ´.[] | długość´ [[1,2], "string", {"a":2}, null] => 2, 6, 1, 0

Klucze, klucze_nieposortowane
Wbudowana funkcja Klawisze, gdy dany obiekt, zwraca jego klucze w tablicy.

Klucze są sortowane „alfabetycznie”, według kolejności punktów kodowych Unicode. To nie jest zamówienie
ma to szczególny sens w każdym konkretnym języku, ale możesz liczyć na to, że będzie to
to samo dla dowolnych dwóch obiektów z tym samym zestawem kluczy, niezależnie od ustawień regionalnych.

Kiedy Klawisze otrzymuje tablicę, zwraca prawidłowe indeksy dla tej tablicy: liczby całkowite
od 0 do długości-1.

Połączenia klucze_nieposortowane funkcja jest jak Klawisze, ale jeśli wejście jest obiektem to klawisze
nie zostaną posortowane, zamiast tego klucze będą mniej więcej w kolejności wstawiania.

jq „klucze”
{"abc": 1, "abcd": 2, "Foo": 3}
=> ["Foo", "abc", "abcd"]

jq „klucze”
[42,3,35]
=> [0,1,2]

ma (klucz)
Wbudowana funkcja ma zwraca, czy obiekt wejściowy ma podany klucz, czy dane wejściowe
tablica ma element o podanym indeksie.

ma($klucz) ma taki sam efekt jak sprawdzenie, czy $ klucz jest członkiem zwróconej tablicy
by Klawisze, Chociaż ma będzie szybciej.

jq ´map(ma("foo"))´
[{"foo": 42}, {}]
=> [prawda, fałsz]

jq 'mapa(ma(2))'
[[0,1], ["a","b","c"]]
=> [fałsz, prawda]

in
Wbudowana funkcja in zwraca klucz wejściowy znajdujący się w podanym obiekcie lub indeks wejściowy
odpowiada elementowi w podanej tablicy. Jest to zasadniczo odwrócona wersja
ma.

jq ´.[] | in({"foo": 42})´
["foo", "bar"]
=> prawda, fałsz

jq ´mapa(w([0,1]))´
[2, 0]
=> [fałsz, prawda]

ścieżka(ścieżka_wyrażenie)
Wyprowadza reprezentacje tablicowe danego wyrażenia ścieżki w .. Wyjścia są tablicami
ciągi (klucze w obiektach 0 i/lub liczby (indeksy tablicy).

Wyrażenia ścieżki to wyrażenia jq, takie jak .a, Ale .[]. Istnieją dwa rodzaje ścieżek
wyrażenia: te, które mogą dokładnie pasować i te, które nie mogą. Na przykład, .ABC jest
wyrażenie ścisłego dopasowania ścieżki, podczas gdy .a[].b nie jest.

ścieżka (exact_path_expression) wygeneruje tablicową reprezentację wyrażenia ścieżki
nawet jeśli nie istnieje w .Jeśli . is zero lub tablica lub obiekt.

ścieżka(wzór) wygeneruje tablicowe reprezentacje pasujących ścieżek wzorzec Jeśli
ścieżki istnieją w ..

Zauważ, że wyrażenia ścieżki nie różnią się od wyrażeń normalnych. Ekspresja
ścieżka(..|select(type=="boolean")) wypisuje wszystkie ścieżki do wartości logicznych w ., i tylko
te ścieżki.

jq ´ścieżka(.a[0].b)´
zero
=> ["a",0,"b"]

jq ´[ścieżka(..)]´
{"a":[{"b"::1}]}
=> [[],["a"],["a",0],["a",0,"b"]]

del(ścieżka_wyrażenie)
Wbudowana funkcja del usuwa klucz i odpowiadającą mu wartość z obiektu.

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

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

do_wpisów, z_wpisów, z_wpisami
Te funkcje konwertują między obiektem a tablicą par klucz-wartość. Jeśli do_wpisów
przechodzi obiekt, a następnie dla każdego k: v wpis na wejściu, tablica wyjściowa zawiera
{"klucz": k, "wartość": v}.

z_wpisów dokonuje przeciwnej konwersji i with_entries(foo) to skrót od
do_wpisów | mapa(foo) | z_wpisów, przydatne do wykonywania operacji na wszystkich klawiszach i
wartości obiektu. z_wpisów akceptuje klucz, klucz, nazwę, wartość i wartość jako klucze.

jq „do_wpisów”
{"a": 1, "b": 2}
=> [{"key":"a", "value":1}, {"key":"b", "value":2}]

jq 'z_wpisów'
[{"key":"a", "value":1}, {"key":"b", "value":2}]
=> {"a": 1, "b": 2}

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

wybierz(wyrażenie_logiczne)
Funkcja wybierz(foo) produkuje swoje dane wejściowe niezmienione, jeśli bla zwraca prawdę dla tego wejścia,
i nie generuje żadnych danych wyjściowych w przeciwnym razie.

Przydaje się do filtrowania list: [1,2,3] | mapa(wybierz(. >= 2)) da tobie [2,3].

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

jq ´.[] | select(.id == "druga")´
[{"id": "first", "val": 1}, {"id": "second", "val": 2}]
=> {"id": "drugi", "val": 2}

tablice, przedmioty, iterowalne, wartości logiczne, liczby, normalne, skończoność, smyczki, wartości null, wartości,
skalary
Te wbudowane wybierają tylko dane wejściowe, które są tablicami, obiektami, elementami iteracyjnymi (tablice lub
obiekty), wartości logiczne, liczby, liczby normalne, liczby skończone, łańcuchy, null, non-null
odpowiednio wartości i elementy nieiterowalne.

jq ´.[]|liczby´
[[],{},1,"foo",null,prawda,fałsz]
=> 1

pusty
pusty nie zwraca żadnych wyników. Wcale. Nawet nie zero.

Przydaje się czasami. Będziesz wiedział, czy tego potrzebujesz :)

jq ´1, puste, 2´
zero
=> 1, 2

jq ´[1,2,pusty,3]´
zero
=> [1,2,3]

błąd(wiadomość)
Powoduje błąd, tak jak .a stosowane do wartości innych niż null i obiektów, ale
z podanym komunikatem jako wartością błędu.

$__lok__
Tworzy obiekt z kluczem „plik” i kluczem „linii”, z nazwą pliku i numerem wiersza
gdzie $__lok__ występuje jako wartości.

jq ´try error("\($__loc__)") catch .´
zero
=> "{\"plik\":\" \",\"linia 1}"

mapa(x), wartości_mapy(x)
Dla każdego filtra x, mapa(x) uruchomi ten filtr dla każdego elementu tablicy wejściowej i
wytworzyć na wyjściach nową tablicę. mapa (.+1) zwiększy każdy element tablicy o
numery.

Podobnie, wartości_mapy(x) uruchomi ten filtr dla każdego elementu, ale zwróci an
obiekt, gdy obiekt jest przekazywany.

mapa(x) odpowiada [.[] | x]. W rzeczywistości tak to się definiuje. Podobnie,
wartości_mapy(x) jest jak zdefiniowano .[] |= x.

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

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

ścieżki, ścieżki(node_filter), ścieżki_liści
ścieżki wypisuje ścieżki do wszystkich elementów w swoim wejściu (z wyjątkiem tego, że nie wypisuje
pusta lista, reprezentująca . samo).

ścieżki(f) wyprowadza ścieżki do dowolnych wartości, dla których f jest prawdziwy. To jest, ścieżki (liczby)
wypisuje ścieżki do wszystkich wartości liczbowych.

ścieżki_liści jest aliasem ścieżki (skalary); ścieżki_liści is przestarzałe i zostanie usunięty za
następne główne wydanie.

jq ´[ścieżki]´
[1,[[],{"a":2}]]
=> [[0],[1],[1,0],[1,1],[1,1,"a"]]

jq ´[ścieżki(skalary)]´
[1,[[],{"a":2}]]
=> [[0],[1,1,"a"]]

Dodaj
Filtr Dodaj przyjmuje jako dane wejściowe tablicę i tworzy jako dane wyjściowe elementy tablicy
dodane razem. Może to oznaczać zsumowane, połączone lub połączone w zależności od typów
elementy tablicy input - zasady są takie same jak dla + operator
(opisane powyżej).

Jeśli dane wejściowe są pustą tablicą, Dodaj powraca zero.

jq „dodaj”
["ABC"]
=> "abc"

jq „dodaj”
[1, 2, 3]
=> 6

jq „dodaj”
[]
=> null

każdy, dowolna (warunek), dowolny(generator; stan: schorzenie)
Filtr każdy przyjmuje jako dane wejściowe tablicę wartości logicznych i tworzy prawdziwy jako wyjście, jeśli
dowolny z elementów tablicy to prawdziwy.

Jeśli dane wejściowe są pustą tablicą, każdy powraca fałszywy.

Połączenia dowolny (warunek) formularz stosuje dany warunek do elementów tablicy wejściowej.

Połączenia dowolny(generator; stan: schorzenie) formularz stosuje dany warunek do wszystkich wyjść funkcji
podany generator.

jq „dowolny”
[prawda fałsz]
=> prawda

jq „dowolny”
[fałsz, fałsz]
=> fałsz

jq „dowolny”
[]
=> fałsz

erta i efekt końcowy przerosły oczekiwania klienta. wszystkie (stan), wszystkie(generator; stan: schorzenie)
Filtr cała kolekcja przyjmuje jako dane wejściowe tablicę wartości logicznych i tworzy prawdziwy jako wyjście, jeśli
wszystkie elementy tablicy są prawdziwy.

Połączenia wszystkie (stan) formularz stosuje dany warunek do elementów tablicy wejściowej.

Połączenia wszystkie(generator; stan: schorzenie) formularz stosuje dany warunek do wszystkich wyjść funkcji
podany generator.

Jeśli dane wejściowe są pustą tablicą, cała kolekcja powraca prawdziwy.

jq „wszystko”
[prawda fałsz]
=> fałsz

jq „wszystko”
[Prawda, prawda]
=> prawda

jq „wszystko”
[]
=> prawda

[Wymaga 1.5] spłaszczyć, spłaszczyć (głębokość)
Filtr spłaszczyć pobiera jako dane wejściowe tablicę zagnieżdżonych tablic i tworzy tablicę płaską w
w którym wszystkie tablice wewnątrz oryginalnej tablicy zostały rekurencyjnie zastąpione ich wartościami.
Możesz przekazać do niego argument, aby określić, ile poziomów zagnieżdżenia ma zostać spłaszczone.

spłaszczyć(2) jest jak spłaszczyć, ale sięga tylko do dwóch poziomów.

jq „spłaszczyć”
[1, [2], [3]]]
=> [1, 2, 3]

jq´spłaszczyć(1)”.
[1, [2], [3]]]
=> [1, 2, [3]]

jq „spłaszczyć”
[[]]
=> []

jq „spłaszczyć”
[{"foo": "bar"}, [{"foo": "baz"}]]
=> [{"foo": "bar"}, {"foo": "baz"}]

zasięg (do), zakres(od;do) zakres(od;do;do)
Połączenia zasięg funkcja tworzy zakres liczb. zasięg(4;10) daje 6 liczb, od 4
(włącznie) do 10 (wyłącznie). Liczby są generowane jako oddzielne wyjścia. Posługiwać się
[zakres(4;10)] aby uzyskać zakres jako tablicę.

Forma jednoargumentowa generuje liczby od 0 do podanej liczby, z przyrostem
1.

Dwuargumentowa forma generuje liczby z od do września z przyrostem o 1.

Trójargumentowa forma generuje liczby od do września z przyrostem by.

jq ´zakres(2;4)´
zero
=> 2, 3

jq ´[zakres(2;4)]´
zero
=> [2,3]

jq '[zasięg(4)]'
zero
=> [0,1,2,3]

jq ´[zakres(0;10;3)]´
zero
=> [0,3,6,9]

jq ´[zakres(0;10;-1)]´
zero
=> []

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

piętro
Połączenia piętro funkcja zwraca piętro swojego wejścia numerycznego.

jq „podłoga”
3.14159
=> 3

kwadrat
Połączenia kwadrat funkcja zwraca pierwiastek kwadratowy ze swojego wejścia numerycznego.

jq „kwadrat”.
9
=> 3

na numer
Połączenia na numer funkcja analizuje swoje dane wejściowe jako liczbę. Konwertuje poprawnie sformatowany
ciągi do ich liczbowego odpowiednika, zostaw liczby w spokoju i podaj błąd we wszystkich innych
wkład.

jq ´.[] | na numer
[1, „1”]
=> 1, 1

tostrowanie
Połączenia tostrowanie function wypisuje swoje dane wejściowe jako ciąg. Ciągi pozostają niezmienione, a wszystkie
inne wartości są zakodowane w formacie JSON.

jq ´.[] | tostring'
[1, "1", [1]]
=> „1”, „1”, „[1]”

rodzaj
Połączenia rodzaj funkcja zwraca typ swojego argumentu jako string, który jest jednym z null,
wartość logiczna, liczba, ciąg, tablica lub obiekt.

jq ´mapa(typ)´
[0, fałsz, [], {}, null, "cześć"]
=> ["liczba", "boolean", "tablica", "obiekt", "null", "ciąg"]

nieskończony, Nie, nieskończony, Isnan, jest nieskończony, jest normalne
Niektóre operacje arytmetyczne mogą dawać nieskończoności i wartości „nie liczba” (NaN). ten
nieskończony wbudowane zwraca prawdziwy jeśli jego wejście jest nieskończone. ten Inan wbudowane zwraca prawdziwy
jeśli jego dane wejściowe to NaN. ten nieskończony builtin zwraca dodatnią wartość nieskończoną. ten nan
wbudowane zwraca NaN. ten jest normalne builtin zwraca prawdę, jeśli jego dane wejściowe są normalną liczbą.

Zauważ, że dzielenie przez zero rodzi błąd.

Obecnie większość operacji arytmetycznych operujących na nieskończoności, NaN i subnormalnych nie do
zgłaszać błędy.

jq ´.[] | (nieskończone * .) < 0´
[-jedenaście]
=> prawda, fałsz

jq ´nieskończony, nan | rodzaj
zero
=> "liczba", "liczba"

sortować, sort_by(ścieżka_wyrażenie)
Połączenia rodzaj function sortuje swoje dane wejściowe, które muszą być tablicą. Wartości są posortowane w
następująca kolejność:

· zero

· fałszywy

· prawdziwy

· liczby

· ciągi znaków w kolejności alfabetycznej (według wartości punktu kodowego Unicode)

· tablice, w porządku leksykalnym

· przedmioty

Kolejność obiektów jest trochę skomplikowana: najpierw porównuje się je, porównując ich
zestawy kluczy (jako tablice w kolejności posortowanej), a jeśli ich klucze są równe, to wartości są
porównał klucz po kluczu.

rodzaj może służyć do sortowania według określonego pola obiektu lub poprzez zastosowanie dowolnego filtra jq.

sortuj według (foo) porównuje dwa elementy, porównując wynik bla na każdym elemencie.

jq „sortuj”
[8,3, null, 6]
=> [null,3,6,8]

jq ´sortuj według(.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 (ścieżka_wyrażenie)
grupa_by(.foo) przyjmuje jako dane wejściowe tablicę, grupuje elementy mające to samo .bla pole
w oddzielne tablice i tworzy wszystkie te tablice jako elementy większej tablicy,
posortowane według wartości .bla pole.

Każde wyrażenie jq, nie tylko dostęp do pola, może być użyte zamiast .bla. Sortowanie
kolejność jest taka sama, jak opisano w rodzaj funkcja powyżej.

jq ´grupa_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(ścieżka_exp), max_by(ścieżka_exp)
Znajdź minimalny lub maksymalny element tablicy wejściowej.

Połączenia min_by(ścieżka_exp) i max_by(ścieżka_exp) funkcje pozwalają określić konkretną
pole lub nieruchomość do zbadania, np. min_by(.foo) znajduje obiekt z najmniejszym bla
pole.

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

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

wyjątkowy, unikatowe_przez(ścieżka_wyraż.)
Połączenia wyjątkowy funkcja przyjmuje jako dane wejściowe tablicę i tworzy tablicę tych samych elementów, in
posortowana kolejność, z usuniętymi duplikatami.

Połączenia unikatowe_przez(ścieżka_wyraż.) funkcja zachowa tylko jeden element dla każdej wartości uzyskanej przez
zastosowanie argumentu. Pomyśl o tym jako o tworzeniu tablicy przez pobranie jednego elementu z każdego
grupa wyprodukowana przez grupa.

jq „wyjątkowy”
[1,2,5,3,5,3,1,3]
=> [1,2,3,5]

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

jq 'unikalny_by (długość)'
["masywny", "bekon", "kotek", "cykada", "szparagi"]
=> ["bekon", "gruby", "szparagi"]

rewers
Ta funkcja odwraca tablicę.

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

zawiera(element)
Filtr zawiera(b) da prawdę, jeśli b jest całkowicie zawarte w danych wejściowych. A
łańcuch B jest zawarty w łańcuchu A, jeśli B jest podłańcuchem A. Tablica B jest zawarta w
tablica A, jeśli wszystkie elementy w B są zawarte w dowolnym elemencie w A. Obiekt B to
zawarte w obiekcie A, jeśli wszystkie wartości w B są zawarte w wartości w A z
ten sam klucz. Zakłada się, że wszystkie inne typy są zawarte w sobie, jeśli są równe.

jq ´zawiera("pasek")´
"głupek"
=> prawda

jq ´zawiera(["baz", "bar"])´
["foobar", "foobaz", "blarp"]
=> prawda

jq ´zawiera(["bazzzzz", "bar"])´
["foobar", "foobaz", "blarp"]
=> fałsz

jq ´zawiera({foo: 12, słupek: [{barp: 12}]})´
{"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]}
=> prawda

jq ´zawiera({foo: 12, słupek: [{barp: 15}]})´
{"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]}
=> fałsz

indeks(y)
Wyprowadza tablicę zawierającą indeksy w . gdzie s występuje. Wejście może być tablicą, in
w którym przypadku, jeśli? s jest tablicą, to na wyjściu indeksów pojawią się te, w których wszystkie elementy w .
dopasuj te z s.

jq ´indeksy(”, „)´
„a, b, cd, efg, cześć”
=> [3,7,12]

jq´Wskaźniki(1)”.
[0,1,2,1,3,1,4]
=> [1,3,5]

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

indeks(y), indeks(y)
Wyprowadza indeks pierwszego (wskaźnik) lub ostatni (skakać) występowanie s na wejściu.

jq ´indeks(", ")´
„a, b, cd, efg, cześć”
=> 3

jq ´rindex(", ")´
„a, b, cd, efg, cześć”
=> 12

wewnątrz
Filtr wewnątrz(b) da prawdę, jeśli dane wejściowe są całkowicie zawarte w b. To
jest zasadniczo odwróconą wersją zawiera.

jq ´wewnątrz("foobar")´
"bar"
=> prawda

jq ´wewnątrz(["foobar", "foobaz", "blarp"])´
["baz", "bar"]
=> prawda

jq ´wewnątrz(["foobar", "foobaz", "blarp"])´
["bazzzzz", "bar"]
=> fałsz

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

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

zaczyna się od(str)
Wyjścia prawdziwy Jeśli . zaczyna się od podanego argumentu ciągu.

jq ´[.[]|zaczyna się("foo")]´
["fo", "foo", "barfoo", "foobar", "barfoob"]
=> [fałsz, prawda, fałsz, prawda, fałsz]

kończy się(str)
Wyjścia prawdziwy Jeśli . kończy się podanym argumentem ciągu.

jq ´[.[]|kończy się("foo")]´
["foobar", "barfoo"]
=> [fałsz, prawda]

kombinacje, kombinacje(n)
Wyprowadza wszystkie kombinacje elementów tablic w tablicy wejściowej. Jeśli podano an
argument n, wypisuje wszystkie kombinacje n powtórzenia tablicy wejściowej.

jq „kombinacje”
[[1,2], [3, 4]]
=> [1, 3], [1, 4], [2, 3], [2, 4]

jq´kombinacje(2)”.
[0, 1]
=> [0, 0], [0, 1], [1, 0], [1, 1]

ltrimstr(str)
Wyprowadza swoje dane wejściowe z usuniętym łańcuchem prefiksu, jeśli zaczyna się od niego.

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

rtrimstr(str)
Wyprowadza swoje dane wejściowe z usuniętym łańcuchem sufiksu, jeśli się nim kończy.

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

eksplodować
Konwertuje ciąg wejściowy na tablicę numerów punktów kodowych ciągu.

jq „eksplodować”
"głupek"
=> [102,111,111,98,97,114]

implodować
Odwrotność wybuchu.

jq „implodować”
[65, 66, 67]
=> "ABC"

dzielić
Dzieli ciąg wejściowy na argumencie separatora.

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

dołącz(str)
Łączy tablicę elementów podanych jako dane wejściowe, używając argumentu jako separatora. To jest
odwrotność dzielić: czyli bieganie split("foo") | dołącz("foo") nad dowolnym ciągiem wejściowym
zwraca wymieniony ciąg wejściowy.

jq ´dołącz(", ")´
["a","b,c,d","e"]
=> "a, b, c, d, e"

ascii_downcase, ascii_upcase
Emituj kopię ciągu wejściowego z jego znakami alfabetycznymi (az i AZ) przekonwertowanymi na
określony przypadek.

podczas(war; aktualizacja)
Połączenia podczas(war; aktualizacja) funkcja umożliwia wielokrotne stosowanie aktualizacji do . aż do dyr
to fałsz.

Należy pamiętać, że podczas(war; aktualizacja) jest wewnętrznie zdefiniowana jako rekurencyjna funkcja jq. Rekursywny
dzwoni w ciągu Podczas nie zużyje dodatkowej pamięci, jeśli aktualizacja produkuje co najwyżej jeden
wyjście dla każdego wejścia. Zobacz zaawansowane tematy poniżej.

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

do (war; Następny)
Połączenia do (war; Następny) funkcja pozwala na wielokrotne stosowanie wyrażenia Następny,
początkowo do . potem do własnego wyjścia, aż dyr jest prawdziwy. Na przykład można to wykorzystać
zaimplementować funkcję czynnikową (patrz poniżej).

Należy pamiętać, że do (war; Następny) jest wewnętrznie zdefiniowana jako rekurencyjna funkcja jq. Rekursywny
dzwoni w ciągu dopóki() nie zużyje dodatkowej pamięci, jeśli Następny produkuje co najwyżej jeden
wyjście dla każdego wejścia. Zobacz zaawansowane tematy poniżej.

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

rekurencja(f), rekurencja, rekurencja(f; stan: schorzenie), recurse_down
Połączenia rekurencja(f) funkcja umożliwia przeszukiwanie struktury rekurencyjnej i wyodrębnianie
ciekawe dane ze wszystkich poziomów. Załóżmy, że twoje dane wejściowe reprezentują system plików:

{"imię": "/", "dzieci": [
{"Nazwa": "/kosz", "dzieci": [
{"Nazwa": "/bin/ls", "dzieci": []},
{"Nazwa": "/ Bin / sh", "dzieci": []}]},
{"Nazwa": "/ Home", "dzieci": [
{"imię": "/dom/stephen", "dzieci": [
{"imię": "/home/stephen/jq", "dzieci": []}]}]}]}

Załóżmy teraz, że chcesz wyodrębnić wszystkie obecne nazwy plików. Musisz odzyskać . Nazwa,
.dzieci[].nazwa, .dzieci[].dzieci[].nazwa, i tak dalej. Możesz to zrobić za pomocą:

recurse(.children[]) | .Nazwa

Kiedy zostaniesz wywołany bez argumentu, powtarzać się odpowiada rekurencja(.[]?).

rekurencja(f) jest identyczny z rekurencja(f; . != zero) i może być używany bez obaw o
głębokość rekurencji.

rekurencja(f; stan: schorzenie) to generator, który zaczyna się od emisji . a następnie emituje kolejno
.|f, .|f|f, .|f|f|f, ... o ile obliczona wartość spełnia warunek. Do
na przykład, żeby wygenerować wszystkie liczby całkowite, przynajmniej w zasadzie, można by napisać rekurencja(.+1;
prawdziwe).

Ze względów historycznych recurse_down istnieje jako alias do dzwonienia powtarzać się bez argumentów.
Ten alias jest brany pod uwagę przestarzałe i zostanie usunięty w następnej wersji głównej.

Rekursywne wywołania w powtarzać się nie zużyje dodatkowej pamięci za każdym razem, gdy f produkuje w
w większości jedno wyjście dla każdego wejścia.

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

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

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

..
Skrót dla powtarzać się bez argumentów. Ma to przypominać XPath //
operator. Zauważ, że ..oraz nie działa; posługiwać się ..|a zamiast. W poniższym przykładzie używamy
..|.a? znaleźć wszystkie wartości kluczy obiektu „a” w dowolnym obiekcie znalezionym „poniżej” ..

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

env
Wyprowadza obiekt reprezentujący środowisko jq.

jq ´śr.PAGER´
zero
=> "mniej"

transponować
Transponuj możliwie postrzępioną macierz (tablicę tablic). Wiersze są wypełnione wartościami null, więc
wynik jest zawsze prostokątny.

jq 'transponować'
[1], [2,3]]
=> [[1,2],[null,3]]

bszukaj(x)
bsearch(x) przeprowadza wyszukiwanie binarne dla x w tablicy wejściowej. Jeśli dane wejściowe są posortowane i
zawiera x, wtedy bsearch(x) zwróci swój indeks w tablicy; w przeciwnym razie, jeśli tablica to
posortowane, zwróci (-1 - ix), gdzie ix jest takim punktem wstawienia, że ​​tablica
nadal być posortowane po wstawieniu x w ix. Jeśli tablica nie jest posortowana, bsearch(x)
zwróci liczbę całkowitą, która prawdopodobnie nie jest interesująca.

jq´bszukaj(0)”.
[0,1]
=> 0

jq´bszukaj(0)”.
[1,2,3]
=> -1

jq´bszukaj(4) jako $ix | jeśli $ix < 0 to .[-(1+$ix)] = 4 else . kończyć się
[1,2,3]
=> [1,2,3,4]

sznur interpolacja - \(bla)
Wewnątrz łańcucha możesz umieścić wyrażenie wewnątrz nawiasów po odwrotnym ukośniku. Cokolwiek
zwracane wyrażenia będą interpolowane do łańcucha.

jq ´"Wkładem było \(.), czyli o jeden mniej niż \(.+1)"´
42
=> "Wpis wynosił 42, czyli o jeden mniej niż 43"

konwertować do od JSON
Połączenia Tojson i odjsona wbudowane zrzucają wartości jako teksty JSON lub analizują teksty JSON do
odpowiednio. Wbudowane tojson różni się od tostring tym, że zwraca tostring
ciągi niezmodyfikowane, podczas gdy tojson koduje ciągi jako ciągi JSON.

jq ´[.[]|ciąg]´
[1, "foo", ["foo"]]
=> ["1","foo","[\"foo\"]"]

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

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

utworzony smyczki i uciekać
Połączenia @bla składnia służy do formatowania i zmiany znaczenia ciągów, co jest przydatne przy budowaniu adresów URL,
dokumenty w języku takim jak HTML lub XML i tak dalej. @bla może służyć jako filtr na
własne, możliwe ucieczki to:

@tekst:

Połączenia tostrowanie, zobacz tę funkcję, aby uzyskać szczegółowe informacje.

@json:

Serializuje dane wejściowe jako JSON.

@html:

Stosuje kod ucieczki HTML/XML, mapując znaki <>&´" do ich podmiotu
odpowiedniki <, >, &, ", ".

@uri.:

Stosuje kodowanie procentowe, mapując wszystkie zastrzeżone znaki URI na a %XX sekwencja.

@csv:

Dane wejściowe muszą być tablicą i są renderowane jako CSV z podwójnymi cudzysłowami dla
ciągi i cudzysłowy, których uniknięto przez powtórzenie.

@tv:

Dane wejściowe muszą być tablicą i są renderowane jako TSV (wartości rozdzielone tabulatorami). Każdy
tablica wejściowa zostanie wydrukowana jako pojedyncza linia. Pola są oddzielone pojedynczą zakładką
(ascii 0x09). Wprowadź znaki wysuwu wiersza (ascii 0x0a), powrót przewozu (ascii
0x0d), zakładka (ascii 0x09) i odwrotny ukośnik (ascii 0x5c) zostanie wypisany jako ucieczka
sekwencje \n, \r, \t, \\ odpowiednio.

@CII:

Wejście jest escapowane, odpowiednie do użycia w wierszu poleceń powłoki POSIX. Jeśli
input jest tablicą, wyjściem będzie seria ciągów oddzielonych spacjami.

@base64:

Dane wejściowe są konwertowane na base64 zgodnie z RFC 4648.

Tę składnię można w użyteczny sposób połączyć z interpolacją ciągów. Możesz śledzić
@bla token z literałem ciągu. Zawartość literału napisowego będzie nie uciec.
Jednak wszystkie interpolacje wykonane w tym literale ciągu zostaną zmienione. Na przykład,

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

wygeneruje następujące dane wyjściowe dla danych wejściowych {"search":"co is jq?"}:

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

Zwróć uwagę, że ukośniki, znak zapytania itp. w adresie URL nie są pominięte, ponieważ były częścią
literału ciągu.

jq „@html”.
"Działa, jeśli x < y"
=> "To działa, jeśli x < y"

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

Daty
jq zapewnia podstawową funkcjonalność obsługi dat, z niektórymi wysokimi i niskimi poziomami
wbudowane. We wszystkich przypadkach te wbudowane rozwiązania dotyczą wyłącznie czasu w UTC.

Połączenia oddatais8601 wbudowany analizuje daty i godziny w formacie ISO 8601 do liczby sekund
od epoki Uniksa (1970-01-01T00:00:00Z). ten dzisiajiso8601 wbudowany robi odwrotność.

Połączenia od daty wbudowane analizuje ciągi daty i godziny. W tej chwili od daty obsługuje tylko ISO 8601
ciągi datetime, ale w przyszłości będzie próbował analizować ciągi datetime w more
formaty.

Połączenia spotykać się z kimś builtin to alias dla dzisiajiso8601.

Połączenia już dziś wbudowane wypisuje aktualny czas w sekundach od epoki Uniksa.

Dostępne są również niskopoziomowe interfejsy jq do funkcji czasowych z biblioteki C: czas strp,
strftime., mktime, gmtime. Zapoznaj się z dokumentacją systemu operacyjnego hosta, aby uzyskać informacje na temat
ciągi formatu używane przez czas strp i strftime.. Uwaga: niekoniecznie są one stabilne
interfejsy w jq, szczególnie jeśli chodzi o ich funkcjonalność lokalizacyjną.

Połączenia gmtime wbudowane zajmuje kilka sekund od epoki Uniksa i wypisuje "broken
czas przestoju” reprezentacja czasu jako tablica liczb reprezentująca (w tej kolejności):
rok, miesiąc (licząc od zera), dzień miesiąca, godzina dnia, minuta
godzina, sekunda minuty, dzień tygodnia i dzień roku – wszystko
oparty na jednej, chyba że zaznaczono inaczej.

Połączenia mktime wbudowane zużywa „przerwane czasy” reprezentacje czasu wyjściowego przez gmtime
i czas strp.

Połączenia strptime(fmt) wbudowane analizuje ciągi wejściowe pasujące do fmt argument. Wyjście jest w
reprezentacja „przerwanego czasu” konsumowana przez gmtime i wyjście przez mktime.

Połączenia strftime(fmt) wbudowane formatuje czas z podanym formatem.

Ciągi formatujące dla czas strp i strftime. są opisane w typowej bibliotece C
dokumentacja. Ciąg formatu dla daty i godziny ISO 8601 to "%Y-%m-%dT%H:%M:%SZ".

jq może nie obsługiwać niektórych lub wszystkich funkcji daty w niektórych systemach.

jq 'od daty'
"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

WARUNKI ROLNICZE PORÓWNANIA

==, !=
Wyrażenie „a == b” da „prawda”, jeśli wyniki a i b są równe (to znaczy
jeśli reprezentują równoważne dokumenty JSON) i „fałszywe” w przeciwnym razie. W szczególności struny
nigdy nie są uważane za równe liczby. Jeśli korzystasz z JavaScriptu, jq´s == jest jak
Javascript's === - uznawanie wartości za równe tylko wtedy, gdy mają ten sam typ oraz
tę samą wartość.

!= jest „nie równe”, a ´a != b´ zwraca przeciwną wartość ´a == b´

jq ’.[] == 1’
[1, 1.0, "1", "banan"]
=> prawda, prawda, fałsz, fałsz

jeśli-to-jeszcze
if A następnie B więcej C zakończenia będzie działać tak samo jak B if A daje wartość inną niż fałsz lub
null, ale zachowuj się tak samo jak C Inaczej.

Sprawdzanie fałszu lub null jest prostszym pojęciem „prawdziwości” niż w JavaScript
lub Pythona, ale oznacza to, że czasami będziesz musiał sprecyzować warunek
chcesz: nie możesz sprawdzić, czy np. ciąg jest pusty, używając if . Nazwa następnie A więcej B zakończenia,
potrzebujesz czegoś bardziej if (.Nazwa | długość) > 0 następnie A więcej B zakończenia zamiast.

Jeśli warunek A daje wiele wyników, jest uważany za „prawdziwy”, jeśli którykolwiek z nich
wyniki nie są fałszywe ani zerowe. Jeśli daje zero wyników, jest uważany za fałszywy.

Więcej przypadków można dodać do jeśli używasz Elif A następnie B składnia.

jq 'jeśli. == 0 wtedy

"zero" elif. == 1 potem "jeden" jeszcze "wiele" koniec´ 2 => "wiele"

>, >=, <=, <
Operatory porównania >, >=, <=, < zwróć, czy ich lewy argument jest większy niż,
większe lub równe, mniejsze lub równe lub mniejsze niż ich prawy argument
(odpowiednio).

Kolejność jest taka sama jak opisana dla rodzaj, powyżej.

jq. <5´
2
=> prawda

i/lub/nie
jq obsługuje normalne operatory logiczne i/lub/lub nie. Mają ten sam standard prawdy
jakby wyrażenia - false i null są uważane za "fałszywe wartości", a wszystko inne jest a
"prawdziwa wartość".

Jeśli argument jednego z tych operatorów daje wiele wyników, sam operator
da wynik dla każdego wejścia.

nie jest w rzeczywistości funkcją wbudowaną, a nie operatorem, więc jest wywoływana jako filtr do
które rzeczy mogą być przesyłane potokowo, a nie ze specjalną składnią, jak w .bla i .Kawiarnia | nie.

Te trzy dają tylko wartości „prawda” i „fałsz”, a więc są przydatne tylko w przypadku autentyczności
Operacje logiczne, zamiast popularnego idiomu Perl/Python/Ruby z
„value_that_may_be_null lub default”. Jeśli chcesz użyć tej formy „lub”, wybieraj między
dwie wartości zamiast oceny warunku, zobacz operator „//” poniżej.

jq ´42 i „ciąg”´
zero
=> prawda

jq ´(prawda, fałsz) lub fałsz´
zero
=> prawda, fałsz

jq ´(prawda, prawda) i (prawda, fałsz)´
zero
=> prawda, fałsz, prawda, fałsz

jq ´[prawda, fałsz | nie
zero
=> [fałsz, prawda]

alternatywa operator - //
Filtr formularza a // b daje takie same wyniki jak aJeśli a daje wyniki inne
niż fałszywy i zero. W przeciwnym razie, a // b daje takie same wyniki jak b.

Jest to przydatne przy dostarczaniu wartości domyślnych: .bla // 1 oceni to 1 jeśli nie ma .bla
element na wejściu. To jest podobne do tego, jak or jest czasami używany w Pythonie (jq´s or operator
jest zarezerwowany dla operacji ściśle logicznych).

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

jq `.foo // 42'
{}
=> 42

próbuj złapać
Błędy można wykryć za pomocą próbować EXP łapać EXP. Wykonywane jest pierwsze wyrażenie, a jeśli
kończy się niepowodzeniem, a następnie wykonywany jest drugi z komunikatem o błędzie. Dane wyjściowe procedury obsługi, jeśli
any, jest wyprowadzany tak, jakby był wynikiem wyrażenia do wypróbowania.

Połączenia próbować EXP używa formularza pusty jako program obsługi wyjątków.

jq ´spróbuj .a catch „. nie jest obiektem”´
prawdziwy
=> „. nie jest obiektem”

jq ´[.[]|spróbuj .a]´
[{}, prawda, {"a"::1}]
=> [null, 1]

jq ´spróbuj error("jakiś wyjątek") catch .´
prawdziwy
=> "jakiś wyjątek"

Przełamując na zewnątrz of kontrola Struktury
Wygodnym zastosowaniem try/catch jest wyrwanie się ze struktur kontrolnych, takich jak zmniejszyć, foreach,
PodczasI tak dalej.

Na przykład:

# Powtarzaj wyrażenie, aż podniesie "break" jako an
# błąd, a następnie przestań powtarzać bez ponownego zgłaszania błędu.
# Ale jeśli wyłapany błąd nie jest "break", to zwiększ go ponownie.
spróbuj powtórzyć(exp) catch .=="break" a następnie opróżnić inny błąd;

jq ma składnię nazwanych etykiet leksykalnych do „przerwania” lub „przejdź (wstecz) do”:

etykieta $out | ... wyrwać się ...

Połączenia złamać $nazwa_etykiety wyrażenie spowoduje, że program będzie zachowywał się tak, jakby najbliższy
(w lewo) etykieta $nazwa_etykiety wytworzony pusty.

Związek między złamać i odpowiadające etykieta jest leksykalny: etykieta musi być
"widoczny" od przerwy.

Wyrwać się z zmniejszyćna przykład:

etykieta $out | zmniejszyć .[] jako $item (null; jeśli .==false to przerwać $out else ... end)

Poniższy program jq generuje błąd składni:

wyrwać się

ponieważ nie ma etykiety $wyjście jest widoczny.

? operator
Połączenia ? operator, używany jako DO POTĘGI?, to skrót od próbować EXP.

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

REGULARNY WYRAŻENIA (PCRE)

jq korzysta z biblioteki wyrażeń regularnych Oniguruma, podobnie jak php, ruby, TextMate, Sublime Text,
itp., więc opis tutaj skupi się na szczegółach jq.

Filtry jq regex są zdefiniowane tak, że można ich używać przy użyciu jednego z następujących wzorców:

STRING | FILTR(REGEX)
STRING | FILTR( REGEX; FLAGI )
STRING | FILTR( [REGEX] )
STRING | FILTR( [REGEX, FLAGI] )

gdzie: * STRING, REGEX i FLAGS są napisami jq i podlegają interpolacji napisów jq; *
REGEX, po interpolacji ciągów, powinien być prawidłowym wyrażeniem regularnym PCRE; * FILTR jest jednym z test,
meczlub zdobyć, Jak opisano poniżej.

FLAGS to łańcuch składający się z jednej z kilku obsługiwanych flag:

· g - Wyszukiwanie globalne (znajdź wszystkie dopasowania, nie tylko pierwsze)

· i - Wyszukiwanie bez uwzględniania wielkości liter

· m - Tryb wielowierszowy (´.´ dopasuje nowe wiersze)

· n - Ignoruj ​​puste dopasowania

· p - Oba tryby s i m są włączone

· s - Tryb pojedynczej linii (´^´ -> ´\A´, ´$´ -> ´\Z´)

· l - Znajdź najdłuższe możliwe mecze

· x - Rozszerzony format regex (ignoruj ​​spacje i komentarze)

Aby dopasować białe znaki we wzorcu x, użyj ucieczki, takiej jak \s, np.

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

Zauważ, że niektóre flagi mogą być również określone w REGEX, np.

· jq -n ´("test", "TEST", "teST", "TEST") | test( "(?i)te(?-i)st" )´

ocenia jako: prawda, prawda, fałsz, fałsz.

[Wymaga 1.5] test(wartość), test(wyrażenie regularne; flagi)
Jak mecz, ale nie zwraca tylko obiektów dopasowania prawdziwy or fałszywy czy
wyrażenie regularne pasuje do danych wejściowych.

jq ´test("foo")´
"bla"
=> prawda

jq ´.[] | test("abc # spacje są ignorowane"; "ix")´
["xabcd", "ABC"]
=> prawda, prawda

[Wymaga 1.5] dopasowanie(wartość), dopasowanie(wyrażenie regularne; flagi)
mecz wypisuje obiekt dla każdego znalezionego dopasowania. Dopasowania mają następujące pola:

· offset - przesunięcie w kodach UTF-8 od początku wejścia

· długość - długość w kodach UTF-8 meczu

· ciąg - ciąg, który pasował

· przechwytuje - tablica obiektów reprezentujących grupy przechwytywania.

Przechwytywanie obiektów grupy ma następujące pola:

· offset - przesunięcie w kodach UTF-8 od początku wejścia

· długość - długość w kodach UTF-8 tej grupy przechwytywania

· ciąg - sznurek, który został przechwycony

· Nazwa - nazwa grupy przechwytującej (lub zero jeśli był nienazwany)

Przechwytywanie grup, które nie pasują do niczego, zwracają przesunięcie -1

jq ´match("(abc)+"; "g")´
„abc abc”
=> {"offset": 0, "length": 3, "string": "abc", "captures": [{"offset": 0, "length": 3, "string": "abc", " name: null}]}, {"offset": 4, "length": 3, "string": "abc", "captures": [{"offset": 4, "length": 3, "string" : "abc", "name": null}]}

jq ´match("foo")´
„foo bar foo”
=> {"offset": 0, "length": 3, "string": "foo", "captures": []}

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

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

jq ´[ match("."; "g")] | długość
"ABC"
=> 3

[Wymaga 1.5] przechwytywanie(val), przechwytywanie(wyrażenie regularne; flagi)
Zbiera nazwane przechwycenia w obiekcie JSON, z nazwą każdego przechwycenia jako kluczem,
a dopasowany ciąg jako odpowiednią wartość.

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

[Wymaga 1.5] skan (wyrażenie regularne), skanuj(wyrażenie regularne; flagi)
Emituj strumień niepokrywających się podciągów danych wejściowych, które pasują do wyrażenia regularnego w
zgodnie z flagami, jeśli takie zostały określone. Jeśli nie ma dopasowania, strumień jest
pusty. Aby przechwycić wszystkie dopasowania dla każdego ciągu wejściowego, użyj idiomu [ expr ]np [
skanuj (wyrażenie regularne) ].

podział(wyrażenie regularne; flagi)
dla wstecznej kompatybilności, dzielić dzieli na ciąg, a nie na wyrażenie regularne.

[Wymaga 1.5] podziały (wyrażenie regularne), dzieli(wyrażenie regularne; flagi)
Zapewniają takie same wyniki jak ich dzielić odpowiedniki, ale jako strumień zamiast
szyk.

[Wymaga 1.5] sub(wyrażenie regularne; tostrowanie) sub(wyrażenie regularne; strunowy; flagi)
Emituj ciąg uzyskany przez zastąpienie pierwszego dopasowania wyrażenia regularnego w ciągu wejściowym przez
tostrowanie, po interpolacji. tostrowanie powinien być ciągiem jq i może zawierać odwołania
do nazwanych przechwytów. Nazwane przechwycenia są w efekcie prezentowane jako obiekt JSON (jako
zbudowany przez zdobyć) Do tostrowanie, więc odwołanie do przechwyconej zmiennej o nazwie „x”
przybrać formę: „(.x)”.

[Wymaga 1.5] gsub(wyrażenie regularne; strunowy), gsub(wyrażenie regularne; strunowy; flagi)
gsub jest jak poniżej ale wszystkie nienakładające się wystąpienia wyrażenia regularnego są zastępowane przez
ciąg, po interpolacji.

ADVANCED ROZWIĄZANIA

Zmienne są absolutną koniecznością w większości języków programowania, ale są relegowane
do „funkcji zaawansowanej” w jq.

W większości języków zmienne są jedynym sposobem przekazywania danych. Jeśli obliczysz a
wartość i chcesz jej użyć więcej niż raz, musisz ją przechowywać w zmiennej. Do
przekazać wartość do innej części programu, będziesz potrzebować tej części programu, aby
zdefiniować zmienną (jako parametr funkcji, element obiektu lub cokolwiek), w której należy umieścić
dane.

Możliwe jest również zdefiniowanie funkcji w jq, chociaż jest to cecha, której największa
użycie jest definiowanie standardowej biblioteki jq (wiele funkcji jq, takich jak mapa i odnaleźć są w rzeczywistości
napisane w jq).

jq ma operatory redukcji, które są bardzo potężne, ale nieco skomplikowane. Znowu są to
najczęściej używane wewnętrznie, aby zdefiniować kilka użytecznych bitów standardowej biblioteki jq.

Może nie jest to na pierwszy rzut oka oczywiste, ale jq to wszystko o generatorach (tak, jak często spotyka się w
inne języki). Niektóre narzędzia pomagają radzić sobie z generatorami.

Pewna minimalna obsługa we/wy (oprócz odczytywania JSON ze standardowego wejścia i pisania JSON do
standardowe wyjście) jest dostępne.

Wreszcie istnieje system modułów/biblioteki.

Zmienne
W jq wszystkie filtry mają wejście i wyjście, więc ręczna instalacja hydrauliczna nie jest konieczna
przekazać wartość z jednej części programu do następnej. Na przykład wiele wyrażeń a + b,
przekazać swoje dane wejściowe do dwóch różnych podwyrażeń (tutaj a i b są oboje zdani tak samo
input), więc zmienne zwykle nie są potrzebne do dwukrotnego użycia wartości.

Na przykład obliczenie średniej wartości tablicy liczb wymaga kilku
zmienne w większości języków — przynajmniej jedna do przechowywania tablicy, być może jedna dla każdego elementu
lub licznik pętli. W jq to po prostu Dodaj / długość - w Dodaj wyrażenie jest podane
tablica i tworzy jej sumę, a długość wyrażenie otrzymuje tablicę i tworzy jej
długość.

Tak więc generalnie istnieje czystszy sposób rozwiązywania większości problemów w jq niż definiowanie zmiennych.
Czasami jednak ułatwiają pracę, więc jq pozwala definiować zmienne za pomocą
wyrażenie as $zmienna. Wszystkie nazwy zmiennych zaczynają się od $. Oto nieco brzydsza wersja
przykładu uśredniania tablicy:

długość jako $array_length | dodaj / $długość_tablicy

Będziemy potrzebować bardziej skomplikowanego problemu, aby znaleźć sytuację, w której faktycznie używamy zmiennych
ułatwia nam życie.

Załóżmy, że mamy szereg postów na blogu z polami „autor” i „tytuł” ​​oraz jeszcze jednym
obiekt, który jest używany do mapowania nazw użytkowników autorów na prawdziwe nazwiska. Nasz wkład wygląda następująco:

{"posts": [{"title": "Pierwszy post", "autor": "anon"},
{"title": "Dobrze napisany artykuł", "autor": "person1"}],
"realnames": {"anon": "Anonimowy Tchórz",
"person1": "Osoba McPherson"}}

Chcemy tworzyć posty z polem autora zawierającym prawdziwe nazwisko, jak w:

{"title": "Pierwszy psot", "autor": "Anonimowy tchórz"}
{"title": "Dobrze napisany artykuł", "autor": "Person McPherson"}

Używamy zmiennej $names do przechowywania obiektu realnames, aby móc się do niego później odwołać
podczas wyszukiwania nazw użytkowników autorów:

.realnames jako $names | .posty[] | {tytuł, autor: $names[.author]}

Ekspresja exp as $x | ... oznacza: dla każdej wartości wyrażenia exp, uruchom resztę
rurociąg z całym oryginalnym wejściem i z $x ustawić na tę wartość. Zatem as
działa jako coś w rodzaju pętli foreach.

Tak samo jak {bla} to wygodny sposób pisania {bla: .bla}, więc {$foo} to wygodny sposób pisania
{foo:$foo}.

Wiele zmiennych można zadeklarować za pomocą jednego as wyrażenie poprzez podanie wzoru
który pasuje do struktury danych wejściowych (jest to znane jako „destrukturyzacja”):

. jako {realnames: $names, posty: [$first, $second]} | ...

Deklaracje zmiennych we wzorcach tablicowych (np. . as [$pierwszy, $druga]) powiąż z
elementy tablicy od elementu o indeksie zero w górę, w kolejności. Kiedy nie ma
wartość w indeksie dla elementu wzorca tablicy, zero jest powiązany z tą zmienną.

Zakres zmiennych obejmuje resztę wyrażenia, które je definiuje, więc

.realnames jako $names | (.posts[] | {tytuł, autor: $names[.autor]})

zadziała, ale

(.realnames jako $names | .posts[]) | {tytuł, autor: $names[.author]}

przyzwyczajenie.

Dla teoretyków języka programowania dokładniejsze jest stwierdzenie, że zmienne jq są
powiązania o zakresie leksykalnym. W szczególności nie ma możliwości zmiany wartości oprawy;
można ustawić tylko nowe wiązanie o tej samej nazwie, które nie będzie widoczne gdzie
stary był.

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

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

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

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

Definiowanie Funkcje
Możesz nadać filtrowi nazwę, używając składni "def":

przyrost definicji: . + 1;

Odtąd, przyrost może być używany jako filtr, tak jak funkcja wbudowana (w rzeczywistości to
tak definiuje się niektóre z poleceń wbudowanych). Funkcja może przyjmować argumenty:

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

Argumenty są przekazywane jako filtry, a nie jako wartości. Można odnieść się do tego samego argumentu
wielokrotnie z różnymi danymi wejściowymi (tutaj f jest uruchamiany dla każdego elementu tablicy wejściowej).
Argumenty funkcji działają bardziej jak wywołania zwrotne niż jak argumenty wartości. To jest
ważne do zrozumienia. Rozważać:

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

Wynik wyniesie 20, ponieważ f is .*2, oraz podczas pierwszego przywołania f . będzie 5,
a za drugim razem będzie to 10 (5 * 2), więc wynikiem będzie 20. Argumenty funkcji
są filtrami, a filtry oczekują danych wejściowych po wywołaniu.

Jeśli chcesz zachowania argumentu wartości do definiowania prostych funkcji, możesz po prostu użyć a
zmienna:

def wartość dodana(f): f jako $f | mapa(. + $f);

Lub użyj skrótu:

def dodajwartość($f): ...;

Z każdą definicją, wartość dodana(.foo) doda bieżące dane wejściowe .bla pole do każdego
element tablicy.

Dozwolonych jest wiele definicji używających tej samej nazwy funkcji. Każda redefinicja zastępuje
poprzedni dla tej samej liczby argumentów funkcji, ale tylko dla odwołań z
funkcje (lub program główny) po ponownej definicji.

jq ´def addvalue(f): . + [f]; mapa(wartośćdod(.[0]))´
[[1,2], [10,20]]
=> [[1,2,1], [10,20,10]]

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

Zredukować
Połączenia zmniejszyć składnia w jq pozwala na łączenie wszystkich wyników wyrażenia według
zbierając je w jedną odpowiedź. Jako przykład przejdziemy [3,2,1] do tego
wyrażenie:

zmniejszyć .[] jako $item (0; . + $item)

Za każdy wynik, który .[] produkuje, . + $przedmiot jest prowadzony w celu zgromadzenia bieżącej sumy,
zaczynając od 0. W tym przykładzie .[] daje wyniki 3, 2 i 1, więc efekt jest
podobnie do uruchomienia czegoś takiego:

0 | (3 jako $pozycja | . + $pozycja) |
(2 jako $pozycja | . + $pozycja) |
(1 jako $pozycja | . + $pozycja)

jq ´redukuj .[] jako $pozycja (0; . + $pozycja)´
[10,2,5,3]
=> 20

granica(n; do potęgi)
Połączenia ograniczenie ekstrakty funkcji do n wyjścia z exp.

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

pierwszy (wyrażenie), ostatni(wyraż), n-ty(n; wyraż)
Połączenia pierwszy (wyrażenie) i ostatni(wyraż) funkcje pobierają pierwszą i ostatnią wartość z expr,
odpowiednio.

Połączenia n-ty(n; wyraż) funkcja wyodrębnia n-tą wartość wyjściową przez expr. Można to zdefiniować jako
def n-ty(n; wyraż): ostatni(limit(n + 1; wyr));, Należy pamiętać, że n-ty(n; wyraż) nie obsługuje
ujemne wartości n.

jq ´[pierwszy(zakres(.)), ostatni(zakres(.)), n-ty(./2; zakres(.))]´
10
=> [0,9,5]

pierwszy, ostatni, n-ty(n)
Połączenia drugim i trwać funkcje wyodrębniają pierwszą i ostatnią wartość z dowolnej tablicy w ..

Połączenia n-ty(n) funkcja wyodrębnia n-tą wartość z dowolnej tablicy w ..

jq ´[zakres(.)]|[pierwszy, ostatni, n-ty(5)]'
10
=> [0,9,5]

foreach
Połączenia foreach składnia jest podobna do zmniejszyć, ale ma na celu umożliwienie budowy ograniczenie
oraz reduktory, które dają wyniki pośrednie (patrz przykład).

Forma to foreach EXP as $zmienna (W TYM; AKTUALIZACJA; WYCIĄG), Jak zmniejszyć, INIT jest oceniany
raz, aby wytworzyć wartość stanu, a następnie każde wyjście EXP jest zobowiązany $zmienna, Aktualizacja is
oceniane dla każdego wyjścia EXP z obecnym stanem i z $zmienna widoczny. Każda wartość
wyjście przez Aktualizacja zastępuje poprzedni stan. Wreszcie, WYCIĄG jest oceniany dla każdego nowego
stan do wyodrębnienia wyjścia z foreach.

Jest to głównie przydatne tylko do konstruowania zmniejszyć- I ograniczeniepodobne funkcje. Ale to jest
znacznie bardziej ogólne, ponieważ pozwala na częściowe redukcje (patrz przykład poniżej).

jq ´[foreach .[] as $item ([[],[]]; if $item == null then [[],.[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"]]

Rekurencja
Jak opisano powyżej, powtarzać się używa rekurencji, a każda funkcja jq może być rekurencyjna. ten
Podczas wbudowany jest również zaimplementowany pod kątem rekurencji.

Wywołania ogonowe są optymalizowane za każdym razem, gdy wyrażenie na lewo od rekurencyjnych wyjść wywołań
jego ostatnia wartość. W praktyce oznacza to, że wyrażenie na lewo od rekurencyjnego
wywołanie nie powinno generować więcej niż jednego wyjścia dla każdego wejścia.

Na przykład:

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

def while(war; aktualizacja):
def _gdy:
if cond then ., (update | _while) else pusty koniec;
_dopóki;

def powtórz(exp):
def _powtórz:
exp, _powtórz;
_powtarzać;

Generatory i iteratory
Niektóre operatory i funkcje jq są w rzeczywistości generatorami, ponieważ mogą wytworzyć zero,
jedna lub więcej wartości dla każdego wejścia, tak jak można by się spodziewać w innych programach
języki, które mają generatory. Na przykład, .[] generuje wszystkie wartości w swoim wejściu
(który musi być tablicą lub obiektem), zakres(0; 10) generuje liczby całkowite od 0 do
10 i tak dalej.

Nawet operator przecinka jest generatorem, generującym najpierw wartości generowane przez
wyrażenie po lewej stronie przecinka, a następnie dla każdego z nich wartości generowane przez
wyrażenie po prawej stronie przecinka.

Połączenia pusty wbudowany jest generatorem, który generuje zerowe wyjścia. ten pusty wbudowany
cofa się do poprzedniego wyrażenia generatora.

Wszystkie funkcje jq mogą być generatorami tylko przy użyciu wbudowanych generatorów. Jest to również możliwe
aby zdefiniować nowe generatory używając tylko rekurencji i operatora przecinka. Jeśli cykliczny
wezwanie (s) jest (są) "w pozycji ogonowej", wtedy generator będzie sprawny. W przykładzie
poniżej rekursywnego wywołania przez _zakres do siebie jest w pozycji ogona. Przykład się pokazuje
trzy zaawansowane tematy: rekurencja ogona, budowa generatora i podfunkcje.

jq ´def zakres(init; upto; by): def _range: if (o > 0 i . < upto) lub (o < 0 i . > upto) then ., ((.+by)|_range) else . kończyć się; if by == 0 to init else init|_range end | select((o > 0 i . < do) lub (o < 0 i . > do)); zakres (0; 10; 3)'
zero
=> 0, 3, 6, 9

jq ´def while(cond; update): def _while: if cond then ., (update | _while) else pusty koniec; _dopóki; [gdy(.<100; .*2)]´
1
=> [1,2,4,8,16,32,64]

MATH

jq obecnie obsługuje tylko liczby zmiennoprzecinkowe podwójnej precyzji IEEE754 (64-bitowe).

Oprócz prostych operatorów arytmetycznych, takich jak +jq ma również większość standardowych funkcji matematycznych
z biblioteki matematycznej C. funkcje matematyczne języka C, które przyjmują pojedynczy argument wejściowy (np. grzech())
są dostępne jako zero-argumentowe funkcje jq. C funkcje matematyczne, które pobierają dwa dane wejściowe
argumenty (np. pow ()) są dostępne jako dwuargumentowe funkcje jq, które ignorują ..

Dostępność standardowych funkcji matematycznych zależy od dostępności odpowiednich
funkcje matematyczne w systemie operacyjnym i biblioteka matematyczna C. Niedostępne funkcje matematyczne
zostanie zdefiniowany, ale zgłosi błąd.

I / O

W tej chwili jq ma minimalne wsparcie dla I/O, głównie w formie kontroli kiedy
wejścia są odczytywane. Do tego służą dwie wbudowane funkcje, wkład i Wejścia, który przeczytał
z tych samych źródeł (np. stdin, pliki nazwane w wierszu poleceń) jako sam jq. Te
dwa wbudowane i własne akcje czytania jq mogą być ze sobą przeplatane.

Jedno wbudowane zapewnia minimalne możliwości wyjściowe, debug. (Przypomnij sobie, że program jq's
wartości wyjściowe są zawsze wyprowadzane jako teksty JSON włączone stdout.) debug wbudowany może mieć
zachowanie specyficzne dla aplikacji, na przykład w przypadku plików wykonywalnych, które używają interfejsu API libjq C, ale nie są
sam plik wykonywalny jq.

wkład
Wyprowadza jedno nowe wejście.

Wejścia
Wyprowadza wszystkie pozostałe wejścia, jeden po drugim.

Jest to przydatne przede wszystkim w przypadku redukcji danych wejściowych programu.

debug
Powoduje wygenerowanie komunikatu debugowania na podstawie wartości wejściowej. Plik wykonywalny jq zawija
wartość wejściowa z ["ODPLUSKWIĆ:", ] i wypisuje to i nową linię na stderr,
zwięźle. Może się to zmienić w przyszłości.

nazwa_pliku_wejściowego
Zwraca nazwę pliku, którego dane wejściowe są aktualnie filtrowane. Zauważ, że to będzie
nie działa dobrze, chyba że jq działa w lokalizacji UTF-8.

numer_linii_wejściowej
Zwraca numer wiersza aktualnie filtrowanego wejścia.

STREAMING

Z --strumień opcja jq może analizować tekst wejściowy w sposób strumieniowy, umożliwiając jq
programy do przetwarzania dużych tekstów JSON natychmiast, a nie po parsowaniu
kończy. Jeśli masz pojedynczy tekst JSON o rozmiarze 1 GB, przesyłanie strumieniowe pozwoli ci
przetworzyć go znacznie szybciej.

Jednak przesyłanie strumieniowe nie jest łatwe w obsłudze, jak to będzie miało w programie jq [ ,
] (i kilka innych form) jako dane wejściowe.

Dostępnych jest kilka wbudowanych funkcji, które ułatwiają obsługę strumieni.

Poniższe przykłady wykorzystują przesyłaną strumieniowo formę [0, [1]], który jest
[[0],0],[[1,0],1],[[1,0]],[[1]].

Formy przesyłania strumieniowego obejmują [ , ] (wskazać dowolną wartość skalarną, pustą tablicę,
lub pustym przedmiotem) oraz [ ] (aby wskazać koniec tablicy lub obiektu). Przyszły
wersje jq uruchamiane z --strumień i -nast może wyświetlać dodatkowe formularze, takie jak ["błąd
wiadomość"] gdy tekst wejściowy nie zostanie przeanalizowany.

truncate_stream(wyrażenie_strumienia)
Zużywa liczbę jako dane wejściowe i obcina odpowiednią liczbę elementów ścieżki z
po lewej stronie danych wyjściowych danego wyrażenia strumieniowego.

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

ze strumienia (wyrażenie_strumienia)
Wyprowadza wartości odpowiadające wynikom wyrażenia strumienia.

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

do strumienia
Połączenia do strumienia wbudowane wyprowadza strumieniową formę swojego wejścia.

jq. jako $kropka|ze strumienia($kropka|do strumienia)|.==$kropka´
[0,[1,{"a":1},{"b":2}]]
=> prawda

ZADANIE

Przypisanie działa trochę inaczej w jq niż w większości języków programowania. jq nie
rozróżniać odniesienia do czegoś i kopie czegoś - dwa obiekty lub tablice są
równy lub nierówny, bez dalszego pojęcia bycia „tym samym przedmiotem” lub „nie”
ten sam przedmiot".

Jeśli obiekt ma dwa pola będące tablicami, .bla i .Kawiarniai dodajesz coś do
.bla, następnie .Kawiarnia nie urosnie. Nawet jeśli właśnie ustawiłeś .Kawiarnia = .bla. Jeśli jesteś używany
do programowania w językach takich jak Python, Java, Ruby, Javascript itp. to możesz pomyśleć
z tego tak, jakby jq wykonał pełną głęboką kopię każdego obiektu przed wykonaniem zadania
(w przypadku wydajności, tak naprawdę tego nie robi, ale to jest ogólna idea).

Wszystkie operatory przypisania w jq mają wyrażenia ścieżki po lewej stronie.

=
Filtr .bla = 1 jako dane wejściowe przyjmie obiekt i wytworzy jako wynik obiekt z
pole "foo" ustawione na 1. W jq nie ma pojęcia o "modyfikowaniu" lub "zmianie" czegoś -
wszystkie wartości jq są niezmienne. Na przykład,

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

nie będzie miało efektu ubocznego ustawienia .bar.baz na 1, ponieważ podobnie wyglądający
program w JavaScript, Python, Ruby lub w innych językach. W przeciwieństwie do tych języków (ale
jak Haskell i niektóre inne języki funkcyjne), nie ma pojęcia dwóch tablic lub
obiekty będące „taką samą tablicą” lub „tym samym obiektem”. Mogą być równe lub nie równe, ale
jeśli zmienimy jednego z nich, w żadnym wypadku nie zmieni się drugi za naszymi plecami.

Oznacza to, że niemożliwe jest budowanie wartości cyklicznych w jq (takich jak tablica, której
pierwszym elementem jest sam). Jest to celowe i zapewnia, że ​​wszystko, co jq
program, który może wyprodukować, może być reprezentowany w formacie JSON.

Zauważ, że lewa strona ´=´ odnosi się do wartości w .. A zatem $var.foo = 1 nie zadziała
zgodnie z oczekiwaniami ($var.foo nie jest prawidłowym lub użytecznym wyrażeniem ścieżki w .); posługiwać się $zmienna | .bla = 1
zamiast.

Jeśli prawa strona ´=´ daje wiele wartości, to dla każdej takiej wartości jq będzie
ustaw ścieżki po lewej stronie na wartość, a następnie wyświetli zmodyfikowaną ..
Na przykład, (.a,.b)=zasięg(2) Wyjścia {"a":0,"b":0}, następnie {"a":1,"b":1}. Aktualizacja"
formularze przydziału (patrz poniżej) tego nie robią.

Zauważ też, że .a, .b=0 nie ustawia .a i .b, ale (.a,.b)=0 ustawia oba.

|=
Oprócz operatora przypisania ´=´, jq zapewnia operator „aktualizacji” ´|=´, który
pobiera filtr po prawej stronie i opracowuje nową wartość właściwości .
przypisywana przez uruchomienie starej wartości przez to wyrażenie. Na przykład .foo |=
.+1 zbuduje obiekt z polem "foo" ustawionym na "foo" plus 1.

Ten przykład powinien pokazać różnicę między ´=´ i ´|=´:

Wprowadź dane wejściowe ´{"a": {"b": 10}, "b": 20}´ do programów:

.a = .b .a |= .b

Pierwsza ustawi pole „a” danych wejściowych na pole „b” danych wejściowych i wyprodukuje
wyjście {"a": 20}. Ten ostatni ustawi pole „a” danych wejściowych na pola „a”
pole "b", dające {"a": 10}.

Lewa strona może być dowolnym ogólnym wyrażeniem ścieżki; zobaczyć ścieżka().

Zauważ, że lewa strona ´|=´ odnosi się do wartości w .. A zatem $var.foo |= . + 1 przyzwyczajenie
pracuj zgodnie z oczekiwaniami ($var.foo nie jest prawidłowym lub użytecznym wyrażeniem ścieżki w .); posługiwać się $zmienna | .bla
|= . + 1 zamiast.

Jeśli prawa strona wyprowadza wiele wartości, zostanie użyta tylko ostatnia.

jq ´(..|select(type=="boolean")) |= if . następnie 1 inny 0 koniec´
[prawda,fałsz,[5,prawda,[prawda,[fałsz]],fałsz]]
=> [1,0,[5,1,[1,[0]],0]]

+=, -=, *=, /=, %=, // =
jq ma kilka operatorów postaci a op= b, które są równoważne a |= . op b. Więc,
+= 1 może służyć do zwiększania wartości.

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

Kompleks Zadania
Dużo więcej rzeczy jest dozwolonych po lewej stronie przypisania jq niż w większości
Języki. Widzieliśmy już proste dostępy do pola po lewej stronie i to nie
zaskoczenie, że dostęp do tablicy działa równie dobrze:

.posts[0].title = "Podręcznik JQ"

Niespodzianką może być to, że wyrażenie po lewej stronie może generować wiele
wyniki, odnosząc się do różnych punktów w dokumencie wejściowym:

.posty[].komentarze |= . + ["to jest świetne"]

Ten przykład dołącza ciąg „to jest świetne” do tablicy „comments” każdego posta w
dane wejściowe (gdzie dane wejściowe to obiekt z polem "posts" będącym tablicą postów).

Kiedy jq napotyka przypisanie, takie jak „a = b”, zapisuje „ścieżkę” wybraną do wybrania a
część dokumentu wejściowego podczas wykonywania Ta ścieżka jest następnie używana do określenia, która część
wejście do zmiany podczas wykonywania przypisania. Dowolny filtr może być użyty na
lewa strona równania – którakolwiek ścieżka wybierze z danych wejściowych, będzie tam, gdzie
przypisanie jest wykonywane.

To bardzo potężna operacja. Załóżmy, że chcemy dodać komentarz do postów na blogu, używając
to samo wejście „blog” powyżej. Tym razem chcemy tylko komentować posty napisane przez
„stedolan”. Posty te możemy znaleźć za pomocą opisanej wcześniej funkcji „wybierz”:

.posty[] | select(.author == "stedolan")

Ścieżki udostępnione przez tę operację wskazują na każdy z postów napisanych przez „stedolan” i
możemy skomentować każdy z nich w taki sam sposób, jak robiliśmy to wcześniej:

(.posts[] | select(.author == "stedolan") | .komentarze) |=
. + ["straszne."]

MODUŁY

jq posiada system bibliotek/modułów. Moduły to pliki, których nazwy kończą się na .jq.

Moduły importowane przez program są wyszukiwane w domyślnej ścieżce wyszukiwania (patrz niżej). ten
importować i zawierać dyrektywy umożliwiają importerowi zmianę tej ścieżki.

Ścieżki w ścieżce wyszukiwania podlegają różnym podstawieniom.

W przypadku ścieżek zaczynających się od „~/”, katalog domowy użytkownika jest zastępowany „~”.

W przypadku ścieżek zaczynających się od „$ORIGIN/”, ścieżka pliku wykonywalnego jq jest zastępowana przez
„$ORIGIN”.

W przypadku ścieżek zaczynających się od „./” lub ścieżek, które są „.”, ścieżka pliku dołączanego to
zastąpiony przez ".". W przypadku programów najwyższego poziomu podanych w wierszu poleceń bieżący
używany jest katalog.

Dyrektywy importu mogą opcjonalnie określać ścieżkę wyszukiwania, do której dołączona jest wartość domyślna.

Domyślną ścieżką wyszukiwania jest ścieżka wyszukiwania podana do -L opcja wiersza poleceń, else
["~/.jq", "$ORIGIN/../lib/jq", „$ORIGIN/../ lib"].

Puste i puste ciągi ścieżek kończą przetwarzanie ścieżki wyszukiwania.

Zależność ze ścieżką względną „foo/bar” byłaby wyszukiwana w „foo/bar.jq” i
„foo/bar/bar.jq” w podanej ścieżce wyszukiwania. Ma to na celu umożliwienie umieszczenia modułów
w katalogu wraz z np. plikami kontroli wersji, plikami README itd.,
ale także aby umożliwić moduły jednoplikowe.

Kolejne komponenty o tej samej nazwie nie mogą uniknąć niejasności (np.
"foo/foo").

Na przykład za pomocą -L$HOME/.jq moduł bla można znaleźć $HOME/.jq/foo.jq i
$HOME/.jq/foo/foo.jq.

Jeśli "$HOME/.jq" jest plikiem, jest on pobierany z programu głównego.

importować Ciąg Ścieżki Względnej as IMIĘ [ ];
Importuje moduł znaleziony w podanej ścieżce względem katalogu w ścieżce wyszukiwania. „.jq”
przyrostek zostanie dodany do ciągu względnego ścieżki. Symbole modułu są poprzedzone
"NAZWA::".

Opcjonalne metadane muszą być stałym wyrażeniem jq. Powinien to być obiekt z klawiszami
jak „strona główna” i tak dalej. Obecnie jq używa tylko klucza/wartości „szukaj”
metadane. Metadane są również udostępniane użytkownikom za pośrednictwem metamoduł wbudowany.

Klucz „szukaj” w metadanych, jeśli jest obecny, powinien mieć ciąg lub wartość tablicy (array
strun); jest to ścieżka wyszukiwania, która ma być poprzedzona ścieżką wyszukiwania najwyższego poziomu.

zawierać Ciąg Ścieżki Względnej [ ];
Importuje moduł znaleziony w podanej ścieżce względem katalogu w ścieżce wyszukiwania, tak jakby to
zostały uwzględnione na miejscu. Do ciągu ścieżki względnej zostanie dodany przyrostek „.jq”. ten
symbole modułu są importowane do przestrzeni nazw wywołującego, tak jakby zawartość modułu miała
zostały uwzględnione bezpośrednio.

Opcjonalne metadane muszą być stałym wyrażeniem jq. Powinien to być obiekt z klawiszami
jak „strona główna” i tak dalej. Obecnie jq używa tylko klucza/wartości „szukaj”
metadane. Metadane są również udostępniane użytkownikom za pośrednictwem metamoduł wbudowany.

importować Ciąg Ścieżki Względnej as $NAZWA [ ];
Importuje plik JSON znaleziony w podanej ścieżce względem katalogu w ścieżce wyszukiwania. A
Do ciągu ścieżki względnej zostanie dodany przyrostek „.json”. Dane pliku będą
dostępny jako $NAZWA::NAZWA.

Opcjonalne metadane muszą być stałym wyrażeniem jq. Powinien to być obiekt z klawiszami
jak „strona główna” i tak dalej. Obecnie jq używa tylko klucza/wartości „szukaj”
metadane. Metadane są również udostępniane użytkownikom za pośrednictwem metamoduł wbudowany.

Klucz „szukaj” w metadanych, jeśli jest obecny, powinien mieć ciąg lub wartość tablicy (array
strun); jest to ścieżka wyszukiwania, która ma być poprzedzona ścieżką wyszukiwania najwyższego poziomu.

moduł ;
Ta dyrektywa jest całkowicie opcjonalna. Nie jest to wymagane do prawidłowego działania. Służy
wyłącznie w celu dostarczenia metadanych, które można odczytać za pomocą metamoduł wbudowany.

Metadane muszą być stałym wyrażeniem jq. Powinien to być obiekt z kluczami, takimi jak
„strona główna”. Obecnie jq nie używa tych metadanych, ale są one dostępne dla użytkowników
za pośrednictwem metamoduł wbudowany.

metamoduł
Pobiera nazwę modułu jako dane wejściowe i wyprowadza metadane modułu jako obiekt, przy czym
importy modułu (w tym metadane) jako wartość tablicy dla klucza "deps".

Programy mogą użyć tego do zapytania o metadane modułu, których mogą następnie użyć do, dla
na przykład wyszukaj, pobierz i zainstaluj brakujące zależności.

Korzystaj z jq online za pomocą usług onworks.net