---
title: 'Core'
description: "Operator inti untuk mengakses data dan mendefinisikan nilai literal."
navigation:
  icon: 'i-ph-code-block'
seo:
  title: 'Core'
  description: "Operator inti untuk mengakses data dan mendefinisikan nilai literal."
---

## `var` - Akses Variabel

Mengakses data dari konteks input.

### Sintaksis
```json
{"var": "path"}
{"var": ["path", default_value]}
```

### Parameter
- **path** (string): Jalur menuju variabel (notasi titik, JSON pointer, atau indeks array)
- **default_value** (opsional, uum): Nilai yang dikembalikan jika variabel tidak ditemukan atau null

### Tipe Kembalian
Any - Mengembalikan nilai pada jalur yang ditentukan, atau nilai default jika tidak ditemukan

### Contoh

**Akses dasar:**
```json
// Data: {"name": "Alice", "age": 30}
{"var": "name"}  // → "Alice"
{"var": "age"}   // → 30
```

**Akses objek bersarang (nested):**
```json
// Data: {"user": {"profile": {"city": "NYC"}}}
{"var": "user.profile.city"}  // → "NYC"
```

**Akses array:**
```json
// Data: {"items": [1, 2, 3, 4, 5]}
{"var": "items.0"}  // → 1
{"var": "items.2"}  // → 3
```

**Dengan nilai default:**
```json
// Data: {"name": "Bob"}
{"var": ["age", 25]}        // → 25 (age tidak ada, kembalikan default)
{"var": ["name", "Guest"]}  // → "Bob" (name ada, kembalikan nilai asli)
```

**Referensi konteks awal/akar (root):**
```json
// Data: [1, 2, 3]
{"var": ""}  // → [1, 2, 3] (mengembalikan seluruh data)
```

**Konteks saat ini dalam operasi array:**
```json
// Dalam map/filter, string kosong merujuk ke elemen saat ini
{"map": [[1, 2, 3], {"var": ""}]}  // → [1, 2, 3]
```

### Format Jalur (Path)

Semua format dinormalkan secara internal:

**Notasi titik:**
```json
{"var": "user.profile.name"}
```

**JSON Pointer:**
```json
{"var": "/user/profile/name"}
```

**Indeks array:**
```json
{"var": "items.0"}
{"var": "items[0]"}  // Juga didukung
```

### Kasus Khusus (Edge Cases)

**Variabel hilang:**
```json
// Data: {"name": "Alice"}
{"var": "missing"}  // → null
```

**Nilai null:**
```json
// Data: {"value": null}
{"var": "value"}           // → null
{"var": ["value", "default"]}  // → "default" (null dianggap sebagai hilang)
```

**Jalur kosong:**
```json
{"var": ""}  // Mengembalikan data konteks awal (root)
```

---

## `$ref` / `ref` - Akses Referensi

Mengakses data menggunakan referensi bergaya JSON Schema. Berperilaku persis sama dengan `var` tetapi memakai sintaks `$ref`.

### Sintaksis
```json
{"$ref": "path"}
{"ref": "path"}
{"$ref": ["path", default_value]}
```

### Parameter
Sama seperti `var`

### Tipe Kembalian
Any - Mengembalikan nilai pada jalur yang ditentukan

### Contoh

**Referensi dasar:**
```json
// Data: {"$params": {"rate": 0.05}}
{"$ref": "$params.rate"}  // → 0.05
```

**Gaya JSON Schema:**
```json
{"$ref": "#/properties/user/properties/name"}
```

**Dengan default:**
```json
{"$ref": ["missing.field", "default"]}  // → "default"
```

### Catatan
- Secara otomatis menormalkan jalur JSON Schema (menghapus segmen `/properties/`)
- Keduanya didukung: `$ref` maupun `ref`
- Jalur diubah ke format JSON pointer secara internal

---

## Nilai Literal (Literal Values)

Menentukan nilai konstan secara langsung di dalam ekspresi logika.

### `null` - Nilai Kosong

```json
null  // → null
```

### `bool` - Nilai Boolean

```json
true   // → true
false  // → false
```

### `number` - Nilai Angka

```json
42        // → 42
3.14159   // → 3.14159
-17.5     // → -17.5
0         // → 0
```

**Fitur:**
- Dukungan presisi tinggi abstrak dari paket `serde_json`
- Disimpan sebagai tipe string secara internal demi memelihara ketepatan presisi penuh
- Dikonversi ke tipe f64 saat bersinggungan operasi matematis aritmatika

### `string` - Nilai Teks / Karakter

```json
"hello"         // → "hello"
"Hello World"   // → "Hello World"
""              // → "" (string kosong)
```

### `array` - Literal Array

```json
[1, 2, 3]                    // → [1, 2, 3]
["a", "b", "c"]              // → ["a", "b", "c"]
[1, "hello", true, null]     // → [1, "hello", true, null] (tipe campuran)
[]                           // → [] (array kosong)
```

**Array bersarang (Nested):**
```json
[[1, 2], [3, 4], [5, 6]]     // → [[1, 2], [3, 4], [5, 6]]
```

**Dengan ekspresi di dalamnya:**
```json
[{"var": "x"}, {"var": "y"}, 10]  // Mengevaluasi ekspresi di dalam array
```

---

## Contoh

### Kombinasi Operator Core

**Akses data bersarang (nested) dengan cadangan (fallback):**
```json
{
  "if": [
    {"var": "user.profile.displayName"},
    {"var": "user.profile.displayName"},
    {"var": ["user.name", "Guest"]}
  ]
}
```

**Membangun struktur yang kompleks:**
```json
{
  "cat": [
    "User: ",
    {"var": "name"},
    " (Age: ",
    {"var": ["age", "Unknown"]},
    ")"
  ]
}
```

**Manipulasi array:**
```json
{
  "map": [
    {"var": "users"},
    {"var": "name"}
  ]
}
// Ekstrak nama (name) dari setiap objek pengguna (users)
```

---

## Praktik Terbaik (Best Practices)

1. **Gunakan notasi titik** untuk rute jalur yang lebih jernih dan terbaca
   ```json
   {"var": "user.profile.name"}  // ✓ Jelas
   {"var": "/user/profile/name"} // ✓ Bisa juga
   ```

2. **Berikan nilai default** untuk kolom opsional
   ```json
   {"var": ["settings.theme", "light"]}
   ```

3. **Gunakan string kosong** untuk konteks operasi per-elemen pada operasi array
   ```json
   {"map": [array, {"*": [{"var": ""}, 2]}]}
   ```

4. **Penormalan jalur seragam** (ditangani otomatis)
   - `"user.profile"` dan `"/user/profile"` dianggap setara
   - Keduanya diubah menjadi gaya format JSON pointer di mesin

5. **Antisipasi data hilang dengan anggun**
   ```json
   {"ifnull": [{"var": "optional"}, "default"]}
   ```

---

## Operator Terkait

- **[if](logical#if)** - Logika kondisional berlandaskan nilai variabel
- **[missing](utility#missing)** - Pengecek eksistensi variabel (yang tidak ada)
- **[ifnull](logical#ifnull)** - Penyedia cadangan nilai antisipasi hasil null
- **[Operator Array](array)** - Mengubah (transform) array dengan `var` dan parameter string kosong

---

## Catatan Kinerja

- **Penormalan rute jalur** berlangsung sekali sewaktu proses kompilasi, bukan saat operasi jalan.
- **Pencarian Variabel (Lookups)** teroptimisasi di balut pemrosesan (zero-copy references) lurus menghasilkan daya tempuh maksimal tercepat.
- **Logika Terkompilasi** menanam hasil penyimpanan laci laci string dalam proses pembacaan jalur panjang beribu-ribu iterasi selanjutnya tanpa putus.
