Ketika sebagian besar pekerjaan Anda melakukan transformasi JSON, maka Anda mungkin memerlukan bahasa template ini agar efektif.

Motivasi

Kami ( Rudderstack ) adalah platform integrasi dan mendukung 200+ integrasi. Kami mengimplementasikan integrasi ini menggunakan kode Javascript asli untuk mengubah peristiwa yang masuk ke payload tujuan, jadi singkatnya, ini adalah manipulasi data JSON. Mempertahankan semua integrasi ini merupakan tantangan, jadi kami menjelajahi jsonata untuk menulis lebih sedikit kode guna mengubah data JSON. Meskipun perpustakaan ini luar biasa, kami masih perlu memenuhi kebutuhan kinerja kami. Misalnya, JSONata mem-parsing template yang diberikan, membuat Pohon Sintaks Abstrak (AST), dan menginterpretasikan AST untuk input yang diberikan. Karena kami perlu melintasi AST setiap saat, ini lambat, jadi kami ingin membuat mesin template yang menghasilkan kode Javascript sehingga akan ada lebih sedikit overhead selama runtime.

Ringkasan

Pustaka untuk memproses data JSON menggunakan sintaks khusus berdasarkan javascript dan jspath . Kami berterima kasih kepada penulis jspath atas karya luar biasa mereka, karena perpustakaan kami merupakan perpanjangan dari perpustakaan asli. Kami juga ingin berterima kasih kepada tim IBM atas pekerjaan mereka jsonata , karena kami telah mengambil beberapa ide dari perpustakaan. Anda juga dapat mempertimbangkan perpustakaan kami sebagai alternatif jsonata .

Pustaka ini menghasilkan kode fungsi javascript dari template dan kemudian menggunakan fungsi tersebut untuk mengevaluasi data JSON. Ini menampilkan kode javascript dalam tahapan berikut:

1. Lexing (Tokenisasi)
2. Parsing (Pembuatan AST)
3. Terjemahan (Pembuatan kode)
4. Kelas mesin mengabstraksi langkah-langkah di atas dan menyediakan cara mudah untuk menggunakan template JSON untuk mengevaluasi input.

Install:npm install rudder-json-template-engine

const engine = new JsonTemplateEngine(`'Hello ' + .name`);
engine.evaluate({name: 'World'}); // => Hello World

Template adalah sekumpulan pernyataan, dan hasil dari pernyataan terakhir adalah output dari template.

Variabel

const a = 1
let b = a + 2
a + b

Input mengacu pada dokumen JSON yang ingin kami proses menggunakan template. Binding mengacu pada data atau fungsi tambahan yang akan kami sediakan untuk memproses data secara efisien.

Contoh:

• Templat:"Hello " + (.name ?? $.defaultName)
• Evaluasi:engine.evaluate({name: 'World'}, {defaultName: 'World'});
• {name: 'World'}adalah masukan.
• ^.namemengacu pada properti "nama" dari input. Kita juga bisa menggunakan .nameuntuk merujuk pada hal yang sama. ^selalu merujuk ke akar input, dan .mengacu pada konteks saat ini. Lihat contoh untuk lebih jelasnya.
• {defaultName: 'World'}adalah binding.
• $.defaultNamemengacu pada properti "defaultName" dari binding. Lihat contoh untuk lebih jelasnya.

let arr = [1, 2, 3, 4]
let a = arr[1, 2] // [2, 3]
let b = arr[0:2] // [1, 2]
let c = arr[-2:] // [3, 4]

Objek

let key = "some key"
// { "a": 1, "b": 2, "c": 3, "some key": 4 }
let obj = {a: 1, b: 2, c: 3, [key]: 4 }
let a = obj["a"] // 1
let b = obj.a // 1
let c = obj{["a", "b"]} // { "a": 1, "b": 2}
let d = obj{~["a", "b"]} // { "c": 3, "some key": 4}

Fungsi

Fungsi normal

let fn = function(arg1, arg2){
  arg1 + arg2
}

Fungsi Lambda/Pendek

let fn = array.map(lambda 2 * ?0);

let fn = array.map(function(args) {
  2 * args[0]
})

Fungsi asinkron

let fn = async function(arg1, arg2){
  const result = await doSomethingAsync(arg1, arg2)
  doSomethingSync(result)
}

let result = await doSomething(.a, .b)

Jalur digunakan untuk mengakses properti di input, bindingsdan variables.

Jalan Sederhana

Jalur sederhana mendukung fitur jalur terbatas dan diterjemahkan sebagai pernyataan akses properti langsung dalam kode javascript yang dihasilkan. a.b.cditerjemahkan ke a?.b?.csehingga mereka sangat cepat dibandingkan dengan Rich paths . Jalur sederhana ideal ketika kita mengetahui struktur objek.

Fitur yang didukung:

• Selector Sederhana
• Filter Indeks Tunggal Lihat contoh untuk kejelasan lebih lanjut.

Jalur kaya dikonversi menjadi kode kompleks untuk mendukung berbagai variasi dalam data.

Jika kita menggunakan rich path untuk expression: a.b.c, itu secara otomatis menangani variasi berikut.

• [{"a": { "b": [{"c": 2}]}}]
• {"a": { "b": [{"c": 2}]}}
• {"a": [{ "b": [{"c": 2}]}]}
• Secara otomatis menangani pemilihan dari objek dan array bersarang.

let x = a.b.c;
let y = a."some key".c

Pemilih karakter pengganti

a.*.c // selects c from any direct property of a

Pemilih keturunan

// selects c from any child property of a
// a.b.c, a.b1.b2.c or a.b1.b2.b3.c
let x = a..c;
let y = a.."some key";

Indeks Tunggal atau Filter Properti

let x = a[0].c;
let y = a[-1].c;  // selects last element from array
let z = a["some key"].c

Multi Indeks atau Filter Properti

let x = a[0, 2, 5].c;
let y = a["some key1", "some key2"].c;

Filter jangkauan

let x = a[2:5].c;
let y = a[:-2].c;
let z = a[2:].c;

let x = obj{["a", "b"]};  // selects a and b
let y = obj{~["a", "b"]}; // selects all properties except a and b

Filter Bersyarat atau Objek

let x = obj{.a > 1};

Blokir ekspresi

let x = obj.({
  a: .a + 1,
  b: .b + 2
});
let x = obj.([.a+1, .b+2]);

Variabel Konteks

.orders@order#idx.products.({
    name: .name,
    price: .price,
    orderNum: idx,
    orderId: order.id
})

Opsi Jalur

Kami dapat menyebutkan defaultPathType saat membuat instance mesin.

// For using simple path as default path type
// a.b.c will be treated as simple path
JsonTemplateEngine.create(`a.b.c`, {defaultPathType: PathType.SIMPLE});
// For using rich path as default path type
// a.b.c will be treated as rich path
JsonTemplateEngine.create(`a.b.c`, {defaultPathType: PathType.RICH});

// Use ~s to treat a.b.c as simple path
~s a.b.c
// Use ~r to treat a.b.c as rich path
~r a.b.c

Kompilasi ekspresi waktu

Ekspresi waktu kompilasi dievaluasi menggunakan opsi binding waktu kompilasi selama fase kompilasi.

// {{$.a.b.c}} gets translated to 1 and
// final translated code will be "let a = 1;"
JsonTemplateEngine.create(`let a = {{$.a.b.c}};`, {
  compileTimeBindings: {
    a: {
      b: {
        c: 1
      }
    }
  }
});

Kesimpulan

Kami telah membuat bahasa sederhana untuk memproses data JSON secara efisien dan menjadikannya open-source . Sangat menyenangkan membangun bahasa, dan saya harap Anda telah mempelajari sesuatu yang baru hari ini.