Bu, Ubuntu Online, Fedora Online, Windows çevrimiçi emülatörü veya MAC OS çevrimiçi emülatörü gibi birden fazla ücretsiz çevrimiçi iş istasyonumuzdan birini kullanarak OnWorks ücretsiz barındırma sağlayıcısında çalıştırılabilen jq komutudur.
Program:
ADI
jq - Komut satırı JSON işlemcisi
SİNOPSİS
jq [seçenekleri...] filtre [Dosyaları...]
jq JSON'u seçerek, yineleyerek, azaltarak ve başka şekillerde dönüştürebilir.
JSON belgelerini karıştırma. Örneğin, komutu çalıştırmak jq ´harita(.price) | Ekle irade
girdi olarak bir dizi JSON nesnesi alın ve "fiyat" alanlarının toplamını döndürün.
jq metin girişini de kabul edebilir, ancak varsayılan olarak, jq JSON varlıklarının akışını okur
(sayılar ve diğer değişmezler dahil) stdin. Boşluk yalnızca ayırmak için gereklidir
1 ve 2 gibi varlıklar ve doğru ve yanlış. Bir veya daha fazla Dosyaları belirtilebilir, ki
dava jq bunun yerine girdileri okuyacaktır.
The seçenekleri bölümünde açıklanmıştır ÇAĞRILAMAK JQ Bölüm; çoğunlukla girdi ve çıktı ile ilgilidirler
biçimlendirme. filtre jq dilinde yazılmıştır ve nasıl dönüştürüleceğini belirtir.
giriş dosyası veya belge.
FİLTRELER
Bir jq programı bir "filtre"dir: bir girdi alır ve bir çıktı üretir. Orada bir sürü
bir nesnenin belirli bir alanını çıkarmak veya bir sayıyı dönüştürmek için yerleşik filtreler
bir dize veya çeşitli diğer standart görevler.
Filtreler çeşitli şekillerde birleştirilebilir - bir filtrenin çıkışını
başka bir filtre veya bir filtrenin çıktısını bir dizide toplayın.
Bazı filtreler birden fazla sonuç üretir, örneğin tüm sonuçları üreten bir filtre vardır.
giriş dizisinin öğeleri. Bu filtreyi bir saniyeye bağlamak, ikinci filtreyi şu şekilde çalıştırır:
dizinin her bir elemanı. Genel olarak, döngüler ve yineleme ile yapılacak şeyler
diğer dillerde sadece filtreleri jq'de birbirine yapıştırarak yapılır.
Her filtrenin bir girişi ve bir çıkışı olduğunu unutmamak önemlidir. Hatta değişmezler
"merhaba" veya 42 gibi filtrelerdir - bir girdi alırlar ancak her zaman aynı değişmez değeri üretirler
çıktı. Toplama gibi iki filtreyi birleştiren işlemler genellikle aynı girdiyi besler.
hem ve sonuçları birleştirmek için. Böylece, bir ortalama alma filtresi uygulayabilirsiniz. eklemek / uzunluk
- giriş dizisini her ikisine de beslemek eklemek filtre ve uzunluk filtreleyin ve ardından gerçekleştirin
bölme.
Ama bu kendimizi aşar. :) Daha basit bir şeyle başlayalım:
ÇAĞRILAMAK JQ
jq filtreleri, bir JSON verisi akışında çalışır. jq girdisi bir dizi olarak ayrıştırılır
sağlanan filtreden birer birer geçirilen boşlukla ayrılmış JSON değerleri
zaman. Filtrenin çıkış(lar)ı yine bir dizi olarak standart çıkışa yazılır.
boşlukla ayrılmış JSON verileri.
Not: Kabuğun alıntı kurallarına dikkat etmek önemlidir. Genel bir kural olarak,
her zaman jq programından alıntı yapın (tek tırnaklı karakterlerle), çok fazla karakter olduğu için
jq'nin özel anlamı da kabuk meta karakterleridir. Örneğin, jq "foo" başarısız olacak
çoğu Unix mermisi, çünkü bu aynı olacaktır jq foo, bu genellikle başarısız olur
Çünkü foo is değil tanımlı. Windows komut kabuğunu (cmd.exe) kullanırken,
komut satırında verildiğinde jq programınızın etrafında çift tırnak kullanın (yerine -f
program dosyası seçeneği), ancak jq programındaki çift tırnakların ters eğik çizgiden kaçması gerekir.
Bazı komut satırlarını kullanarak jq'nin girdisini ve çıktısını nasıl okuyup yazacağını etkileyebilirsiniz.
seçenekleri:
· --versiyon:
jq versiyonunun çıktısını alın ve sıfır ile çıkın.
· --seq:
Kullan uygulama/json-seq JQ'nun girişindeki JSON metinlerini ayırmak için MIME tipi şeması
ve çıktı. Bu, önce bir ASCII RS (kayıt ayırıcı) karakterinin yazdırıldığı anlamına gelir.
çıktıdaki her değer ve her çıktıdan sonra bir ASCII LF (satır besleme) yazdırılır. Giriş
Ayrıştırılamayan JSON metinleri yoksayılır (ancak hakkında uyarılır), tümü atılır.
sonraki RS'ye kadar sonraki giriş. Bu ayrıca jq çıktısını
--seq seçeneği.
· --aktarım:
Girdiyi akış biçiminde ayrıştırın, yol ve yaprak değerleri dizilerini çıktılayın
(skaler ve boş diziler veya boş nesneler). Örneğin, "A" olur [[],"a"], ve
[[],"a",["b"]] olur [[0],[]], [[1 A"], ve [[1,0],"b"].
Bu, çok büyük girdileri işlemek için kullanışlıdır. Bunu şununla birlikte kullanın:
filtreleme ve azaltmak ve her biri için büyük girdileri aşamalı olarak azaltmak için sözdizimi.
· --höpürdet/-s:
Girdideki her JSON nesnesi için filtreyi çalıştırmak yerine girdinin tamamını okuyun
büyük bir diziye aktarın ve filtreyi yalnızca bir kez çalıştırın.
· --Ham girdi/-R:
Girdiyi JSON olarak ayrıştırmayın. Bunun yerine, metnin her satırı filtreye bir
sicim. ile birleştirilirse --höpürdet, daha sonra girdinin tamamı filtreye bir
tek uzun dize.
· --null-giriş/-n:
Herhangi bir girdiyi hiç okumayın! Bunun yerine, filtre kullanılarak bir kez çalıştırılır boş girdi olarak.
Bu, jq'yi basit bir hesap makinesi olarak kullanırken veya JSON verilerini oluşturmak için kullanışlıdır.
çizik.
· --kompakt-çıktı / -c:
Varsayılan olarak, jq, JSON çıktısını güzel yazdırır. Bu seçeneğin kullanılması daha fazla
bunun yerine her JSON nesnesini tek bir satıra koyarak kompakt çıktı.
· --tab:
Her girinti düzeyi için iki boşluk yerine bir sekme kullanın.
· --girinti n:
Girinti için verilen boşluk sayısını (8'den fazla değil) kullanın.
· --renk-çıktı / -C ve --tek renkli-çıktı / -M:
Varsayılan olarak jq, bir terminale yazılırsa renkli JSON çıktısı verir. zorlayabilirsin
kullanarak bir boruya veya dosyaya yazarken bile renk üretin -Cve ile rengi devre dışı bırakın -M.
· --ascii-çıktı / -a:
jq, giriş belirtilmiş olsa bile, genellikle ASCII olmayan Unicode kod noktalarını UTF-8 olarak çıkarır
bunları kaçış dizileri olarak ("\u03bc" gibi). Bu seçeneği kullanarak jq'yi
eşdeğeri ile değiştirilen her ASCII olmayan karakterle saf ASCII çıktısı üretin
kaçış dizisi.
· --tamponsuz
Her JSON nesnesi yazdırıldıktan sonra çıktıyı boşaltın (yavaş bir boru oluşturuyorsanız kullanışlıdır).
veri kaynağını jq'ya ve jq'nun çıktısını başka bir yere borulama).
· --sort-tuşları / -S:
Her nesnenin alanlarını tuşlarla sıralı bir şekilde çıktılayın.
· --ham-çıktı / -r:
Bu seçenekle, filtrenin sonucu bir dize ise doğrudan yazılacaktır.
tırnak işaretleri içeren bir JSON dizesi olarak biçimlendirilmek yerine standart çıktıya. Bu
jq filtrelerinin JSON tabanlı olmayan sistemlerle konuşmasını sağlamak için yararlı olabilir.
· --join-çıktı / -j:
Facebok sayfasını beğenin : -r ancak jq, her çıktıdan sonra yeni bir satır yazdırmaz.
· -f Dosya / --dosyadan Dosya:
awk´s -f seçeneği gibi bir komut satırından ziyade dosyadan filtreyi okuyun. Sen
ayrıca yorum yapmak için ´#´ kullanabilirsiniz.
· -Ldizin / -L rehber:
Başa ekle rehber modüller için arama listesine. Bu seçenek kullanılırsa hayır
yerleşik arama listesi kullanılır. Aşağıdaki modüller bölümüne bakın.
· -e / --çıkış durumu:
Son çıkış değerleri hiçbiri değilse, jq'nin çıkış durumunu 0'a ayarlar. yanlış ne de boş,
1 eğer son çıkış değeri ise yanlış or boşveya 4 geçerli bir sonuç hiç olmadıysa
üretilmiş. Normalde herhangi bir kullanım sorunu veya sistem hatası varsa jq 2 ile çıkar, 3
bir jq programı derleme hatası varsa veya jq programı çalışıyorsa 0.
· --arg isim değer:
Bu seçenek, önceden tanımlanmış bir değişken olarak jq programına bir değer iletir. jq çalıştırırsanız
ile --arg foo bar, Daha sonra $ foo programda mevcuttur ve değere sahiptir "Çubuk".
Bunu not et değer bir dize olarak ele alınacaktır, bu nedenle --arg foo 123 bağlayacak $ foo için "123".
· --argjson isim JSON-metin:
Bu seçenek, önceden tanımlanmış bir değişken olarak jq programına JSON kodlu bir değer iletir. Eğer
jq ile çalıştırıyorsun --argjson foo 123, Daha sonra $ foo programda mevcuttur ve
değer 123.
· --slurp dosyası değişken ismi Dosya:
Bu seçenek, adlandırılmış dosyadaki tüm JSON metinlerini okur ve bir diziyi bağlar.
verilen global değişkene ayrıştırılmış JSON değerleri. jq ile çalıştırırsanız --arg dosyası foo bar,
sonra $ foo programda mevcuttur ve elemanları şuna karşılık gelen bir diziye sahiptir.
adlı dosyadaki metinler bar.
· --arg dosyası değişken ismi Dosya:
Kullanmayın. Kullanmak --slurp dosyası yerine.
(Bu seçenek şuna benzer: --slurp dosyası, ancak dosyada yalnızca bir metin varsa, bu
kullanılır, aksi takdirde bir dizi metin kullanılır. --slurp dosyası.)
· --çalışma testleri [dosya adı]:
Verilen dosya veya standart girdideki testleri çalıştırır. Bu verilen son seçenek olmalı
ve önceki tüm seçenekleri dikkate almaz. Giriş, yorum satırlarından oluşur, boş
satırları ve program satırlarını takip eden bir giriş satırı, olduğu kadar çok çıktı satırı
beklenen (çıktı başına bir tane) ve sonlandırılan boş bir satır. Derleme hatası testleri
yalnızca "%%FAIL" içeren bir satırla başlayın, ardından aşağıdaki programı içeren bir satır
derleyin, ardından gerçekle karşılaştırmak için bir hata mesajı içeren bir satır.
Bu seçeneğin geriye doğru uyumsuz bir şekilde değişebileceği konusunda uyarınız.
KLASİK FİLTRELER
.
Mutlak en basit (ve en az ilginç) filtre .. Bu, onu alan bir filtredir.
girdi ve çıktı olarak değişmeden üretir.
jq varsayılan olarak tüm çıktıları güzel bir şekilde yazdırdığından, bu önemsiz program yararlı bir yol olabilir
JSON çıktısını biçimlendirme, diyelim ki, kıvırmak.
jq'.'
"Merhaba dünya!"
=> "Merhaba dünya!"
.foo, .foo.bar
En basit işe yarar filtre .foo. Bir JSON nesnesi (diğer adıyla sözlük veya karma) verildiğinde
girdi olarak, "foo" anahtarındaki değeri veya yoksa null değerini üretir.
Anahtar özel karakterler içeriyorsa, onu aşağıdaki gibi çift tırnak içine almanız gerekir.
bu: "foo$".
Formun bir filtresi .foo.bar eşdeğerdir .foo|.bar.
jq '.foo'
{"foo": 42, "bar": "daha az ilginç veri"}
=> 42
jq '.foo'
{"notfoo": doğru, "ayrıcanotfoo": yanlış}
=> boş
jq ´.["foo"]´
{"foo": 42}
=> 42
.foo?
Tıpkı .foo, ancak ne zaman bir hata bile vermez . bir dizi veya nesne değildir.
jq '.foo?'
{"foo": 42, "bar": "daha az ilginç veri"}
=> 42
jq '.foo?'
{"notfoo": doğru, "ayrıcanotfoo": yanlış}
=> boş
jq ´.["foo"]?´
{"foo": 42}
=> 42
jq `[.foo?]'
[1,2]
=> []
.[ ], .[2], .[10:15]
Ayrıca, aşağıdaki gibi sözdizimi kullanarak bir nesnenin alanlarını arayabilirsiniz. .["foo"] (.foo yukarıdaki bir
bunun kısa versiyonu). Anahtar bir tamsayıysa, bu diziler için de çalışır.
Diziler sıfır tabanlıdır (javascript gibi), yani . [2] dizinin üçüncü öğesini döndürür.
The .[10:15] sözdizimi, bir dizinin alt dizisini veya bir dizenin alt dizisini döndürmek için kullanılabilir.
tarafından döndürülen dizi .[10:15] dizin 5'daki öğeleri içeren 10 uzunluğunda olacaktır
(dahil) 15 indeksine (hariç). Her iki indeks de negatif olabilir (bu durumda
dizinin sonundan geriye doğru) veya atlanmıştır (bu durumda, başlangıç veya
dizinin sonu).
The . [2] sözdizimi, verilen dizindeki öğeyi döndürmek için kullanılabilir. Negatif endeksler
izin verilir, -1 son öğeye atıfta bulunur, -2 son öğeden sonraki öğeye atıfta bulunur,
ve benzerleri.
The .foo sözdizimi yalnızca basit anahtarlar için çalışır, yani tümü alfasayısal karakter olan anahtarlar.
.[ ] iki nokta üst üste ve nokta gibi özel karakterler içeren tuşlarla çalışır. İçin
örnek .["foo::bar"] ve .["foo.bar"] çalışırken çalışmak .foo::bar ve .foo.bar olmazdı.
The ? "operatör", aşağıdaki gibi dilim operatörüyle birlikte de kullanılabilir. .[10:15]?, hangi çıktılar
girdilerin dilimlenebilir olduğu değerler.
jq `.[0]'
[{"ad":"JSON", "iyi":doğru}, {"ad":"XML", "iyi":yanlış}]
=> {"ad":"JSON", "iyi":doğru}
jq `.[2]'
[{"ad":"JSON", "iyi":doğru}, {"ad":"XML", "iyi":yanlış}]
=> boş
jq `.[2:4]'
["a","b","c","d","e"]
=> ["c", "d"]
jq `.[2:4]'
"abcdefghi"
=> "cd"
jq'.[:3]'
["a","b","c","d","e"]
=> ["a", "b", "c"]
jq `.[-2:]'
["a","b","c","d","e"]
=> ["d", "e"]
jq `.[-2]'
[1,2,3]
=> 2
.[]
Eğer kullanıyorsanız .[indeks] sözdizimi, ancak dizini tamamen atlayın, geri dönecek herşey arasında
bir dizinin elemanları. Koşma .[] giriş ile [1,2,3] sayıları üç olarak üretecek
tek bir dizi yerine ayrı sonuçlar.
Bunu bir nesne üzerinde de kullanabilirsiniz ve bu, nesnenin tüm değerlerini döndürür.
jq `.[]'
[{"ad":"JSON", "iyi":doğru}, {"ad":"XML", "iyi":yanlış}]
=> {"ad":"JSON", "iyi":doğru}, {"ad":"XML", "iyi":yanlış}
jq `.[]'
[]
=>
jq `.[]'
{"a": 1, "b": 1}
=> 1, 1
.[]?
Facebok sayfasını beğenin : .[], ancak herhangi bir hata çıktısı alınmaz . bir dizi veya nesne değildir.
,
İki filtre virgülle ayrılırsa, giriş her ikisine de beslenir ve orada
çoklu çıktılar olacaktır: ilk olarak, sol ifade tarafından üretilen tüm çıktılar ve
sonra sağ tarafından üretilen tüm çıktılar. Örneğin, filtre .foo, .Kafe, üretir
hem "foo" alanları hem de "bar" alanları ayrı çıktılar olarak.
jq `.foo, .bar`
{"foo": 42, "bar": "başka bir şey", "baz": doğru}
=> 42, "başka bir şey"
jq ´.kullanıcı, .projeler[]´
{"user":"stedolan", "projeler": ["jq", "wikiflow"]}
=> "stedolan", "jq", "wikiflow"
jq `.[4,2]'
["a","b","c","d","e"]
=> "e", "c"
|
| operatör, soldakinin çıktısını/çıktılarını besleyerek iki filtreyi birleştirir.
sağdakinin girişi. Unix kabuğunun borusuyla hemen hemen aynı, eğer
buna alışmışsın.
Soldaki birden fazla sonuç veriyorsa, sağdaki için çalıştırılacaktır.
bu sonuçların her biri. Yani, ifade .[] | .foo her birinin "foo" alanını alır
giriş dizisinin öğesi.
jq ´.[] | .isim
[{"ad":"JSON", "iyi":doğru}, {"ad":"XML", "iyi":yanlış}]
=> "JSON", "XML"
TÜRLERİ VE DEĞERLER
jq, JSON ile aynı veri türleri kümesini destekler - sayılar, dizeler, booleanlar, diziler,
nesneler (JSON konuşmasında yalnızca dize tuşlarına sahip karmalardır) ve "null".
Boolean'lar, null, karakter dizileri ve sayılar javascript'tekiyle aynı şekilde yazılır. Tıpkı
jq'daki diğer her şey, bu basit değerler bir girdi alır ve bir çıktı üretir - 42 bir
bir girdi alan, onu yok sayan ve bunun yerine 42 döndüren geçerli jq ifadesi.
Dizi kas kütlesi inşasında ve - []
JSON'da olduğu gibi, [] olduğu gibi diziler oluşturmak için kullanılır [1,2,3]. Dizilerin öğeleri şunları yapabilir:
herhangi bir jq ifadesi olsun. Tüm ifadeler tarafından üretilen tüm sonuçlar toplanır
tek bir büyük diziye. Bilinen sayıda değerden bir dizi oluşturmak için kullanabilirsiniz.
(de olduğu gibi [.foo, .Çubuk, .baz]) veya bir filtrenin tüm sonuçlarını bir dizide "toplamak" (olarak
in [.itemler[].isim])
"," operatörünü anladıktan sonra, jq'nin dizi sözdizimine farklı bir şekilde bakabilirsiniz.
ışık: ifade [1,2,3] virgülle ayrılmış diziler için yerleşik bir sözdizimi kullanmıyorsa,
ama bunun yerine uyguluyor [] operatörü (sonuçları topla) ifadesine 1,2,3 (ki
üç farklı sonuç üretir).
bir filtreniz varsa X bu dört sonuç üretir, ardından ifade [X] üretecek
tek sonuç, dört elemanlı bir dizi.
jq ´[.kullanıcı, .projeler[]]´
{"user":"stedolan", "projeler": ["jq", "wikiflow"]}
=> ["stedolan", "jq", "wikiflow"]
nesneler - {}
JSON gibi, {} aşağıdaki gibi nesneler (diğer bir deyişle sözlükler veya karmalar) oluşturmak içindir: {"a": 42,
"B": 17}.
Tuşlar "mantıklı" ise (tüm alfabetik karakterler), tırnak işaretleri bırakılabilir.
Değer herhangi bir ifade olabilir (gerçi eğer öyleyse onu parantez içine almanız gerekebilir).
{} ifadesinin girişine uygulanan (tüm filtreleri unutmayın)
bir girdisi ve bir çıktısı vardır).
{foo: .bar}
JSON nesnesini üretecek {"foo": 42} JSON nesnesi verilirse {"bar":42, "baz":43}.
Bunu, bir nesnenin belirli alanlarını seçmek için kullanabilirsiniz: eğer girdi,
"user", "title", "id" ve "content" alanlarını ve sadece "user" ve "title" istediğiniz alanları
yazmak
{kullanıcı: .user, başlık: .title}
Bu çok yaygın olduğu için bir kısayol sözdizimi vardır: {kullanıcı, Başlık}.
İfadelerden biri birden çok sonuç veriyorsa, birden çok sözlük
üretilmiş. eğer giriş
{"user":"stedolan","titles":["JQ Primer", "Daha Fazla JQ"]}
sonra ifade
{kullanıcı, başlık: .titles[]}
iki çıktı üretecektir:
{"user":"stedolan", "title": "JQ Primer"}
{"user":"stedolan", "title": "Daha Fazla JQ"}
Anahtarın etrafına parantez koymak, bir ifade olarak değerlendirileceği anlamına gelir. İle
yukarıdakiyle aynı giriş,
{(.user): .titles}
üretir
{"stedolan": ["JQ Primer", "Daha Fazla JQ"]}
jq ´{kullanıcı, başlık: .titles[]}´
{"user":"stedolan","titles":["JQ Primer", "Daha Fazla JQ"]}
=> {"user":"stedolan", "title": "JQ Primer"}, {"user":"stedolan", "title": "Daha Fazla JQ"}
jq ´{(.kullanıcı): .titles}´
{"user":"stedolan","titles":["JQ Primer", "Daha Fazla JQ"]}
=> {"stedolan": ["JQ Primer", "Daha Fazla JQ"]}
İNŞAAT OPERATÖRLERİ VE FONKSİYONLAR
Bazı jq operatörü (örneğin, +) türlerine göre farklı şeyler yaparlar.
bağımsız değişkenler (diziler, sayılar vb.). Ancak, jq hiçbir zaman örtük tür dönüştürmeleri yapmaz. Eğer
bir nesneye bir dize eklemeye çalışırsanız, bir hata mesajı alırsınız ve sonuç olmaz.
Ek - +
Operatör + iki filtre alır, ikisini de aynı girdiye uygular ve
birlikte sonuçlar. "Ekleme"nin anlamı, ilgili türlere bağlıdır:
· Rakamlarla normal aritmetik tarafından eklenir.
· Diziler daha büyük bir diziye birleştirilerek eklenir.
· Dizeler daha büyük bir dizeye birleştirilerek eklenir.
· nesneler birleştirilerek, yani her ikisinden de tüm anahtar/değer çiftleri eklenerek eklenir.
nesneleri tek bir birleşik nesneye dönüştürür. Her iki nesne de aynı değer için bir değer içeriyorsa
tuşu, sağdaki nesne + kazanır. (Özyinelemeli birleştirme için * Şebeke.)
boş herhangi bir değere eklenebilir ve diğer değeri değiştirmeden döndürür.
jq `.a + 1`
{"a": 7}
=> 8
jq `.a + .b´
{"a": [1,2], "b": [3,4]}
=> [1,2,3,4]
jq ´.a + boş"
{"a": 1}
=> 1
jq `.a + 1`
{}
=> 1
jq ´{a: 1} + {b: 2} + {c: 3} + {a: 42}´
boş
=> {"a": 42, "b": 2, "c": 3}
Çıkarma - -
Sayılarda normal aritmetik çıkarmanın yanı sıra, - operatör dizilerde kullanılabilir
ikinci dizinin öğelerinin tüm oluşumlarını ilk diziden kaldırmak için.
jq `4 - .a'
{"a":3}
=> 1
jq'. - ["xml", "yaml"]´
["xml", "yaml", "json"]
=> ["json"]
Çarpma işlemi, bölünme, modülo - *, /, ve %
Bu infix operatörleri, iki sayı verildiğinde beklendiği gibi davranır. Sıfır artışlarla bölme
bir hata. x % y x modulo y'yi hesaplar.
Bir dizgeyi bir sayı ile çarpmak, o dizgenin birçok
kez. "x" * 0 üretir boş.
Bir dizgiyi başka birine bölmek, ikinciyi ayırıcı olarak kullanarak birinciyi böler.
İki nesneyi çarpmak onları özyinelemeli olarak birleştirir: bu toplama gibi çalışır, ancak her ikisi birden
nesneler aynı anahtar için bir değer içerir ve değerler nesnelerdir, ikisi birleştirilir
aynı strateji ile.
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}}´
boş
=> {"k": {"a": 0, "b": 2, "c": 3}}
jq'.[] | (1 / .)?'
[1,0, -1]
=> 1, -1
uzunluk
yerleşik işlev uzunluk çeşitli farklı değer türlerinin uzunluğunu alır:
· Uzunluğu dizi içerdiği Unicode kod noktalarının sayısıdır (ki
saf ASCII ise, bayt cinsinden JSON kodlu uzunluğuyla aynıdır).
· Bir uzunluğu dizi eleman sayısıdır.
· Bir uzunluğu nesne anahtar/değer çiftlerinin sayısıdır.
· Uzunluğu boş sıfırdır.
jq ´.[] | uzunluk´ [[1,2], "string", {"a":2}, null] => 2, 6, 1, 0
anahtarlar, key_sıralanmamış
yerleşik işlev anahtarlar, bir nesne verildiğinde, anahtarlarını bir dizide döndürür.
Anahtarlar, unicode kod noktası sırasına göre "alfabetik olarak" sıralanır. Bu bir sipariş değil
bu, herhangi bir dilde özellikle anlamlıdır, ancak bunun dil olduğuna güvenebilirsiniz.
yerel ayarlardan bağımsız olarak, aynı tuş grubuna sahip herhangi iki nesne için aynıdır.
Ne zaman anahtarlar bir dizi verildiğinde, o dizi için geçerli dizinleri döndürür: tamsayılar
0'dan uzunluk-1'e.
The key_sıralanmamış işlev tıpkı anahtarlar, ancak giriş bir nesneyse, tuşlar
sıralanmayacak, bunun yerine anahtarlar kabaca ekleme sırasına göre olacak.
jq 'anahtarları'
{"abc": 1, "abcd": 2, "Foo": 3}
=> ["Foo", "abc", "abcd"]
jq 'anahtarları'
[42,3,35]
=> [0,1,2]
sahip(anahtar)
yerleşik işlev vardır girdi nesnesinin verilen anahtara mı yoksa girdiye mi sahip olduğunu döndürür
dizi, verilen dizinde bir öğeye sahiptir.
sahip($anahtar) olup olmadığını kontrol etmekle aynı etkiye sahiptir. $ anahtarı döndürülen dizinin bir üyesidir
by anahtarlar, Rağmen vardır daha hızlı olacaktır.
jq ´map(has("foo"))´
[{"foo": 42}, {}]
=> [doğru, yanlış]
jq haritası(vardır(2)´
[[0,1], ["a","b","c"]]
=> [yanlış, doğru]
in
yerleşik işlev in giriş anahtarının verilen nesnede veya giriş dizininde olduğunu döndürür
verilen dizideki bir öğeye karşılık gelir. Bu, esasen, ters çevrilmiş bir versiyonudur.
vardır.
jq ´.[] | in({"foo": 42})´
["foo", "bar"]
=> doğru, yanlış
jq ´harita(in([0,1]))´
[2, 0]
=> [yanlış, doğru]
yol(yol_ifadesi)
Verilen yol ifadesinin dizi temsillerini şu şekilde verir: .. Çıktılar dizilerdir
dizeler (nesneler0 ve/veya sayılardaki anahtarlar (dizi indeksleri.
Yol ifadeleri, aşağıdaki gibi jq ifadeleridir. .a, Aynı zamanda .[]. iki tür yol vardır
ifadeler: tam olarak eşleşebilenler ve eşleşmeyenler. Örneğin, .ABC bir
tam eşleşme yolu ifadesi, .a[].b değil.
yol(tam_yol_ifadesi) yol ifadesinin dizi temsilini üretecek
içinde olmasa da ., Eğer . is boş veya bir dizi veya bir nesne.
yol(desen) eşleşen yolların dizi temsillerini üretecek model eğer
yollar var ..
Yol ifadelerinin normal ifadelerden farklı olmadığına dikkat edin. İfade
path(..|select(type=="boolean")) içindeki boole değerlerine giden tüm yolları verir ., ve sadece
o yollar.
jq ´yol(.a[0].b)´
boş
=> ["a",0,"b"]
jq ´[yol(..)]´
{"a":[{"b":1}]}
=> [[],["a"],["a",0],["a",0,"b"]]
del(yol_ifadesi)
yerleşik işlev del bir nesneden bir anahtarı ve ona karşılık gelen değeri kaldırır.
jq 'del(.foo)'
{"foo": 42, "bar": 9001, "baz": 42}
=> {"bar": 9001, "baz": 42}
jq 'del(.[1, 2])'
["foo", "bar", "baz"]
=> ["foo"]
girişler, girişlerden_girişler, with_entries
Bu işlevler, bir nesne ile bir dizi anahtar-değer çifti arasında dönüşüm yapar. Eğer to_entries
bir nesne iletilir, ardından her biri için k: v girişte giriş, çıkış dizisi şunları içerir
{"anahtar": k, "değer": v}.
from_entries ters dönüşüm yapar ve with_entries(foo) için bir kısayol
to_entries | harita(foo) | from_entries, tüm tuşlara bazı işlemler yapmak için kullanışlıdır ve
bir nesnenin değerleri. from_entries anahtar, Anahtar, Ad, değer ve Değeri anahtar olarak kabul eder.
jq 'to_girişler'
{"a": 1, "b": 2}
=> [{"anahtar":"a", "değer":1}, {"anahtar":"b", "değer":2}]
jq 'from_entries'
[{"anahtar":"a", "değer":1}, {"anahtar":"b", "değer":2}]
=> {"a": 1, "b": 2}
jq ´with_entries(.key |= "KEY_" + .)´
{"a": 1, "b": 2}
=> {"KEY_a": 1, "KEY_b": 2}
seç(boolean_expression)
Bu fonksiyon seç(foo) girdisini değişmeden üretirse foo bu girdi için true değerini döndürür,
ve aksi halde çıktı üretmez.
Listeleri filtrelemek için kullanışlıdır: [1,2,3] | harita(seç(. >= 2)) sana vereceğim [2,3].
jq ´harita(seç(. >= 2))´
[1,5,3,0,7]
=> [5,3,7]
jq ´.[] | select(.id == "saniye")´
[{"id": "birinci", "değer": 1}, {"id": "ikinci", "değer": 2}]
=> {"id": "saniye", "val": 2}
diziler, nesneler, yinelenebilir, boolean, sayılar, normaller, sonlular, Teller, boş değerler, değerler,
skalerler
Bu yerleşikler yalnızca diziler, nesneler, yinelenebilirler (diziler veya
nesneler), boole'ler, sayılar, normal sayılar, sonlu sayılar, dizeler, boş, boş olmayan
sırasıyla değerler ve yinelenemeyenler.
jq ´.[]|sayılar´
[[],{},1,"foo",null,true,false]
=> 1
boş
boş sonuç döndürmez. Hiç yok. bile değil boş.
Ara sıra işe yarar. ihtiyacın olursa anlarsın :)
jq ´1, boş, 2´
boş
=> 1, 2
jq ´[1,2,boş,3]´
boş
=> [1,2,3]
hata(İleti)
Bir hata üretir, tıpkı .a null ve nesneler dışındaki değerlere uygulanır, ancak
hata değeri olarak verilen mesajla.
$__loc__
Dosya adı ve satır numarası ile bir "dosya" anahtarı ve bir "satır" anahtarı ile bir nesne üretir
nerede $__loc__ değerler olarak ortaya çıkar.
jq ´try error("\($__loc__)") yakalama .´
boş
=> "{\"dosya\":\" \",\"satır 1}"
harita(x), harita_değerleri(x)
Herhangi bir filtre için x, harita(x) giriş dizisinin her bir öğesi için bu filtreyi çalıştıracak ve
çıktıları yeni bir dizi üretin. harita(.+1) bir dizinin her bir öğesini artıracaktır
numaraları.
Benzer şekilde, harita_değerleri(x) bu filtreyi her eleman için çalıştıracak, ancak bir
bir nesne geçirildiğinde nesne.
harita(x) eşdeğerdir [.[] | x]. Aslında bu böyle tanımlanır. Benzer şekilde,
harita_değerleri(x) olarak tanımlanır .[] |= x.
jq 'harita(.+1)'
[1,2,3]
=> [2,3,4]
jq 'harita_değerleri(.+1)'
{"a": 1, "b": 2, "c": 3}
=> {"a": 2, "b": 3, "c": 4}
yollar, yollar(düğüm_filtresi), yaprak_yolları
yolları girişindeki tüm öğelerin yollarını çıkarır (çıktısını vermemesi dışında)
temsil eden boş liste. kendisi).
yollar(f) için herhangi bir değere giden yolları çıktı olarak verir. f doğru. Yani, yollar(sayılar)
tüm sayısal değerlere giden yolları verir.
yaprak_yolları takma adıdır yollar(skaler); yaprak_yolları is önerilmiyor ve içinde kaldırılacak
sonraki büyük sürüm.
jq ´[yollar]´
[1,[[],{"a":2}]]
=> [[0],[1],[1,0],[1,1],[1,1,"a"]]
jq ´[yollar(skaler)]´
[1,[[],{"a":2}]]
=> [[0],[1,1,"a"]]
eklemek
Filtre eklemek bir diziyi girdi olarak alır ve çıktı olarak dizinin elemanlarını üretir.
birlikte eklendi. Bu, türlerine bağlı olarak özetlenmiş, birleştirilmiş veya birleştirilmiş anlamına gelebilir.
giriş dizisinin öğeleri - kurallar, + Şebeke
(Yukarıda tarif edilen).
Giriş boş bir dizi ise, eklemek İade boş.
jq 'ekle'
["ABC"]
=> "abc"
jq 'ekle'
[1, 2, 3]
=> 6
jq 'ekle'
[]
=> boş
hiç, herhangi(koşul), herhangi(jeneratör; şart)
Filtre herhangi girdi olarak bir dizi boole değeri alır ve üretir gerçek çıktı olarak eğer
dizinin herhangi bir elemanı gerçek.
Giriş boş bir dizi ise, herhangi İade yanlış.
The herhangi bir(koşul) form, verilen koşulu giriş dizisinin öğelerine uygular.
The herhangi(jeneratör; şart) form, verilen koşulu tüm çıktılara uygular.
verilen jeneratör
jq 'herhangi biri'
[doğru yanlış]
=> doğru
jq 'herhangi biri'
[yanlış, yanlış]
=> yanlış
jq 'herhangi biri'
[]
=> yanlış
tüm, hepsi(koşul), hepsi(jeneratör; şart)
Filtre herşey girdi olarak bir dizi boole değeri alır ve üretir gerçek çıktı olarak eğer
dizinin tüm elemanları gerçek.
The hepsi(koşul) form, verilen koşulu giriş dizisinin öğelerine uygular.
The hepsi(jeneratör; şart) form, verilen koşulu tüm çıktılara uygular.
verilen jeneratör
Giriş boş bir dizi ise, herşey İade gerçek.
jq 'hepsi'
[doğru yanlış]
=> yanlış
jq 'hepsi'
[doğru doğru]
=> doğru
jq 'hepsi'
[]
=> doğru
[Gereklilikler 1.5] düzleştirmek, düzleştir(derinlik)
Filtre düzleştirmek girdi olarak iç içe dizilerden oluşan bir dizi alır ve içinde düz bir dizi üretir.
orijinal dizi içindeki tüm diziler, değerleriyle özyinelemeli olarak değiştirilmiştir.
Kaç tane iç içe yerleştirme düzeyinin düzleştirileceğini belirtmek için ona bir argüman iletebilirsiniz.
düzleştirmek(2) gibi düzleştirmek, ancak yalnızca iki seviye derinliğe kadar gidiyor.
jq 'düzleştir'
[1, [2], [[3]]]
=> [1, 2, 3]
jq'düzleştirmek(1)'
[1, [2], [[3]]]
=> [1, 2, [3]]
jq 'düzleştir'
[[]]
=> []
jq 'düzleştir'
[{"foo": "bar"}, [{"foo": "baz"}]]
=> [{"foo": "bar"}, {"foo": "baz"}]
aralık (en fazla), aralık aralık
The menzil fonksiyon bir dizi sayı üretir. aralık(4;10) 6'ten 4 sayı üretir
(dahil) ila 10 (hariç). Rakamlar ayrı çıktılar olarak üretilir. Kullanmak
[aralık(4;10)] dizi olarak bir aralık elde etmek için.
Bir bağımsız değişken formu, 0'dan verilen sayıya kadar bir artışla sayılar üretir.
1.
İki bağımsız değişken formu, aşağıdakilerden sayılar üretir: itibaren için kadar 1'lik artışla.
Üç bağımsız değişken formu sayılar üretir itibaren için kadar bir artışla by.
jq 'aralık(2;4)'
boş
=> 2, 3
jq ´[aralık(2;4)]´
boş
=> [2,3]
jq'[menzil(4)]´'
boş
=> [0,1,2,3]
jq ´[aralık(0;10;3)]´
boş
=> [0,3,6,9]
jq ´[aralık(0;10;-1)]´
boş
=> []
jq ´[aralık(0;-5;-1)]´
boş
=> [0,-1,-2,-3,-4]
zemin
The zemin işlev, sayısal girişinin tabanını döndürür.
jq 'zemin'
3.14159
=> 3
sqrt
The sqrt işlev, sayısal girdisinin karekökünü döndürür.
jq 'sqrt'
9
=> 3
numaraya
The numaraya fonksiyon girdisini sayı olarak ayrıştırır. Doğru biçimlendirilmiş dönüştürecek
dizeleri sayısal eşdeğerlerine çevirin, sayıları olduğu gibi bırakın ve diğer tüm işlemlerde bir hata verin.
giriş.
jq ´.[] | numaraya
[1, "1"]
=> 1, 1
dizginlemek
The dizginlemek işlev, girdisini bir dize olarak yazdırır. Dizeler değişmeden bırakılır ve tümü
diğer değerler JSON kodludur.
jq ´.[] | tostring'
[1, "1", [1]]
=> "1", "1", "[1]"
tip
The tip işlev, bağımsız değişkeninin türünü, boş olanlardan biri olan bir dize olarak döndürür,
boolean, sayı, dize, dizi veya nesne.
jq 'harita(tip)'
[0, false, [], {}, null, "merhaba"]
=> ["sayı", "boolean", "dizi", "nesne", "boş", "dize"]
sonsuz, Hayır, sonsuz isnan, sonsuz normaldir
Bazı aritmetik işlemler, sonsuzlar ve "sayı değil" (NaN) değerleri verebilir. bu
sonsuz yerleşik dönüşler gerçek girişi sonsuz ise. bu isnan yerleşik dönüşler gerçek
girişi bir NaN ise. bu sonsuz yerleşik pozitif bir sonsuz değer döndürür. bu nan
yerleşik bir NaN döndürür. bu normaldir Yerleşik, girişi normal bir sayıysa true değerini döndürür.
Sıfıra bölmenin bir hata oluşturduğunu unutmayın.
Şu anda sonsuzluklar, NaN'ler ve alt normaller üzerinde çalışan çoğu aritmetik işlem,
hataları yükselt.
jq ´.[] | (sonsuz * .) < 0´
[-on bir]
=> doğru, yanlış
jq ´sonsuz, nan | tip
boş
=> "sayı", "sayı"
çeşit, sort_by(yol_ifadesi)
The tür işlevler, bir dizi olması gereken girdisini sıralar. Değerler şu şekilde sıralanır:
aşağıdaki sıra:
· boş
· yanlış
· gerçek
· sayılar
· dizeler, alfabetik sırayla (unicode kod noktası değerine göre)
· diziler, sözcük sırasına göre
· nesneler
Nesnelerin sıralaması biraz karmaşıktır: önce nesneler karşılaştırılarak karşılaştırılır.
anahtar kümeleri (sıralanmış sırada diziler olarak) ve anahtarları eşitse değerler
anahtar anahtar karşılaştırıldı.
tür bir nesnenin belirli bir alanına göre veya herhangi bir jq filtresi uygulayarak sıralamak için kullanılabilir.
sıralama_by(foo) sonucunu karşılaştırarak iki öğeyi karşılaştırır foo her eleman üzerinde.
jq 'sıralama'
[8,3,boş,6]
=> [boş,3,6,8]
jq 'sıralama ölçütü(.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(yol_ifadesi)
group_by(.foo) girdi olarak bir dizi alır, aynı diziye sahip öğeleri gruplandırır .foo alan
ayrı dizilere ayırır ve bu dizilerin tümünü daha büyük bir dizinin öğeleri olarak üretir,
değerine göre sıralanır. .foo alan.
Yerine yalnızca bir alan erişimi değil, herhangi bir jq ifadesi kullanılabilir. .foo. sıralama
sipariş, tarif edilenle aynıdır tür yukarıdaki fonksiyon.
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}]]
dakika, max, min_by(yol_ifadesi), max_by(yol_ifadesi)
Giriş dizisinin minimum veya maksimum öğesini bulun.
The min_by(yol_ifadesi) ve max_by(yol_ifadesi) işlevler, belirli bir
incelenecek alan veya özellik, örn. min_by(.foo) en küçük olan nesneyi bulur foo
alan.
jq 'min'
[5,4,2,7]
=> 2
jq 'max_by(.foo)'
[{"foo":1, "bar":14}, {"foo":2, "bar":3}]
=> {"foo":2, "çubuk":3}
benzersiz, benzersiz_by(yol_ifadesi)
The benzersiz işlev bir diziyi girdi olarak alır ve aynı öğelerden oluşan bir dizi üretir.
kopyalar kaldırılarak sıralı düzen.
The benzersiz_by(yol_ifadesi) fonksiyon tarafından elde edilen her değer için sadece bir eleman tutacaktır.
argümanı uygulamak. Her bir elemandan bir eleman alarak bir dizi yapmak gibi düşünün.
tarafından üretilen grup Grup.
jq 'benzersiz'
[1,2,5,3,5,3,1,3]
=> [1,2,3,5]
jq 'benzersiz_by(.foo)'
[{"foo": 1, "bar": 2}, {"foo": 1, "bar": 3}, {"foo": 4, "bar": 5}]
=> [{"foo": 1, "bar": 2}, {"foo": 4, "bar": 5}]
jq 'benzersiz_by(uzunluk)'
["tıknaz", "pastırma", "yavru kedi", "ağustosböceği", "kuşkonmaz"]
=> ["pastırma", "tıknaz", "kuşkonmaz"]
ters
Bu işlev bir diziyi tersine çevirir.
jq 'ters'
[1,2,3,4]
=> [4,3,2,1]
içerir(eleman)
Filtre içerir(b) b tamamen girdi içindeyse true üretecektir. A
B dizesi, B, A'nın bir alt dizesiyse, A dizesinde bulunur.
B'deki tüm öğeler A'daki herhangi bir öğede yer alıyorsa bir A dizisi. Bir B nesnesi
B'deki tüm değerler A'daki değerde yer alıyorsa, nesne A'da bulunur.
aynı anahtar. Diğer tüm türlerin, eşit olmaları durumunda birbirini içerdiği varsayılır.
jq ´içerir("bar")´
"foobar"
=> doğru
jq ´içerir(["baz", "bar"])´
["foobar", "foobaz", "blarp"]
=> doğru
jq ´içerir(["bazzzzz", "bar"])´
["foobar", "foobaz", "blarp"]
=> yanlış
jq ´içerir({foo: 12, bar: [{barp: 12}]})´
{"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]}
=> doğru
jq ´içerir({foo: 12, bar: [{barp: 15}]})´
{"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]}
=> yanlış
indeks(ler)
içindeki indeksleri içeren bir dizi çıktısı verir. . nerede s meydana gelmek. Giriş bir dizi olabilir,
hangi durumda s bir dizi ise, dizin çıktısı, içindeki tüm öğelerin olduğu dizinler olacaktır. .
bunlarla eşleşmek s.
jq ´indeksler(", ")´
"a,b, cd, efg, hijk"
=> [3,7,12]
jq'endeksleri(1)'
[0,1,2,1,3,1,4]
=> [1,3,5]
jq 'endeksler([1,2])'
[0,1,2,3,1,4,2,5,1,2,6,7]
=> [1,8]
indeks(ler), binek(ler)
İlk dizinin çıktısını verir (indeks) veya son (hayvan) meydana gelmesi s girişte.
jq ´indeks(", ")´
"a,b, cd, efg, hijk"
=> 3
jq ´index(", ")´
"a,b, cd, efg, hijk"
=> 12
içeride
Filtre içeride(b) girdi tamamen b içinde yer alıyorsa true üretecektir. o
aslında, ters bir versiyonudur içeren.
jq ´inside("foobar")´
"Çubuk"
=> doğru
jq ´inside(["foobar", "foobaz", "blarp"])´
["baz", "bar"]
=> doğru
jq ´inside(["foobar", "foobaz", "blarp"])´
["bazzzzz", "bar"]
=> yanlış
jq ´inside({"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]})´
{"foo": 12, "bar": [{"barp": 12}]}
=> doğru
jq ´inside({"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]})´
{"foo": 12, "bar": [{"barp": 15}]}
=> yanlış
startwith(str)
Çıkışlar gerçek Eğer . verilen dize argümanıyla başlar.
jq ´[.[]|startswith("foo")]´
["fo", "foo", "barfoo", "foobar", "barfoob"]
=> [yanlış, doğru, yanlış, doğru, yanlış]
biter(str)
Çıkışlar gerçek Eğer . verilen dize argümanıyla biter.
jq ´[.[]|("foo")]´ ile biter
["foobar", "barfoo"]
=> [yanlış, doğru]
kombinasyonlar kombinasyonlar(n)
Girdi dizisindeki dizilerin öğelerinin tüm kombinasyonlarının çıktısını verir. eğer verilirse
tartışma n, tüm kombinasyonları çıkarır n giriş dizisinin tekrarları.
jq 'kombinasyonları'
[[1,2], [3, 4]]
=> [1, 3], [1, 4], [2, 3], [2, 4]
jq'kombinasyonları(2)'
[0, 1]
=> [0, 0], [0, 1], [1, 0], [1, 1]
ltrimstr(dz)
Girdisini, onunla başlıyorsa, verilen önek dizgisi kaldırılmış olarak çıkarır.
jq ´[.[]|ltrimstr("foo")]´
["fo", "foo", "barfoo", "foobar", "afoo"]
=> ["fo","","barfoo","bar","afoo"]
rtrimstr(str)
Girdisini, kendisiyle bitiyorsa, verilen son ek dizgisi kaldırılmış olarak çıkarır.
jq ´[.[]|rtrimstr("foo")]´
["fo", "foo", "barfoo", "foobar", "aptal"]
=> ["fo"","bar","foobar","aptal"]
patlamak
Bir girdi dizesini, dizenin kod noktası sayılarından oluşan bir diziye dönüştürür.
jq 'patlama'
"foobar"
=> [102,111,111,98,97,114]
içeriye patlamak
Patlamanın tersi.
jq 'patlama'
[65, 66, 67]
=> "ABC"
bölmek
Ayırıcı bağımsız değişkende bir giriş dizesini böler.
jq ´split(", ")´
"a, b, c, d, e,"
=> ["a","b,c,d","e",""]
katılmak(str)
Argümanı ayırıcı olarak kullanarak girdi olarak verilen öğe dizisini birleştirir. O
tersi bölmek: yani koşmak split("foo") | katıl("foo") herhangi bir giriş dizesi üzerinde
söz konusu giriş dizesini döndürür.
jq ´birleştir(", ")´
["a","b,c,d","e"]
=> "a, b,c,d,e"
ascii_downcase, ascii_upcase
Giriş dizesinin alfabetik karakterleri (az ve AZ) biçimine dönüştürülmüş bir kopyasını yayınlayın.
belirtilen durum.
while(koşul; Güncelleme)
The while(koşul; Güncelleme) işlevi, bir güncellemeyi art arda uygulamanıza izin verir. . kadar cond
yanlış.
Bunu not et while(koşul; Güncelleme) dahili olarak özyinelemeli bir jq işlevi olarak tanımlanır. özyinelemeli
içinde aramalar süre durumunda ek bellek tüketmez güncelleştirme en fazla bir tane üretir
Her girdi için çıktı Aşağıdaki gelişmiş konulara bakın.
jq ´[while(.<100; .*2)]´
1
=> [1,2,4,8,16,32,64]
kadar(koşul; sonraki)
The kadar(koşul; sonraki) işlevi, ifadeyi tekrar tekrar uygulamanıza olanak tanır sonraki,
başlangıçta . sonra kendi çıktısına kadar cond doğru. Örneğin, bu kullanılabilir
faktöriyel bir işlevi uygulamak için (aşağıya bakın).
Bunu not et kadar(koşul; sonraki) dahili olarak özyinelemeli bir jq işlevi olarak tanımlanır. özyinelemeli
içinde aramalar a kadar() durumunda ek bellek tüketmez sonraki en fazla bir tane üretir
Her girdi için çıktı Aşağıdaki gelişmiş konulara bakın.
jq ´[.,1]|until(.[0] < 1; [.[0] - 1, .[1] * .[0]])|.[1]´
4
=> 24
özyineleme(f), yineleme, yineleme(f; şart), yineleme_aşağı
The özyineleme(f) işlev, özyinelemeli bir yapı içinde arama yapmanızı ve
her seviyeden ilginç veriler. Girişinizin bir dosya sistemini temsil ettiğini varsayalım:
{"ad": "/", "çocuklar": [
{"isim": "/çöp Kutusu", "çocuklar": [
{"isim": "/bin/ls", "çocuklar": []},
{"isim": "/ Bin / sh", "çocuklar": []}]},
{"isim": "/ Ana Sayfa", "çocuklar": [
{"isim": "/home/stephen", "çocuklar": [
{"ad": "/home/stephen/jq", "çocuklar": []}]}]}]}
Şimdi mevcut tüm dosya adlarını çıkarmak istediğinizi varsayalım. geri alman gerekiyor . İsim,
.children[].isim, .children[].children[].isim, ve benzeri. Bunu şununla yapabilirsiniz:
recurse(.children[]) | .isim
Argümansız çağrıldığında, recurse eşdeğerdir özyineleme(.[]?).
özyineleme(f) ile aynı yineleme(f; . != boş) ve endişe duymadan kullanılabilir
özyineleme derinliği.
yineleme(f; şart) yayan bir jeneratördür. ve sonra sırayla yayar
.|f, .|f|f, .|f|f|f, ... hesaplanan değer koşulu karşıladığı sürece. İçin
örneğin, tüm tamsayıları oluşturmak için, en azından prensipte, yazılabilir özyineleme(.+1;
doğru).
Miras nedenlerle, yineleme_aşağı aramak için bir takma ad olarak var recurse argümanlar olmadan.
Bu takma ad kabul edilir önerilmiyor ve bir sonraki ana sürümde kaldırılacaktır.
Yinelemeli çağrılar recurse ne zaman ek bellek tüketmez f üretir
çoğu her girdi için tek bir çıktı.
jq `recurse(.foo[])'
{"foo":[{"foo": []}, {"foo":[{"foo":[]}]}]}
=> {"foo":[{"foo":[]},{"foo":[{"foo":[]}]}]}, {"foo":[]}, {"foo": [{"foo":[]}]}, {"foo":[]}
jq 'yineleme'
{"a":0,"b":[1]}
=> {"a":0,"b":[1]}, 0, [1], 1
jq ´recurse(. * .; . < 20)´
2
=> 2, 4, 16
..
Kısa el için recurse argümanlar olmadan. Bunun XPath'e benzemesi amaçlanmıştır. //
Şebeke. Bunu not et ..ve çalışmıyor; kullanmak ..|bir Bunun yerine. Aşağıdaki örnekte kullandığımız
..|.a? "a" nesne anahtarlarının tüm değerlerini "aşağıda" bulunan herhangi bir nesnede bulmak için ..
jq `..|.a?'
[[{"a":1}]]
=> 1
env
jq'nin ortamını temsil eden bir nesne çıktısı verir.
jq 'env.PAGER'
boş
=> "daha az"
aktarmak
Olası bir pürüzlü matrisi (bir dizi dizi) transpoze edin. Satırlar boş değerlerle doldurulur, böylece
sonuç her zaman dikdörtgendir.
jq 'devrimi'
[[1], [2,3]]
=> [[1,2],[boş,3]]
ara(x)
bsearch(x) girdi dizisinde x için ikili arama yapar. Giriş sıralanırsa ve
x içeriyorsa, bsearch(x) dizideki dizinini döndürür; aksi takdirde, eğer dizi
sıralandığında (-1 - ix) döndürür, burada ix bir ekleme noktasıdır, öyle ki dizi
x'in ix'e eklenmesinden sonra hala sıralanabilir. Dizi sıralanmamışsa, bsearch(x)
muhtemelen ilgilenilmeyen bir tamsayı döndürür.
jq'arama(0)'
[0,1]
=> 0
jq'arama(0)'
[1,2,3]
=> -1
jq'arama(4) $ix olarak | eğer $ix < 0 ise .[-(1+$ix)] = 4 else . son
[1,2,3]
=> [1,2,3,4]
dizi interpolasyon - \(foo)
Bir dizgenin içinde, ters eğik çizgiden sonra parantez içine bir ifade koyabilirsiniz. Ne olursa olsun
ifade dönüşleri dizeye enterpolasyonlu olacaktır.
jq ´"Giriş, \(.+1) değerinden bir küçük olan \(.) idi"´
42
=> "Giriş 42'ydi, bu da 43'ten bir eksik"
dönüştürmek / noktasından JSON
The tojson ve fromjson'dan yerleşikler, değerleri JSON metinleri olarak döker veya JSON metinlerini
sırasıyla değerler. tojson yerleşiği, tostring dönüşlerinde tostring'den farklıdır
dizeler değiştirilmemişken, tojson dizeleri JSON dizeleri olarak kodlar.
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"]]
oluşturulan dizeleri ve kaçan
The @foo sözdizimi, URL'ler oluşturmak için yararlı olan dizeleri biçimlendirmek ve kaçmak için kullanılır,
HTML veya XML gibi bir dilde belgeler vb. @foo filtre olarak kullanılabilir
kendi başına, olası kaçışlar şunlardır:
@Metin:
aramalar dizginlemek, ayrıntılar için bu işleve bakın.
@json:
Girişi JSON olarak serileştirir.
@html:
Karakterleri eşleyerek HTML/XML çıkışını uygular <>&´" onların varlığına
eşdeğerleri <, >, &, ', ".
@uri:
Tüm ayrılmış URI karakterlerini bir %XX sıra.
@csv:
Girdi bir dizi olmalıdır ve çift tırnak işaretiyle CSV olarak işlenir.
dizeler ve tekrardan kaçan tırnak işaretleri.
@tsv:
Girdi bir dizi olmalıdır ve TSV (sekmeyle ayrılmış değerler) olarak işlenir. Her biri
giriş dizisi tek bir satır olarak yazdırılacaktır. Alanlar tek bir sekme ile ayrılır
(ascii 0x09). Girdi karakterleri satır besleme (ascii 0x0a), satır başı (ascii
0x0d), sekme (ascii 0x09) ve ters eğik çizgi (ascii 0x5c) çıkış olarak çıkış olacak
dizileri \n, \r, \t, \\ respectivamente.
@sh:
Giriş, bir POSIX kabuğu için bir komut satırında kullanıma uygun olarak çıkışlıdır. Eğer
girdi bir dizidir, çıktı boşlukla ayrılmış bir dizi dizi olacaktır.
@base64:
Giriş, RFC 64 tarafından belirtildiği gibi base4648'e dönüştürülür.
Bu sözdizimi, dize enterpolasyonu ile kullanışlı bir şekilde birleştirilebilir. takip edebilirsiniz
@foo bir dize değişmezi ile belirteç. Dize değişmezinin içeriği değil kaçmak.
Ancak, bu dize değişmezi içinde yapılan tüm enterpolasyonlardan kaçınılacaktır. Örneğin,
@uri "https://www.google.com/search?q=\(.search)"
girdi için aşağıdaki çıktıyı üretecek {"ara":"ne is jq?"}:
"https://www.google.com/search?q=what%20is%20jq%3F"
URL'deki eğik çizgi, soru işareti vb. öğelerin, birer parçası oldukları için kaçılmadığına dikkat edin.
dize değişmezinin.
jq'@html'
"Bu, x < y ise çalışır"
=> "Bu, x < y ise çalışır"
jq ´@sh "echo \(.)"´
"O'Hara'nın Ale"
=> "Echo ´O´\\´´Hara´\\´´´s Ale´"
Tarih
jq, bazı yüksek düzeyli ve düşük düzeyli verilerle bazı temel tarih işleme işlevleri sağlar.
yerleşikler. Her durumda, bu yerleşikler yalnızca UTC'deki zamanla ilgilenir.
The tarihiso8601'den yerleşik, ISO 8601 biçimindeki tarih saatlerini birkaç saniyeye ayrıştırır
Unix döneminden beri (1970-01-01T00:00:00Z). bu bugüniso8601 yerleşik tersini yapar.
The itibaren yerleşik tarih saat dizelerini ayrıştırır. Şu anda itibaren yalnızca ISO 8601'i destekler
tarih saat dizeleri, ancak gelecekte tarih saat dizelerini daha fazla ayrıştırmaya çalışacak
biçimleri.
The bugüne kadar yerleşik için bir takma addır bugüniso8601.
The şimdi yerleşik, Unix döneminden bu yana saniye cinsinden geçerli saati verir.
C-kütüphane zaman işlevlerine yönelik düşük seviyeli jq arayüzleri de sağlanır: strp zamanı,
strftime, mktime, ve gm zamanı. için ana bilgisayar işletim sisteminizin belgelerine bakın.
tarafından kullanılan biçim dizeleri strp zamanı ve strftime. Not: bunlar mutlaka kararlı değildir
jq'deki arabirimler, özellikle yerelleştirme işlevleriyle ilgili olarak.
The gm zamanı yerleşik, Unix döneminden bu yana birkaç saniye tüketir ve "bozuk
kapalı kalma süresi" süreyi temsil eden bir sayı dizisi olarak temsil eder (bu sırayla):
yıl, ay (sıfır tabanlı), ayın günü, günün saati, günün dakikası
saat, dakikanın saniyesi, haftanın günü ve yılın günü -- hepsi
aksi belirtilmedikçe tek tabanlı.
The mktime yerleşik, zaman çıktısının "bozuk zaman" temsillerini tüketir gm zamanı
ve strp zamanı.
The dizi zamanı(fmt) yerleşik, eşleşen giriş dizelerini ayrıştırır fmt argüman. çıktı
tarafından tüketilen "bozuk zaman" temsili gm zamanı ve çıkış tarafından mktime.
The strftime(fmt) yerleşik biçimleri verilen biçime sahip bir zaman.
için biçim dizeleri strp zamanı ve strftime tipik C kitaplığında açıklanmıştır
belgeler. ISO 8601 datetime için biçim dizgisi "%Y-%m-%dT%H:%M:%SZ".
jq, bazı sistemlerde bu tarih işlevinin bir kısmını veya tamamını desteklemeyebilir.
jq 'tarihten itibaren'
"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
ŞARTLILAR VE KARŞILAŞTIRMALAR
==, !=
'a == b' ifadesi, a ve b'nin sonucu eşitse (yani,
eşdeğer JSON belgelerini temsil ediyorlarsa) ve aksi takdirde 'yanlış'. Özellikle, dizeler
asla sayılara eşit kabul edilmez. Javascript'ten geliyorsanız, jq´s == gibidir
Javascript´s === - değerleri yalnızca aynı türe sahip olduklarında eşit olarak kabul etmek
aynı değer.
!= "eşit değildir" ve ´a != b´, ´a == b´nin tersi değerini döndürür
jq ´.[] == 1´
[1, 1.0, "1", "muz"]
=> doğru, doğru, yanlış, yanlış
if-then-else
if A sonra B başka C son aynı şekilde hareket edecek B if A false dışında bir değer üretir veya
null, ancak aynı şekilde davranın C aksi takdirde.
Yanlış veya boş olup olmadığını kontrol etmek, Javascript'te bulunandan daha basit bir "doğruluk" kavramıdır.
veya Python, ancak bu, bazen durum hakkında daha açık olmanız gerektiği anlamına gelir.
istediğiniz: örneğin bir dizgenin boş olup olmadığını test edemezsiniz. if . İsim sonra A başka B son,
daha çok şeye ihtiyacın olacak if (.isim | uzunluk) > 0 sonra A başka B son yerine.
A koşulu birden fazla sonuç veriyorsa, bunlardan herhangi biri varsa "doğru" kabul edilir.
sonuçlar yanlış veya boş değil. Sıfır sonuç veriyorsa yanlış kabul edilir.
Bir if kullanılıyorsa daha fazla vaka eklenebilir elif A sonra B sözdizimi.
jq 'eğer . == 0 o zaman
"sıfır" elif. == 1 sonra "bir" başka "çok" biter´ 2 => "çok"
>, >=, <=, <
karşılaştırma operatörleri >, >=, <=, < sol argümanlarının şundan büyük olup olmadığını döndür,
haklı argümanlarından daha büyük veya ona eşit, daha az veya ona eşit veya daha az
(sırasıyla).
Sıralama için açıklananla aynıdır tür, yukarıda.
jq'. < 5´
2
=> doğru
ve/veya/değil
jq, normal Boole operatörlerini destekler ve/veya/veya desteklemez. Aynı doğruluk standardına sahipler
sanki ifadeler - false ve null "yanlış değerler" olarak kabul edilir ve diğer her şey bir
"gerçek değer".
Bu operatörlerden birinin işleneni birden fazla sonuç üretiyorsa, operatörün kendisi
her girdi için bir sonuç üretecektir.
değil aslında bir operatörden ziyade yerleşik bir işlevdir, bu nedenle filtre olarak adlandırılır.
gibi, özel sözdizimi yerine hangi şeyler aktarılabilir? .foo ve .Kafe | değil.
Bu üçü yalnızca "doğru" ve "yanlış" değerlerini üretir ve bu nedenle yalnızca gerçek için yararlıdır.
Perl/Python/Ruby deyimi yerine Boolean işlemleri
"value_that_may_be_null veya varsayılan". Bu "veya" biçimini kullanmak istiyorsanız,
bir koşulu değerlendirmek yerine iki değer, aşağıdaki "//" operatörüne bakın.
jq ´42 ve "bir dize"´
boş
=> doğru
jq ´(doğru, yanlış) veya yanlış´
boş
=> doğru, yanlış
jq ´(doğru, doğru) ve (doğru, yanlış)´
boş
=> doğru, yanlış, doğru, yanlış
jq ´[doğru, yanlış | olumsuzluk
boş
=> [yanlış, doğru]
Alternatif Şebeke - //
Formun bir filtresi a // b ile aynı sonuçları üretir a, Eğer a başka sonuçlar üretir
göre yanlış ve boş. Aksi takdirde, a // b ile aynı sonuçları üretir b.
Bu, varsayılanları sağlamak için kullanışlıdır: .foo // 1 değerlendirecek 1 eğer yoksa .foo
girişteki eleman. Nasıl benzer or bazen Python'da kullanılır (jq´s or Şebeke
kesinlikle Boole işlemleri için ayrılmıştır).
jq '.foo // 42'
{"foo": 19}
=> 19
jq '.foo // 42'
{}
=> 42
dene-yakala
Hatalar kullanılarak yakalanabilir denemek EXP yakalamak EXP. İlk ifade yürütülür ve eğer
başarısız olur, ardından ikincisi hata mesajıyla birlikte yürütülür. İşleyicinin çıktısı, eğer
any, denenecek ifadenin çıktısıymış gibi çıktıdır.
The denemek EXP form kullanımları boş istisna işleyicisi olarak.
jq ´dene .a yakalama ". bir nesne değil"´
gerçek
=> ". bir nesne değil"
jq ´[.[]|deneyin .a]´
[{}, doğru, {"a":1}]
=> [boş, 1]
jq ´deneyin error("bazı istisnalar") yakalama .´
gerçek
=> "bazı istisnalar"
Kırma dışarı of kontrol yapılar
Try/catch'in uygun bir kullanımı, aşağıdaki gibi kontrol yapılarından kurtulmaktır: azaltmak, her biri için,
süreVe benzeri.
Örneğin:
# Bir ifadeyi "break" ifadesini yükseltene kadar tekrarlayın.
# hata, ardından hatayı yeniden yükseltmeden tekrarlamayı bırakın.
# Ama yakalanan hata "break" değilse, yeniden yükseltin.
tekrarlamayı deneyin(exp) catch .=="break" sonra başka bir hatayı boşaltın;
jq, "kırmak" veya "geri gitmek (geri)" için adlandırılmış sözcük etiketleri için bir sözdizimine sahiptir:
etiket $out | ... doları kırmak ...
The kırılma $etiket_adı ifadesi, programın en yakın gibi davranmasına neden olur.
(sola) etiket $etiket_adı üretilmiş boş.
Arasındaki ilişki kırılma ve karşılık gelen etiket sözcükseldir: etiket olmalıdır
aradan "görünür".
Birinden ayrılmak için azaltmak, Örneğin:
etiket $out | .[] öğesini $item olarak azaltın (boş; .==false ise, $out'u ayırın yoksa ... son)
Aşağıdaki jq programı bir sözdizimi hatası üretir:
doları kırmak
çünkü etiket yok $ çıkışı görünür.
? Şebeke
The ? olarak kullanılan operatör TECRÜBE?, kısaltmasıdır denemek EXP.
jq `[.[]|(.a)?]'
[{}, doğru, {"a":1}]
=> [boş, 1]
DÜZENLİ İFADE (PCRE)
jq, php, ruby, TextMate, Sublime Text gibi Oniguruma düzenli ifade kitaplığını kullanır.
vb, bu nedenle buradaki açıklama jq özelliklerine odaklanacaktır.
jq normal ifade filtreleri, şu kalıplardan biri kullanılarak kullanılabilecek şekilde tanımlanmıştır:
STRING | FİLTRE( REGEX )
STRING | FİLTRE( REGEX; BAYRAKLAR)
STRING | FİLTRE( [REGEX] )
STRING | FİLTRE( [REGEX, BAYRAKLAR] )
burada: * STRING, REGEX ve FLAGS, jq dizeleridir ve jq dize enterpolasyonuna tabidir; *
REGEX, dize enterpolasyonundan sonra geçerli bir PCRE normal ifadesi olmalıdır; * FİLTRE test,
maçya da ele geçirmek, aşağıda açıklandığı gibi.
FLAGS, desteklenen bayraklardan birinden oluşan bir dizedir:
· g - Küresel arama (yalnızca ilkini değil, tüm eşleşmeleri bulun)
· i - Büyük/küçük harfe duyarsız arama
· m - Çok satırlı mod (´.´ yeni satırlarla eşleşir)
· n - Boş eşleşmeleri yoksay
· p - Hem s hem de m modları etkinleştirildi
· s - Tek hat modu (´^´ -> ´\A´, ´$´ -> ´\Z´)
· l - Mümkün olan en uzun eşleşmeleri bulun
· x - Genişletilmiş normal ifade biçimi (boşlukları ve yorumları yoksay)
Bir x desenindeki boşlukları eşleştirmek için \s gibi bir kaçış kullanın, örn.
· test( "a\sb", "x").
REGEX içinde belirli bayrakların da belirtilebileceğini unutmayın, örn.
· jq -n ´("test", "Test", "test", "TEST") | test( "(?i)te(?-i)st")´
şu şekilde değerlendirir: doğru, doğru, yanlış, yanlış.
[Gereklilikler 1.5] test(değer), test(normal ifade; bayraklar)
Facebok sayfasını beğenin : maç, ancak eşleşen nesneleri döndürmez, yalnızca gerçek or yanlış olup olmadığı için
regex girişle eşleşir.
jq ´test("foo")´
"foo"
=> doğru
jq ´.[] | test("abc # boşlukları dikkate alınmaz"; "ix")´
["xabcd", "ABC"]
=> doğru, doğru
[Gereklilikler 1.5] maç(val), maç(normal ifade; bayraklar)
maç bulduğu her eşleşme için bir nesne çıktısı verir. Eşleşmeler aşağıdaki alanlara sahiptir:
· ofset - girişin başlangıcından itibaren UTF-8 kod noktalarında ofset
· uzunluk - maçın UTF-8 kod noktalarındaki uzunluk
· dizi - eşleştiği dize
· yakalar - yakalama gruplarını temsil eden bir dizi nesne.
Grup nesnelerinin yakalanması aşağıdaki alanlara sahiptir:
· ofset - girişin başlangıcından itibaren UTF-8 kod noktalarında ofset
· uzunluk - bu yakalama grubunun UTF-8 kod noktalarındaki uzunluk
· dizi - yakalanan dize
· isim - yakalama grubunun adı (veya boş isimsiz olsaydı)
Hiçbir şeyle eşleşmeyen grupları yakalamak, -1 ofsetini döndürür
jq ´eşleşme("(abc)+"; "g")´
"abc abc"
=> {"kaydırma": 0, "uzunluk": 3, "dize": "abc", "yakalar": [{"kaydırma": 0, "uzunluk": 3, "dize": "abc", " name": null}]}, {"offset": 4, "uzunluk": 3, "string": "abc", "captures": [{"offset": 4, "uzunluk": 3, "dize" : "abc", "ad": boş}]}
jq ´match("foo")´
"foo bar foo"
=> {"offset": 0, "uzunluk": 3, "dize": "foo", "yakalar": []}
jq ´match(["foo", "ig"])´
"foo bar FOO"
=> {"offset": 0, "uzunluk": 3, "string": "foo", "captures": []}, {"offset": 8, "uzunluk": 3, "string": "FOO ", "yakalar": []}
jq ´match("foo (? Çubuk)? foo"; "ig")´
"foo bar foo foo foo"
=> {"offset": 0, "uzunluk": 11, "string": "foo bar foo", "captures": [{"offset": 4, "uzunluk": 3, "string": "bar" , "name": "bar123"}]}, {"offset": 12, "uzunluk": 8, "string": "foo foo", "captures": [{"offset": -1, "uzunluk" : 0, "dize": boş, "ad": "bar123"}]}
jq ´[ eşleşme("."; "g")] | uzunluk
"ABC"
=> 3
[Gereklilikler 1.5] yakalama(val), yakalama(normal ifade; bayraklar)
Adlandırılmış yakalamaları bir JSON nesnesinde toplar, anahtar olarak her yakalamanın adı,
ve karşılık gelen değer olarak eşleşen dize.
jq ´capture("(? [az]+)-(? [0-9]+)")´
"xyzzy-14"
=> { "a": "xyzzy", "n": "14" }
[Gereklilikler 1.5] tarama(regex), tarama(normal ifade; bayraklar)
içindeki normal ifadeyle eşleşen girdinin örtüşmeyen alt dizelerinin bir akışını yayınlayın.
varsa, bayraklara uygun olarak belirtilecektir. Eşleşme yoksa akış
boş. Her giriş dizesi için tüm eşleşmeleri yakalamak için deyimi kullanın [ İfade ], Örneğin [
tarama(normal ifade) ].
split(normal ifade; bayraklar)
Geriye dönük uyumluluk için, bölmek bir regex değil, bir dizgede böler.
[Gereklilikler 1.5] böler(regex), böler(normal ifade; bayraklar)
Bunlar, kendileriyle aynı sonuçları sağlar. bölmek meslektaşları, ancak bir akış yerine bir akış olarak
dizisi.
[Gereklilikler 1.5] alt(normal ifade; tostring) alt(normal ifade; dize; bayraklar)
Giriş dizesindeki ilk normal ifade eşleşmesini şununla değiştirerek elde edilen dizeyi yayınlayın.
dizginlemek, enterpolasyondan sonra. dizginlemek jq dizesi olmalıdır ve referanslar içerebilir
adlandırılmış yakalamalar için. Adlandırılmış yakalamalar aslında bir JSON nesnesi olarak sunulur (aslında
tarafından inşa edildi ele geçirmek) Ile dizginlemek, bu nedenle "x" adlı yakalanan bir değişkene yapılan bir başvuru
"(.x)" biçimini alın.
[Gereklilikler 1.5] gsub(normal ifade; sicim), gsub(normal ifade; dize; bayraklar)
gsub gibi alt ancak regex'in örtüşmeyen tüm oluşumları,
dize, enterpolasyondan sonra.
İLERİ ÖZELLİKLER
Değişkenler çoğu programlama dilinde mutlak bir zorunluluktur, ancak bunlar küme düşürülür.
jq'deki "gelişmiş bir özelliğe".
Çoğu dilde değişkenler, verileri aktarmanın tek yoludur. bir hesap yaparsanız
değer ve onu bir kereden fazla kullanmak istiyorsanız, onu bir değişkende saklamanız gerekir. İle
programın başka bir bölümüne bir değer iletirseniz, programın o bölümüne ihtiyacınız olacak
yerleştirileceği bir değişken (işlev parametresi, nesne üyesi veya her neyse) tanımlayın
veri.
Fonksiyonları jq'da tanımlamak da mümkündür, ancak bu en büyük özelliği olan bir özelliktir.
kullanım, jq'nun standart kitaplığını tanımlamaktır (birçok jq işlevi, harita ve bulmak aslında
jq ile yazılmıştır).
jq, çok güçlü ancak biraz zor olan indirgeme operatörlerine sahiptir. Yine bunlar
jq standart kitaplığının bazı yararlı bitlerini tanımlamak için çoğunlukla dahili olarak kullanılır.
İlk başta açık olmayabilir, ancak jq tamamen jeneratörlerle ilgilidir (evet, genellikle
Diğer diller). Jeneratörlerle başa çıkmak için bazı yardımcı programlar sağlanmıştır.
Bazı minimum G/Ç desteği (standart girdiden JSON okumanın ve JSON'u
standart çıktı) mevcuttur.
Son olarak, bir modül/kütüphane sistemi var.
Değişkenler
jq'de, tüm filtrelerin bir girişi ve bir çıkışı vardır, bu nedenle manuel tesisat gerekli değildir.
programın bir bölümünden diğerine bir değer iletir. Birçok ifade, örneğin a + b,
girdilerini iki farklı alt ifadeye iletin (burada a ve b ikisi de aynı geçti
girdi), bu nedenle bir değeri iki kez kullanmak için değişkenler genellikle gerekli değildir.
Örneğin, bir sayı dizisinin ortalama değerini hesaplamak için birkaç
çoğu dilde değişkenler - diziyi tutmak için en az bir tane, belki her eleman için bir tane
veya bir döngü sayacı için. jq'de, basitçe eklemek / uzunluk - eklemek ifadesi verilir
dizi ve toplamını üretir ve uzunluk ifadeye dizi verilir ve onun
uzunluğu.
Bu nedenle, jq'daki çoğu sorunu çözmenin genellikle değişkenleri tanımlamaktan daha temiz bir yolu vardır.
Yine de bazen işleri kolaylaştırırlar, bu nedenle jq kullanarak değişkenleri tanımlamanıza izin verir.
ifade as $değişken. Tüm değişken isimleri ile başlar $. İşte biraz daha çirkin bir versiyon
dizi ortalama örneğinin:
uzunluk $dizi_uzunluk olarak | / $dizi_uzunluk ekle
Değişkenlerin fiilen kullanıldığı bir durumu bulmak için daha karmaşık bir probleme ihtiyacımız olacak.
hayatımızı kolaylaştırır.
Diyelim ki, "yazar" ve "başlık" alanları olan bir dizi blog yazımız var.
yazar kullanıcı adlarını gerçek adlarla eşleştirmek için kullanılan nesne. Girişimiz şuna benziyor:
{"gönderiler": [{"başlık": "İlk psot", "yazar": "anon"},
{"title": "İyi yazılmış bir makale", "yazar": "kişi1"}],
"gerçek adlar": {"anon": "Anonim Korkak",
"kişi1": "Kişi McPherson"}}
Aşağıdaki gibi, gerçek bir ad içeren yazar alanıyla gönderiler üretmek istiyoruz:
{"title": "Frist psot", "yazar": "Anonim Korkak"}
{"title": "İyi yazılmış bir makale", "yazar": "Kişi McPherson"}
realnames nesnesini saklamak için $names değişkenini kullanırız, böylece daha sonra başvurabiliriz
yazar kullanıcı adlarını ararken:
.gerçek isimler $isimler olarak | .posts[] | {başlık, yazar: $names[.author]}
İfade exp as $x | ... şu anlama gelir: ifadenin her değeri için exp, geri kalanını çalıştır
tüm orijinal girdiye sahip boru hattı ve $x o değere ayarlayın. Böylece as
bir foreach döngüsü gibi işlev görür.
Tıpkı {foo} kullanışlı bir yazma yöntemidir {foo: .foo}, yani {$foo} kullanışlı bir yazma yöntemidir
{foo:$foo}.
Tek bir değişken kullanılarak birden çok değişken bildirilebilir. as bir desen sağlayarak ifade
girdinin yapısıyla eşleşen (bu, "yıkım" olarak bilinir):
. as {gerçek adlar: $adlar, gönderiler: [$ilk, $saniye]} | ...
Dizi modellerindeki değişken bildirimleri (örn. . as [$ilk, $saniye]) bağlamak
dizinin öğeleri, sırayla, sıfır dizinindeki öğeden yukarıya. yokken
dizi desen öğesi için dizindeki değer, boş bu değişkene bağlıdır.
Değişkenler, onları tanımlayan ifadenin geri kalanının kapsamına alınır, bu nedenle
$isimler olarak .realnames | (.posts[] | {başlık, yazar: $names[.author]})
çalışacak ama
(.realnames as $names | .posts[]) | {başlık, yazar: $names[.author]}
alışkanlık.
Programlama dili teorisyenleri için jq değişkenlerinin
sözlüksel kapsamlı bağlamalar. Özellikle bir bağlamanın değerini değiştirmenin bir yolu yoktur;
sadece aynı ada sahip yeni bir ciltleme kurulabilir, ancak nerede görünmeyecek
eskisiydi.
jq ´.bar $x olarak | .foo | . + $x´
{"foo":10, "bar":200}
=> 210
jq'. $i|[(.*2|. $i| $i olarak), $i]´ olarak
5
=> [10,5]
jq'. [$a, $b, {c: $c}] olarak | $a + $b + $c´
[2, 3, {"c": 4, "d": 5}]
=> 9
jq ´.[] olarak [$a, $b] | {a: $a, b: $b}´
[[0], [0, 1], [2, 1, 0]]
=> {"a":0,"b":null}, {"a":0,"b":1}, {"a":2,"b":1}
Tanımlanması fonksiyonlar
"def" sözdizimini kullanarak bir filtreye bir ad verebilirsiniz:
tanım artışı: . + 1;
O andan itibaren artım tıpkı yerleşik bir işlev gibi bir filtre olarak kullanılabilir (aslında bu
bazı yerleşiklerin nasıl tanımlandığı). Bir fonksiyon argüman alabilir:
tanım haritası(f): [.[] | F];
Argümanlar, değerler olarak değil, filtreler olarak iletilir. Aynı argüman referans alınabilir
farklı girdilerle birden çok kez (burada f giriş dizisinin her öğesi için çalıştırılır).
Bir işlevin bağımsız değişkenleri, benzer değer bağımsız değişkenlerinden çok geri aramalar gibi çalışır. Bu
anlamak önemlidir. Düşünmek:
tanım foo(f): f|f;
5|foo(.*2)
Sonuç 20 olacak çünkü f is .*2, ve ilk çağrı sırasında f . 5 olacak,
ve ikinci kez 10 (5 * 2) olacak, bu nedenle sonuç 20 olacaktır. Fonksiyon argümanları
filtrelerdir ve filtreler, çağrıldıklarında bir girdi bekler.
Basit işlevleri tanımlamak için değer argümanı davranışını istiyorsanız, sadece bir
değişken:
def katmadeğer(f): f $f olarak | harita(.+$f);
Veya kısa el kullanın:
def katmadeğer($f): ...;
Her iki tanımla, katma değer(.foo) mevcut girişi ekleyecektir .foo her birine alan
dizinin elemanı.
Aynı işlev adını kullanan birden çok tanımlamaya izin verilir. Her yeniden tanımlama yerini alır
önceki aynı sayıda işlev argümanı için, ancak yalnızca
yeniden tanımlamanın ardından işlevler (veya ana program).
jq ´def katma değeri(f): . + [f]; map(addvalue(.[0]))´
[[1,2], [10,20]]
=> [[1,2,1], [10,20,10]]
jq ´def addvalue(f): $x olarak f | harita(. + $x); katma değer(.[0])´
[[1,2], [10,20]]
=> [[1,2,1,2], [10,20,1,2]]
Azaltmak
The azaltmak jq'deki sözdizimi, bir ifadenin tüm sonuçlarını şu şekilde birleştirmenize izin verir:
bunları tek bir cevapta toplamak. Örnek olarak, geçeceğiz [3,2,1] Buna
ifadesi:
.[] öğesini $item (0; . + $item) olarak azaltın
Her sonuç için .[] üretir, . + $ öğe çalışan bir toplam biriktirmek için çalıştırılır,
0'dan başlayarak. Bu örnekte, .[] 3, 2 ve 1 sonuçlarını üretir, bu nedenle etki
şöyle bir şey çalıştırmaya benzer:
0 | (3 $item | . + $item olarak) |
(2 $item | . + $item olarak) |
(1 $item | . + $item olarak)
jq 'reduce .[] $item (0; . + $item)' olarak
[10,2,5,3]
=> 20
sınır(n; tecrübe)
The sınır fonksiyon özleri kadar n çıktılar exp.
jq `[sınır(3;.[])]'
[0,1,2,3,4,5,6,7,8,9]
=> [0,1,2]
ilk(ifade), son(ifade), n'inci(n; ifade)
The ilk(ifade) ve son(ifade) işlevler, ilk ve son değerleri çıkarır İfade,
respectivamente.
The n'inci(n; ifade) işlev, n. değer çıktısını şu şekilde alır: İfade. Bu şu şekilde tanımlanabilir
def n'inci(n; ifade): son(sınır(n + 1; ifade));. Bunu not et n'inci(n; ifade) desteklemiyor
negatif değerler n.
jq ´[ilk(aralık(.)), son(aralık(.)), nth(./2; aralık(.))]´
10
=> [0,9,5]
ilk, son, n.(n)
The ilk ve son fonksiyonlar herhangi bir diziden ilk ve son değerleri çıkarır. ..
The n.(n) işlevi herhangi bir dizinin n'inci değerini alır. ..
jq ´[aralık(.)]|[ilk, son, n'inci(5)]´'
10
=> [0,9,5]
her biri için
The her biri için sözdizimi şuna benzer azaltmak, ancak inşaatına izin vermeyi amaçlayan sınır
ve ara sonuçlar üreten redüktörler (örneğe bakın).
form her biri için EXP as $ var (İÇİNDE; GÜNCELLEŞTİRME; AYIKLA). Gibi azaltmak, INIT değerlendirilir
bir durum değeri üretmek için bir kez, ardından her çıktısı EXP bağlı $ var, GÜNCELLEME is
her bir çıktı için değerlendirilen EXP mevcut durumla ve $ var görünür. Her değer
tarafından çıktı GÜNCELLEME önceki durumu değiştirir. Nihayet, ÖZÜ her yeni için değerlendirilir
bir çıktı çıkarmak için durum her biri için.
Bu çoğunlukla yalnızca inşa etmek için kullanışlıdır. azaltmak- Ve sınır-benzeri fonksiyonlar. Ama bu
Kısmi azalmalara izin verdiği için çok daha geneldir (aşağıdaki örneğe bakın).
jq ´[foreach .[] $item olarak ([[],[]]; $item == null ise [[],.[0]] değilse [(.[0] + [$item]),[ ]] bitiş; eğer $item == boş ise .[1] başka boş son)]´
[1,2,3,4,null,"a","b",null]
=> [[1,2,3,4],["a","b"]]
Özyineleme
Yukarıda anlatıldığı gibi, recurse özyinelemeyi kullanır ve herhangi bir jq işlevi özyinelemeli olabilir. bu
süre yerleşik özyineleme açısından da uygulanmaktadır.
Kuyruk çağrıları, özyinelemeli çağrı çıktılarının solundaki ifade her çıktığında optimize edilir
onun son değeri. Pratikte bu, özyinelemeli ifadenin solundaki ifadenin
call, her girdi için birden fazla çıktı üretmemelidir.
Örneğin:
def recurse(f): def r: ., (f | seç(. != null) | r); r;
def while(koşul; güncelleme):
tanım _while:
eğer koşul ise ., (güncelleme | _while) yoksa boş son;
_sırasında;
def tekrar(exp):
tanım _tekrar:
deneyim, _tekrar;
_tekrarlamak;
Jeneratörler ve yineleyiciler
Bazı jq operatörleri ve işlevleri aslında sıfır üretebildikleri için üreteçlerdir.
diğer programlamada beklendiği gibi, her giriş için bir veya daha fazla değer
jeneratörleri olan diller. Örneğin, .[] girişindeki tüm değerleri üretir
(bir dizi veya nesne olmalıdır), aralık(0; 10) 0 ile arasında tamsayılar üretir
10 vb.
Virgül operatörü bile bir üreteçtir ve ilk önce virgül tarafından üretilen değerleri üretir.
virgülün solundaki ifade, ardından bunların her biri için, tarafından üretilen değerler
virgülün sağındaki ifade.
The boş yerleşik sıfır çıktı üreten jeneratördür. bu boş builtin
önceki oluşturucu ifadesine geri döner.
Tüm jq işlevleri, yalnızca yerleşik üreteçler kullanılarak üreteç olabilir. Ayrıca mümkün
yalnızca özyineleme ve virgül operatörünü kullanarak yeni oluşturucular tanımlamak için. özyinelemeli ise
çağrı(lar) "kuyruk konumunda" ise jeneratör verimli olacaktır. örnekte
tarafından özyinelemeli çağrının altında _Aralık kendine kuyruk pozisyonundadır. Örnek kendini gösteriyor
üç gelişmiş konu: kuyruk özyineleme, üreteç yapısı ve alt işlevler.
jq ´def range(init; upto; by): def _range: if (by > 0 and . < upto) veya (by < 0 and . > upto) o zaman ., ((.+by)|_range) else . son; if ile == 0 ise init else init|_range end | select((> 0 ve . < kadar) veya ( < 0 ve . > kadar)); aralık(0; 10; 3)´
boş
=> 0, 3, 6, 9
jq ´def while(cond; güncelleme): def _while: eğer koşul ise ., (güncelleme | _while) yoksa boş son; _sırasında; [while(.<100; .*2)]´
1
=> [1,2,4,8,16,32,64]
MATEMATİK
jq şu anda yalnızca IEEE754 çift duyarlıklı (64 bit) kayan noktalı sayı desteğine sahiptir.
gibi basit aritmetik operatörlerin yanı sıra +, jq ayrıca çoğu standart matematik işlevine sahiptir
C matematik kütüphanesinden. Tek bir girdi argümanı alan C matematik işlevleri (örn. günah())
sıfır argümanlı jq fonksiyonları olarak mevcuttur. İki girdi alan C matematik fonksiyonları
argümanlar (örn. güç()) yok sayan iki bağımsız değişkenli jq işlevleri olarak mevcuttur. ..
Standart matematik fonksiyonlarının mevcudiyeti, karşılık gelen fonksiyonların mevcudiyetine bağlıdır.
işletim sisteminizdeki matematik işlevleri ve C matematik kitaplığı. Kullanılamayan matematik işlevleri
tanımlanacak ancak bir hata oluşturacaktır.
I / O
Şu anda jq, çoğunlukla ne zaman üzerinde kontrol şeklinde, G/Ç için minimum desteğe sahiptir.
girişler okunur. Bunun için iki yerleşik işlev sağlanmıştır, giriş ve girişler, okuyan
Aynı kaynaklardan (örn. stdin, komut satırında adlandırılan dosyalar) jq'nin kendisi olarak. Bunlar
iki yerleşik ve jq'nin kendi okuma eylemleri birbiriyle serpiştirilebilir.
Tek bir yerleşik, minimum çıktı yetenekleri sağlar, ayıklamak. (Bir jq programının
çıktı değerleri her zaman üzerinde JSON metinleri olarak çıktılanır stdout'u.) ayıklamak yerleşik olabilir
libjq C API'sini kullanan ancak kullanılmayan yürütülebilir dosyalar gibi uygulamaya özel davranış
jq yürütülebilir dosyasının kendisi.
giriş
Bir yeni girdi çıktısı verir.
girişler
Kalan tüm girdileri birer birer çıktılar.
Bu, öncelikle bir programın girdileri üzerindeki azalmalar için kullanışlıdır.
ayıklamak
Üretilecek giriş değerine dayalı olarak bir hata ayıklama mesajına neden olur. jq yürütülebilir sarar
ile giriş değeri ["DEBUG:", ] ve bunu ve stderr'de yeni bir satır yazdırır,
kompakt olarak. Bu gelecekte değişebilir.
girdi_dosya adı
Girdisi filtrelenmekte olan dosyanın adını döndürür. Bunun olacağını unutmayın
jq bir UTF-8 yerel ayarında çalışmıyorsa iyi çalışmaz.
girdi_satır_numarası
Şu anda filtrelenmekte olan girişin satır numarasını döndürür.
YAYIN AKIŞI
İle --aktarım jq seçeneği, giriş metinlerini akış biçiminde ayrıştırabilir ve jq'ye izin verir
büyük JSON metinlerini ayrıştırmadan sonra hemen işlemeye başlamak için programlar
tamamlar. 1 GB boyutunda tek bir JSON metniniz varsa, akışı yapmanıza izin verir.
çok daha hızlı işlemek için.
Bununla birlikte, jq programının sahip olacağı gibi akışla uğraşmak kolay değildir. [ ,
] (ve diğer birkaç form) girdi olarak.
Akışları işlemeyi kolaylaştırmak için çeşitli yerleşikler sağlanmıştır.
Aşağıdaki örnekler, akış biçimini kullanır: [0, [1]], Olduğu bir
[[0],0],[[1,0],1],[[1,0]],[[1]].
Akış formları şunları içerir: [ , ] (herhangi bir skaler değeri belirtmek için boş dizi,
veya boş nesne) ve [ ] (bir dizinin veya nesnenin sonunu belirtmek için). Gelecek
ile çalıştırılan jq sürümleri --aktarım ve -seq gibi ek formlar verebilir ["hata
İleti"] bir giriş metni ayrıştırılamadığında.
truncate_stream(akış_ifadesi)
Girdi olarak bir sayı tüketir ve gelen yol öğelerinin karşılık gelen sayısını keser.
verilen akış ifadesinin çıktılarının solunda.
jq ´[1|truncate_stream([[0],1],[[1,0],2],[[1,0]],[[1]])]´
1
=> [[[0],2],[[0]]]
akıştan(akış_ifadesi)
Akış ifadesinin çıktılarına karşılık gelen değerleri verir.
jq ´fromstream(1|truncate_stream([[0],1],[[1,0],2],[[1,0]],[[1]]))´
boş
=> [2]
akış
The akış yerleşik, girişinin akış biçimini çıkarır.
jq'. $nokta|fromstream($nokta|tostream)|.==$nokta´ olarak
[0,[1,{"a":1},{"b":2}]]
=> doğru
ÖDEV
Atama, jq'de çoğu programlama dilinden biraz farklı çalışır. jq yok
bir şeye yapılan referanslar ile kopyaları arasında ayrım yapın - iki nesne veya dizi
"aynı nesne" olma veya "olmama" kavramı olmaksızın eşit olsun ya da olmasın.
aynı nesne".
Bir nesnenin dizi olan iki alanı varsa, .foo ve .Kafe, ve bir şey eklersiniz
.foo, Daha sonra .Kafe daha büyük olmayacak. Az önce ayarlamış olsan bile .Kafe = .foo. eğer kullanılmışsan
Python, Java, Ruby, Javascript vb. dillerde programlama yapmak için düşünebilirsiniz.
sanki jq, atamayı yapmadan önce her nesnenin tam bir derin kopyasını yapıyormuş gibi
(performans için aslında bunu yapmaz, ancak genel fikir budur).
jq'daki tüm atama operatörlerinin sol tarafında yol ifadeleri vardır.
=
Filtre .foo = 1 girdi olarak bir nesne alacak ve çıktı olarak bir nesne üretecektir.
"foo" alanı 1 olarak ayarlandı. jq'da bir şeyi "değiştirmek" veya "değiştirmek" kavramı yoktur -
tüm jq değerleri değişmezdir. Örneğin,
.foo = .bar | .foo.baz = 1
benzer görünümlü olduğu için .bar.baz'ın 1 olarak ayarlanmasının yan etkisi olmayacaktır.
program Javascript, Python, Ruby veya diğer dillerde olur. Bu dillerden farklı olarak (ancak
Haskell ve diğer bazı işlevsel diller gibi), iki dizi veya
nesnelerin "aynı dizi" veya "aynı nesne" olması. Eşit olabilirler veya eşit olmayabilirler, ancak
Bunlardan birini hiçbir şekilde değiştirirsek, diğeri arkamızdan değişmeyecektir.
Bu, jq'da dairesel değerler oluşturmanın imkansız olduğu anlamına gelir (örneğin,
ilk öğe kendisidir). Bu oldukça kasıtlıdır ve her şeyin bir jq
program üretebilir, JSON'da temsil edilebilir.
´=´ öğesinin sol tarafının, içindeki bir değeri ifade ettiğini unutmayın. .. Böylece $var.foo = 1 çalışmayacak
beklenildiği gibi ($var.foo geçerli veya kullanışlı bir yol ifadesi değil .); kullanmak $ var | .foo = 1
yerine.
'=' öğesinin sağ tarafı birden fazla değer üretiyorsa, bu tür her bir değer için jq
sol taraftaki yolları değere ayarlayın ve ardından değiştirilen çıktıyı verecektir. ..
Örneğin, (.a,.b)=menzil(2) çıkışlar {"a":0,"b":0}, Daha sonra {"a":1,"b":1}. Güncelleme"
ödev formları (aşağıya bakın) bunu yapmaz.
Bunu da unutmayın .a,.b=0 ayarlanmıyor .a ve .b, fakat (.a,.b)=0 ikisini de ayarlar.
|=
´=´ atama operatörünün yanı sıra jq, "güncelleme" operatörünü ´|=´ sağlar.
sağ tarafta bir filtre alır ve özelliği için yeni değeri hesaplar. .
bu ifade aracılığıyla eski değeri çalıştırarak atanır. Örneğin, .foo |=
.+1, "foo" alanı girdinin "foo" artı 1'e ayarlanmış bir nesne oluşturur.
Bu örnek, ´=´ ve ´|=´ arasındaki farkı göstermelidir:
Programlara ´{"a": {"b": 10}, "b": 20}´ girişini sağlayın:
.a = .b .a |= .b
İlki, girdinin "a" alanını girdinin "b" alanına ayarlayacak ve üretecektir.
çıktı {"a": 20}. İkincisi, girişin "a" alanını "a" alanına ayarlayacaktır.
"b" alanı, üreten {"a": 10}.
Sol taraf herhangi bir genel yol ifadesi olabilir; görmek yol().
´|=´ öğesinin sol tarafının, içindeki bir değeri ifade ettiğini unutmayın. .. Böylece $var.foo |= . + 1 alışkanlık
beklendiği gibi çalışın ($var.foo geçerli veya kullanışlı bir yol ifadesi değil .); kullanmak $ var | .foo
|= . + 1 yerine.
Sağ taraf birden fazla değer veriyorsa, yalnızca sonuncusu kullanılacaktır.
jq ´(..|select(type=="boolean")) |= if . o zaman 1 başka 0 son´
[doğru,yanlış,[5,doğru,[doğru,[yanlış]],yanlış]]
=> [1,0,[5,1,[1,[0]],0]]
+=, -=, *=, /=, %=, // =
jq, formun birkaç operatörüne sahiptir a operasyon= b, hepsi eşdeğer olan a |= . op b. Yani,
+= 1 değerleri artırmak için kullanılabilir.
jq ´.foo += 1´
{"foo": 42}
=> {"foo": 43}
Karmaşık ödevler
Bir jq atamasının sol tarafında birçok şeye göre çok daha fazla şeye izin verilir.
Diller. Sol tarafta basit alan erişimlerini zaten gördük ve bu
dizi erişimlerinin de işe yaraması şaşırtıcı:
.posts[0].title = "JQ Kılavuzu"
Sürpriz olarak gelebilen şey, soldaki ifadenin birden fazla üretebilmesidir.
girdi belgesindeki farklı noktalara atıfta bulunan sonuçlar:
.posts[].comments |= . + ["bu harika"]
Bu örnek, içindeki her gönderinin "yorumlar" dizisine "bu harika" dizesini ekler.
girdi (burada girdi, bir yazı dizisi olan "yazılar" alanına sahip bir nesnedir).
jq, ´a = b´ gibi bir atamayla karşılaştığında, a'yı seçmek için alınan "yolu" kaydeder.
a yürütülürken girdi belgesinin bir parçası. Bu yol daha sonra hangi bölümü bulmak için kullanılır
atama yürütülürken değiştirilecek giriş. üzerinde herhangi bir filtre kullanılabilir.
eşittir sol tarafı - girişten hangi yolu seçerse seçsin,
atama yapılır.
Bu çok güçlü bir işlemdir. Kullanarak blog gönderilerine bir yorum eklemek istediğimizi varsayalım.
yukarıdaki aynı "blog" girişi. Bu sefer sadece yazanlara yorum yapmak istiyoruz.
"stedol". Bu gönderileri daha önce açıklanan "seç" işlevini kullanarak bulabiliriz:
.posts[] | select(.author == "stedol")
Bu işlem tarafından sağlanan yollar, "stedolan"ın yazdığı gönderilerin her birine işaret eder ve
her biri hakkında daha önce yaptığımız gibi yorum yapabiliriz:
(.posts[] | select(.author == "stedolan") | .comments) |=
. + ["korkunç."]
MODÜLLER
jq bir kütüphane/modül sistemine sahiptir. Modüller, adları ile biten dosyalardır. .jq.
Bir program tarafından içe aktarılan modüller, varsayılan bir arama yolunda aranır (aşağıya bakın). bu
ithalat ve dahil yönergeler, ithalatçının bu yolu değiştirmesine izin verir.
Bir arama yolundaki yollar, çeşitli ikamelere tabidir.
"~/" ile başlayan yollar için, kullanıcının ana dizini "~" ile değiştirilir.
"$ORIGIN/" ile başlayan yollar için, jq yürütülebilir dosyasının yolu,
"$KÖKEN".
"./" ile başlayan yollar veya "." olan yollar için, dahil edilen dosyanın yolu
vekalet etmek ".". Komut satırında verilen üst düzey programlar için geçerli
dizin kullanılır.
İçe aktarma yönergeleri, isteğe bağlı olarak, varsayılanın eklendiği bir arama yolu belirtebilir.
Varsayılan arama yolu, kullanıcıya verilen arama yoludur. -L komut satırı seçeneği, başka
["~/.jq", "$ORIGIN/../lib/jq", "$KÖKEN/../ lib"].
Boş ve boş dize yolu öğeleri, arama yolu işlemeyi sonlandırır.
Göreli yol "foo/bar" olan bir bağımlılık "foo/bar.jq" içinde aranır ve
verilen arama yolunda "foo/bar/bar.jq". Bu, modüllerin yerleştirilmesine izin vermek için tasarlanmıştır
örneğin sürüm kontrol dosyaları, BENİOKU dosyaları vb. ile birlikte bir dizinde,
ama aynı zamanda tek dosyalı modüllere izin vermek için.
Aynı ada sahip ardışık bileşenlerin belirsizliklerden kaçınmasına izin verilmez (örn.
"foo/foo").
Örneğin, -L$HOME/.jq bir modül foo bulunabilir $HOME/.jq/foo.jq ve
$HOME/.jq/foo/foo.jq.
"$HOME/.jq" bir dosyaysa, ana programa kaynaklanır.
ithalat GöreliYolDizesi as ADI [ ];
Arama yolundaki bir dizine göre verilen yolda bulunan bir modülü içe aktarır. Bir ".jq"
göreli yol dizesine son ek eklenecektir. Modülün sembollerinin ön eki şu şekildedir:
"İSİM::".
İsteğe bağlı meta veriler sabit bir jq ifadesi olmalıdır. Anahtarları olan bir nesne olmalı
"ana sayfa" vb. Şu anda jq yalnızca "arama" anahtarını/değerini kullanır.
meta veri. Meta veriler ayrıca kullanıcılara şu şekilde sunulur: modül metası yerleşik.
Varsa, meta verilerdeki "arama" anahtarının bir dize veya dizi değeri (dizi
diziler); bu, üst düzey arama yolunun önüne eklenecek arama yoludur.
dahil GöreliYolDizesi [ ];
Verilen yolda bulunan bir modülü, bir arama yolundaki bir dizine göreli gibi içe aktarır.
yerlerine dahil edildi. Göreli yol dizesine bir ".jq" eki eklenecektir. bu
modülün sembolleri, sanki modülün içeriğinde varmış gibi arayanın ad alanına aktarılır.
doğrudan dahil edilmiştir.
İsteğe bağlı meta veriler sabit bir jq ifadesi olmalıdır. Anahtarları olan bir nesne olmalı
"ana sayfa" vb. Şu anda jq yalnızca "arama" anahtarını/değerini kullanır.
meta veri. Meta veriler ayrıca kullanıcılara şu şekilde sunulur: modül metası yerleşik.
ithalat GöreliYolDizesi as $NAME [ ];
Arama yolundaki bir dizine göre verilen yolda bulunan bir JSON dosyasını içe aktarır. A
Göreli yol dizesine ".json" soneki eklenecektir. Dosyanın verileri
olarak mevcut $NAME::NAME.
İsteğe bağlı meta veriler sabit bir jq ifadesi olmalıdır. Anahtarları olan bir nesne olmalı
"ana sayfa" vb. Şu anda jq yalnızca "arama" anahtarını/değerini kullanır.
meta veri. Meta veriler ayrıca kullanıcılara şu şekilde sunulur: modül metası yerleşik.
Varsa, meta verilerdeki "arama" anahtarının bir dize veya dizi değeri (dizi
diziler); bu, üst düzey arama yolunun önüne eklenecek arama yoludur.
modül ;
Bu yönerge tamamen isteğe bağlıdır. Düzgün çalışması için gerekli değildir. hizmet eder
ile okunabilen meta verileri sağlama amacını taşır. modül metası yerleşik.
Meta veri sabit bir jq ifadesi olmalıdır. Gibi tuşları olan bir nesne olmalı
"ana sayfa". Şu anda jq bu meta verileri kullanmaz, ancak kullanıcıların kullanımına sunulur
ile modül metası yerleşik.
modül metası
Modül adını girdi olarak alır ve modülün meta verilerini bir nesne olarak çıkarır.
modülün içe aktardığı (meta veriler dahil) "deps" anahtarı için bir dizi değeri olarak.
Programlar bunu, daha sonra kullanabilecekleri bir modülün meta verilerini sorgulamak için kullanabilirler.
örneğin, eksik bağımlılıkları arayın, indirin ve yükleyin.
onworks.net hizmetlerini kullanarak jq çevrimiçi kullanın
