Setara XSLT untuk JSON

Saya tertarik untuk menemukan (atau jika perlu mengembangkan) setara XSLT untuk JSON.

Karena saya belum menemukan satu pun, saya sedang mempertimbangkan bahasa query yang mungkin digunakan untuk mencocokkan jalur JSON sehingga dapat menerapkan templat (dari JavaScript) ketika ada kecocokan (mungkin hanya memeriksa serangkaian pola pencocokan secara berurutan, dan berhenti di template pertama yang cocok, meskipun memungkinkan untuk setara dengan xsl: apply-templat untuk membuat templat tetap berjalan untuk anak-anak).

Saya menyadari JSONPath, JSONQuery, dan RQL sebagai bahasa query JSON (meskipun saya tidak sepenuhnya jelas tentang apakah RQL mendukung jalur absolut dan relatif). Setiap saran tentang faktor untuk dipertimbangkan dan keuntungan relatif masing-masing terhadap penggunaan seperti itu.

XML: XSLT :: JSON: x . Apa itu x ?

Jawaban yang paling mudah adalah x = JavaScript. Meskipun Anda bisa mengajukan alasan untuk ini, rasanya tidak memuaskan. Meskipun XSLT secara teknis Turing lengkap , ada korespondensi yang buruk antara gaya deklaratif XSLT dan gaya yang lebih imperatif atau fungsional yang terlihat dalam JavaScript.

Ada beberapa bahasa permintaan JSON mandiri, seperti JSONPath , JSONiq , dan RQL yang mungkin berdiri di tengah XML: XPath :: JSON: y (atau mungkin, XQuery daripada XPath). Dan setiap database dokumen yang berfokus pada JSON memiliki bahasa query yang terkait dengan JSON .

Tetapi kenyataannya adalah, meskipun ada beberapa pesaing untuk posisi XSLT penuh, seperti SpahQL , tidak ada yang secara umum diterima, secara luas didukung setara JSON dengan XSLT.

Mengapa?

Dengan semua JSON di dunia, mengapa tidak ada analog (lebih langsung) ke XSLT? Karena banyak pengembang melihat XSLT sebagai percobaan yang gagal. Mesin pencari mana pun akan mengarah ke kutipan seperti "XSLT adalah kegagalan yang dibungkus dengan rasa sakit." Yang lain berpendapat bahwa jika itu hanya diformat lebih baik, itu akan lebih populer. Tetapi minat pada XSLT umumnya telah berkurang selama bertahun-tahun . Banyak alat yang mendukungnya hanya mendukung versi 1.0 , yang merupakan spesifikasi 1999. Spesifikasi berusia lima belas tahun? Ada spesifikasi 2.0 yang jauh lebih baru, dan jika orang antusias dengan XSLT, itu akan didukung. Bukan itu.

Pada umumnya pengembang telah memilih untuk memproses dan mengubah dokumen XML dengan kode, bukan template transformasi. Oleh karena itu tidak mengherankan bahwa ketika bekerja dengan JSON, mereka pada umumnya juga akan memilih untuk melakukannya dalam bahasa ibu mereka, daripada menambahkan sistem transformasi "asing" tambahan.

Sementara Jonathan sebagian besar berbicara tentang sifat XSLT sebagai bahasa dalam jawabannya, saya pikir ada sudut pandang lain untuk dipertimbangkan.

Tujuan XSLT adalah untuk mengubah dokumen XML menjadi beberapa dokumen lain (XML, HTML, SGML, PDF, dll). Dengan cara ini, XSLT sering digunakan, secara efektif, sebagai bahasa templat.

Ada banyak sekali pustaka templat di luar sana, bahkan jika Anda membatasi diri Anda sendiri ke pustaka JavaScript (yang seharusnya tidak Anda perlukan, karena JS di JSON hanya merujuk pada asal notasi dan tidak boleh dianggap menyiratkan bahwa JSON hanya untuk JavaScript). Pemilih mesin template ini memberikan dan indikasi tentang berbagai opsi JS yang ada di luar sana.

Bagian terakhir dari pertanyaan Anda berbicara lebih banyak tentang bahasa permintaan dan versi XML ini adalah XPath (bukan XSLT). Seperti yang Anda perhatikan, ada berbagai opsi di sana dan saya tidak menambahkan apa pun ke daftar itu. Daerah ini relatif baru, jadi saya sarankan Anda memilih satu dan ikuti saja.

Berikut adalah beberapa contoh apa yang dapat Anda lakukan dengan JSLT - JavaScript Lightweight Transforms (kecil ^{[jslt.min.js]} ) saya:

https://jsfiddle.net/YSharpLanguage/c7usrpsL/10

( ^{[jslt.min.js]} beratnya ~ 3,1kb yang diperkecil )

yaitu, hanya satu fungsi,

function Per ( subject ) { ... }

... yang sebenarnya meniru model pemrosesan XSLT (1.0) .

(lih fungsi dalam "transform" dan "templat", di tubuh Per)

Jadi, pada dasarnya, itu hanya semua dimasukkan ke dalam single function Per ( subject ) { ... }yang melakukan evaluasi pada jenis argumen uniknya, untuk diterapkan, baik:

1) Array subjek

pembuatan nodeset / filtering / perataan / pengelompokan / pemesanan / dll , jika subjek adalah array, di mana nodeset yang dihasilkan (juga Array ) diperluas dengan, dan terikat dengan metode yang sesuai ( hanya instance Array yang dikembalikan dari panggilan ke Per ( subjectArray )adalah diperpanjang; yaitu, Array.prototype dibiarkan tak tersentuh)

yaitu, Per :: Array --> Array

( metode ekstensi Array yang dihasilkan memiliki nama yang cukup jelas seperti, groupBy, orderBy, flattenBy, dll - lih. penggunaan dalam contoh-contoh)

2) Subjek string

interpolasi string , jika subjek adalah string

("Per" lalu mengembalikan objek dengan metode map ( source ), yang terikat ke string templat subjek )

yaitu, Per :: String --> {map :: ( AnyValue --> String )}

misalnya,

Per("Hi honey, my name is {last}. {first}, {last}.").map({ "first": "James", "last": "Bond" })

hasil:

"Hi honey, my name is Bond. James, Bond."

sementara salah satu dari

Per("Those '{*}' are our 10 digits.").map([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ])

atau

Per("Those '{*}' are our 10 digits.").map(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

menghasilkan yang sama:

"Those '0123456789' are our 10 digits."

tapi hanya

Per("Those '{*}' are our 10 digits.").map([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ], ", ")

hasil panen

"Those '0, 1, 2, 3, 4, 5, 6, 7, 8, 9' are our 10 digits."

3) Ubah subjek

XSLT mirip-transformasi , jika subjek adalah hash dengan anggota "$" yang didefinisikan secara konvensional menyediakan array aturan penulisan ulang (dan sama seperti dalam (2), "Per" kemudian mengembalikan objek dengan metode yang map ( source )terikat pada subjek. mengubah - di mana

"ruleName" in Per ( subjectTransform [ , ruleName ])adalah opsional dan menyediakan fungsionalitas yang mirip dengan <xsl: call-template name = "templateName"> ...)

yaitu, Per :: ( Transform [, ruleName :: String ]) -->{map :: ( AnyValue --> AnyValue )}

dengan

Transform :: {$ :: Array aturan penulisan ulang ^[rw.r.] }

( ^[rw.r.] pasangan fungsi predikat dan templat)

misalnya, diberikan (... contoh lain yang dibuat-buat)

// (A "Member" must have first and last names, and a gender)
function Member(obj) {
  return obj.first && obj.last && obj.sex;
}

var a_transform = { $: [
//...
  [ [ Member ], // (alike <xsl:template match="...">...)
      function(member) {
        return {
          li: Per("{first} {last}").map(member) +
              " " +
              Per(this).map({ gender: member.sex })
        };
      }
  ],

  [ [ function(info) { return info.gender; } ], // (alike <xsl:template match="...">...)
      function(info) { return Per("(gender: {gender})").map(info); }
  ],

  [ [ "betterGenderString" ], // (alike <xsl:template name="betterGenderString">...)
      function(info) {
        info.pronoun = info.pronoun || "his/her";
        return Per("({pronoun} gender is {gender})").map(info);
      }
  ]
//...
] };

kemudian

Per(a_transform).map({ "first": "John", "last": "Smith", "sex": "Male" })

hasil:

{ "li": "John Smith (gender: Male)" }

sementara ... (mirip <xsl:call-template name="betterGenderString">...)

"James Bond... " +
Per(a_transform, "betterGenderString").map({ "pronoun": "his", "gender": "Male" })

hasil:

"James Bond... (his gender is Male)"

dan

"Someone... " +
Per(a_transform, "betterGenderString").map({ "gender": "Male or Female" })

hasil:

"Someone... (his/her gender is Male or Female)"

4) Sebaliknya

fungsi identitas , dalam semua kasus lainnya

yaitu, Per :: T --> T

(yaitu, Per === function ( value ) { return value ; })

Catatan

pada (3) di atas, JavaScript "ini" di badan fungsi templat terikat dengan wadah / pemilik Transform dan seperangkat aturannya (sebagaimana didefinisikan oleh array $: [...]) - oleh karena itu, membuat ekspresi "Per (ini)", dalam konteks itu, setara fungsional-dekat dengan XSLT

<xsl:apply-templates select="..."/>

'HTH,

Saya baru-baru ini membuat perpustakaan, json-transforms , tepatnya untuk tujuan ini:

https://github.com/ColinEberhardt/json-transforms

Ia menggunakan kombinasi JSPath , DSL yang dimodelkan pada XPath, dan pendekatan pencocokan pola rekursif, yang terinspirasi langsung oleh XSLT.

Ini contoh singkatnya. Diberikan objek JSON berikut:

const json = {
  "automobiles": [
    { "maker": "Nissan", "model": "Teana", "year": 2011 },
    { "maker": "Honda", "model": "Jazz", "year": 2010 },
    { "maker": "Honda", "model": "Civic", "year": 2007 },
    { "maker": "Toyota", "model": "Yaris", "year": 2008 },
    { "maker": "Honda", "model": "Accord", "year": 2011 }
  ]
};

Inilah transformasi:

const jsont = require('json-transforms');
const rules = [
  jsont.pathRule(
    '.automobiles{.maker === "Honda"}', d => ({
      Honda: d.runner()
    })
  ),
  jsont.pathRule(
    '.{.maker}', d => ({
      model: d.match.model,
      year: d.match.year
    })
  ),
  jsont.identity
];

const transformed  = jsont.transform(json, rules);

Yang menghasilkan sebagai berikut:

{
  "Honda": [
    { "model": "Jazz", "year": 2010 },
    { "model": "Civic", "year": 2007 },
    { "model": "Accord", "year": 2011 }
  ]
}

Transformasi ini terdiri dari tiga aturan. Yang pertama cocok dengan mobil apa pun yang dibuat oleh Honda, memancarkan objek dengan Hondaproperti, kemudian secara rekursif cocok. Aturan kedua cocok dengan objek apa pun dengan makerproperti, mengeluarkan modeldan yearproperti. Final adalah transformasi identitas yang cocok secara rekursif.

Saya tidak berpikir Anda akan pernah mendapatkan varian JSON untuk JSON per se. Ada beberapa mesin templating seperti Python Jinja2, JavaScripts Nunjucks, Groovy MarkupTemplateEngine, dan banyak lainnya yang harus cocok untuk apa yang Anda inginkan. .NET memiliki dukungan serialisasi / deserialisasiisasi T4 dan JSON sehingga Anda juga memilikinya.

Karena data JSON yang derserialisasi pada dasarnya adalah sebuah kamus atau struktur peta, itu hanya akan melewati mesin templating Anda dan Anda akan beralih pada node yang diinginkan di sana. Data JSON kemudian ditransformasikan oleh templat.