---
title: 'Pemecahan Masalah'
description: "Panduan referensi cepat untuk kesalahan umum (pitfalls) saat bekerja dengan operator JSON-Eval-RS dan cara menghindarinya."
navigation:
  icon: 'i-ph-lightbulb'
seo:
  title: 'Pemecahan Masalah'
  description: "Panduan referensi cepat untuk kesalahan umum (pitfalls) saat bekerja dengan operator JSON-Eval-RS dan cara menghindarinya."
---

## Daftar Isi

- [Kesalahan Akses Variabel](#kesalahan-akses-variabel)
- [Kesalahan Operasi Array](#kesalahan-operasi-array)
- [Kesalahan Aritmatika](#kesalahan-aritmatika)
- [Kesalahan Operasi String](#kesalahan-operasi-string)
- [Kesalahan Operasi Tanggal](#kesalahan-operasi-tanggal)
- [Kesalahan Perbandingan](#kesalahan-perbandingan)
- [Kesalahan Logika](#kesalahan-logika)

---

## Kesalahan Akses Variabel

### ❌ Menggunakan referensi variabel yang salah di operasi array

```json
// SALAH - merujuk ke field yang tidak ada
{"map": [
  [1, 2, 3],
  {"*": [{"var": "value"}, 2]}  // Mencari field bernama "value"
]}

// BENAR - gunakan string kosong untuk elemen saat ini
{"map": [
  [1, 2, 3],
  {"*": [{"var": ""}, 2]}
]}
```

**Mengapa:** Di dalam `map`, `filter`, `all`, `some`, `none`, elemen saat ini diakses dengan `{"var": ""}`.

---

### ❌ Lupa memberikan nilai default

```json
// SALAH - mungkin mengembalikan null tanpa diduga
{"var": "optional.field"}

// BENAR - berikan nilai default
{"var": ["optional.field", "nilai default"]}

// ATAU gunakan ifnull
{"ifnull": [{"var": "optional.field"}, "default"]}
```

**Mengapa:** Field yang hilang mengembalikan `null` yang mungkin memicu masalah dalam perhitungan.

---

## Kesalahan Operasi Array

### ❌ Tipe nilai awal reduce yang salah

```json
// SALAH - nilai awal tidak cocok dengan tipe akumulator
{"reduce": [
  array,
  {"merge": [{"var": "accumulator"}, [{"var": "current"}]]},
  0  // Seharusnya [] untuk akumulator array!
]}

// BENAR - cocokkan tipenya
{"reduce": [
  array,
  {"merge": [{"var": "accumulator"}, [{"var": "current"}]]},
  []  // Nilai awal berupa array
]}
```

**Mengapa:** Tipe nilai awal harus cocok dengan apa yang Anda bangun.

---

### ❌ Menambahkan pemisah sebelum item pertama di reduce

```json
// SALAH - menghasilkan ",a,b,c"
{"reduce": [
  ["a", "b", "c"],
  {"cat": [{"var": "accumulator"}, ",", {"var": "current"}]},
  ""
]}

// BENAR - pemisah kondisional
{"reduce": [
  ["a", "b", "c"],
  {"cat": [
    {"var": "accumulator"},
    {"if": [{">": [{"length": {"var": "accumulator"}}, 0]}, ",", ""]},
    {"var": "current"}
  ]},
  ""
]}
```

**Mengapa:** Pemisah ditambahkan sebelum mengecek apakah akumulator kosong.

---

### ❌ Kebingungan all/some/none dengan array kosong

```json
{"all": [[], kondisi]}   // → true (secara hampa benar - tidak ada contoh tandingan)
{"some": [[], kondisi]}  // → false (tidak ada elemen yang cocok)
{"none": [[], kondisi]}  // → true (tidak ada elemen yang cocok)
```

**Praktik Terbaik:** Selalu cek apakah array tidak kosong terlebih dahulu jika logika mengharapkannya:

```json
{"if": [
  {">": [{"length": array}, 0]},
  {"all": [array, kondisi]},
  defaultValue
]}
```

---

## Kesalahan Aritmatika

### ❌ Presisi floating point dalam perhitungan keuangan

```json
// SALAH - kesalahan presisi
{"+": [0.1, 0.2]}  // → 0.30000000000000004

// BENAR - selalu gunakan pembulatan (round)
{"round": [{"+": [0.1, 0.2]}, 2]}  // → 0.3
```

**Mengapa:** Floating point biner tidak dapat merepresentasikan semua desimal secara tepat.

---

### ❌ Tidak menangani pembagian dengan nol

```json
// SALAH - mengembalikan null tanpa diduga
{"/": [{"var": "total"}, {"var": "count"}]}  // null jika count=0

// BENAR - cek terlebih dahulu
{"if": [
  {"!=": [{"var": "count"}, 0]},
  {"/": [{"var": "total"}, {"var": "count"}]},
  0
]}

// ATAU gunakan ifnull
{"ifnull": [
  {"/": [{"var": "total"}, {"var": "count"}]},
  0
]}
```

**Mengapa:** Pembagian dengan nol mengembalikan `null` alih-alih melempar error.

---

### ❌ Persentase sebagai angka utuh, bukan desimal

```json
// SALAH - menggunakan 10 untuk 10%
{"*": [100, 10]}  // → 1000 (diharapkan 10)

// BENAR - gunakan desimal
{"*": [100, 0.1]}  // → 10

// ATAU bagi dengan 100
{"*": [100, {"/": [10, 100]}]}  // → 10
```

**Mengapa:** 10% berarti 0.1, bukan 10.

---

### ❌ Menggunakan + untuk penggabungan string (concatenation)

```json
// SALAH - memaksa string menjadi angka
{"+": ["Halo", " Dunia"]}  // → NaN atau 0

// BENAR - gunakan cat
{"cat": ["Halo", " Dunia"]}  // → "Halo Dunia"
```

**Mengapa:** Operator aritmatika selalu memaksa nilai menjadi angka.

---

## Kesalahan Operasi String

### ❌ Urutan parameter salah saat mencari (search)

```json
// SALAH - parameter tertukar
{"search": ["Halo Dunia", "Dunia"]}

// BENAR - teks yang dicari dulu, baru tempat mencarinya
{"search": ["Dunia", "Halo Dunia"]}  // → 6
```

**Mengapa:** Parameter pertama adalah apa yang dicari, parameter kedua adalah tempat mencarinya.

---

### ❌ Kebingungan indeks berbasis 0 vs berbasis 1

```json
// splittext menggunakan indeks berbasis 0
{"splittext": ["a,b,c", ",", 0]}  // → "a" (elemen pertama)
{"splittext": ["a,b,c", ",", 2]}  // → "c" (elemen ketiga)

// search mengembalikan posisi berbasis 1
{"search": ["Dunia", "Halo Dunia"]}  // → 6 (posisi 6, bukan 5)
```

**Mengapa:** Operator yang berbeda mengikuti konvensi yang berbeda.

---

### ❌ Tidak menangani null dalam penggabungan (concatenation)

```json
// SALAH - menghasilkan "Halo null"
{"cat": ["Halo ", {"var": "nama"}]}  // Jika nama bernilai null

// BENAR - berikan nilai default
{"cat": [
  "Halo ",
  {"ifnull": [{"var": "nama"}, "Tamu"]}
]}
```

**Mengapa:** `cat` mengubah null menjadi string "null".

---

## Kesalahan Operasi Tanggal

### ❌ Pengurangan tahun saja untuk menghitung umur

```json
// SALAH - tidak menghitung apakah sudah berulang tahun atau belum
{"-": [
  {"year": {"today": null}},
  {"year": {"var": "birthdate"}}
]}

// BENAR - gunakan DATEDIF
{"DATEDIF": [{"var": "birthdate"}, {"today": null}, "Y"]}
```

**Mengapa:** Umur bergantung pada apakah hari ulang tahun sudah terlewati tahun ini.

---

### ❌ Urutan parameter yang salah pada days

```json
// SALAH - mengembalikan angka negatif
{"days": [{"var": "startDate"}, {"var": "endDate"}]}  // → -14

// BENAR - tanggal akhir dulu
{"days": [{"var": "endDate"}, {"var": "startDate"}]}  // → 14
```

**Mengapa:** `days([akhir, awal])` mengembalikan `akhir - awal` dalam hitungan hari.

---

### ❌ Menggunakan format tanggal non-ISO

```json
// SALAH - format ambigu
{"year": "01/15/2024"}  // MM/DD atau DD/MM?
{"year": "15-01-2024"}  // Pemisah yang salah

// BENAR - gunakan ISO 8601
{"year": "2024-01-15"}  // → 2024
```

**Mengapa:** Hanya format ISO 8601 yang dijamin dapat di-parse dengan benar.

---

### ❌ Kebingungan kode unit DATEDIF

```json
// Kebingungan "M" vs "YM"
{"DATEDIF": ["1990-03-15", "2023-07-10", "M"]}   // → 399 (total bulan)
{"DATEDIF": ["1990-03-15", "2023-07-10", "YM"]}  // → 3 (sisa bulan)

// Untuk tampilan "33 tahun, 3 bulan":
{"cat": [
  {"DATEDIF": [awal, akhir, "Y"]}, " tahun, ",
  {"DATEDIF": [awal, akhir, "YM"]}, " bulan"
]}
```


---

## Kesalahan Perbandingan

### ❌ Menggunakan == saat tipe data itu penting

```json
// SALAH - perbandingan dengan paksaan tipe (coercion)
{"==": [0, false]}     // → true (tidak terduga)
{"==": [1, "1"]}       // → true (tidak terduga)

// BENAR - gunakan perbandingan ketat (strict equality)
{"===": [0, false]}    // → false
{"===": [1, "1"]}      // → false
```

**Mengapa:** `==` melakukan paksaan tipe, sementara `===` mengharuskan tipe data yang sama persis.

---

### ❌ Membandingkan string sebagai angka

```json
// SALAH - perbandingan leksikografis
{"<": ["10", "2"]}  // → true (perbandingan string: "1" < "2")

// BENAR - ubah menjadi angka
{"<": [
  {"ToNumber": ["10"]},
  {"ToNumber": ["2"]}
]}  // → false (10 > 2)
```

**Mengapa:** Operator perbandingan tidak secara otomatis mengubah string menjadi angka untuk pengurutan.

---

### ❌ Tidak memeriksa null sebelum perbandingan

```json
// SALAH - perbandingan null mungkin gagal
{">": [{"var": "age"}, 18]}  // Gagal jika age bernilai null

// BENAR - validasi terlebih dahulu
{"and": [
  {"!= !== [{"var": "age"}, null]},
  {">": [{"var": "age"}, 18]}
]}
```

**Mengapa:** Perbandingan dengan null dapat menghasilkan hasil yang tidak terduga.

---

## Kesalahan Logika

### ❌ Tidak memanfaatkan evaluasi hubung-singkat (short-circuit evaluation)

```json
// TIDAK EFISIEN - kedua kondisi selalu dievaluasi
{"if": [
  {"and": [pengecekan_mahal, pengecekan_murah]},
  ...
]}

// LEBIH BAIK - pengecekan murah di depan
{"if": [
  {"and": [pengecekan_murah, pengecekan_mahal]},
  ...
]}
```

**Mengapa:** `and` akan langsung berhenti pada nilai salah (falsy) pertama yang ditemukan.

---

### ❌ If bersarang alih-alih pola else-if

```json
// SALAH - struktur terlalu dalam
{"if": [
  kond1, val1,
  {"if": [
    kond2, val2,
    {"if": [kond3, val3, default]}
  ]}
]}

// LEBIH BAIK - struktur datar
{"if": [
  kond1, val1,
  kond2, val2,
  kond3, val3,
  default
]}
```

**Mengapa:** Operator `if` secara alami mendukung perantaian else-if.

---

### ❌ Menggunakan if bersarang untuk null coalescing

```json
// SALAH - terlalu panjang
{"if": [
  {"!= !== [{"var": "value"}, null]},
  {"var": "value"},
  "default"
]}

// LEBIH BAIK - gunakan ifnull
{"ifnull": [{"var": "value"}, "default"]}
```

**Mengapa:** `ifnull` dirancang khusus untuk pola ini.

---

## Referensi Cepat: Kesalahan Paling Umum

1. **Menggunakan `{"var": "field"}` alih-alih `{"var": ""}` dalam operasi array.**
2. **Lupa membulatkan (round) perhitungan keuangan.**
3. **Tidak menangani pembagian dengan nol.**
4. **Menggunakan `==` padahal tipe data itu penting (gunakan `===`).**
5. **Kejutan paksaan tipe (`+` memaksa ke angka, gunakan `cat` untuk string).**
6. **Menggunakan format tanggal yang salah (selalu gunakan ISO 8601: `"2024-01-15"`).**
7. **Tidak memberikan nilai default untuk field yang bisa bernilai null.**
8. **Urutan parameter yang salah (`search`, `days`, dll).**
9. **Masalah presisi floating point (selalu `round` angka desimal).**
10. **Kasus array kosong pada `all`/`some`/`none`.**

---

## Dokumentasi Terkait

- **[Ringkasan Operator](/operators/summary)** - Referensi cepat untuk semua operator.
- **[Operator Inti](/operators/core)** - Pola akses variabel.
- **[Operator Array](/operators/array)** - Pemecahan masalah operasi array.
- **[Operator Aritmatika](/operators/arithmetic)** - Masalah operasi matematika.
- **[Operator Perbandingan](/operators/comparison)** - Detail paksaan tipe data.
- **[Fungsi Tanggal](/operators/date)** - Praktik terbaik penanganan tanggal.

---

**Ingat:** Kebanyakan masalah berasal dari:
1. Tidak membaca dokumentasi untuk urutan parameter.
2. Mengasumsikan perilaku JavaScript/Excel tanpa mengecek.
3. Tidak menangani null atau kasus tepi (edge cases).
4. Kejutan paksaan tipe data.

Jika ragu, periksa dokumentasi operator terkait untuk contoh dan pemecahan masalah!
