---
title: 'Perbandingan'
description: "Operator perbandingan nilai yang mengembalikan hasil boolean."
navigation:
  icon: 'i-ph-code-block'
seo:
  title: 'Perbandingan'
  description: "Operator perbandingan nilai yang mengembalikan hasil boolean."
---

## Tinjauan

Operator perbandingan mengevaluasi hubungan antara nilai-nilai dan mengembalikan `true` atau `false`. Mereka sangat mendasar untuk membangun logika kondisional, aturan validasi, dan kontrol alur dalam evaluasi JSON.

### Kapan Menggunakan Operator Perbandingan

- **Validasi**: Periksa apakah input pengguna memenuhi persyaratan.
- **Aturan Bisnis**: Terapkan batasan usia, batas harga, rentang tanggal.
- **Logika Kondisional**: Cabangkan eksekusi berdasarkan hubungan nilai.
- **Penyaringan (Filtering)**: Pilih data yang cocok dengan kriteria tertentu.
- **Kontrol Akses**: Verifikasi izin dan tingkat otorisasi.

### Koersi Tipe vs Perbandingan Ketat

JSON-EvalRS menyediakan dua mode perbandingan:

1. **Kesetaraan Longgar** (`==`, `!=`): Melakukan koersi tipe (type coercion) sebelum perbandingan.
2. **Kesetaraan Ketat** (`===`, `!==`): Tidak ada koersi tipe, tipe data harus cocok.

**Kapan menggunakan masing-masing:**
- Gunakan **ketat** (`===`) ketika keamanan tipe penting (misalnya, membedakan `0` dari `false`).
- Gunakan **longgar** (`==`) saat membandingkan nilai yang mungkin memiliki representasi berbeda (misalnya, string "1" vs angka 1).

---

## `==` - Sama Dengan (Longgar)

Memeriksa apakah dua nilai sama dengan koersi tipe.

### Sintaks
```json
{"==": [value1, value2]}
```

### Parameter
- **value1** (any): Nilai pertama
- **value2** (any): Nilai kedua

### Tipe Kembalian
Boolean - `true` jika nilai-nilai tersebut sama (setelah koersi tipe)

### Contoh

**Kesetaraan dasar:**
```json
{"==": [1, 1]}           // → true
{"==": ["halo", "halo"]} // → true
{"==": [true, true]}     // → true
```

**Koersi tipe:**
```json
{"==": [1, "1"]}         // → true (string dikoersi ke angka)
{"==": [0, false]}       // → true (boolean dikoersi ke angka)
{"==": [null, null]}     // → true
{"==": ["", false]}      // → true (keduanya falsy)
```

**Dengan variabel:**
```json
// Data: {"age": 30, "minAge": 30}
{"==": [{"var": "age"}, {"var": "minAge"}]}
// → true
```

**Membandingkan nilai hasil perhitungan:**
```json
// Data: {"price": 100, "discount": 20}
{"==": [
  {"-": [{"var": "price"}, {"var": "discount"}]},
  80
]}
// → true
```

### Aturan Koersi Tipe

- Angka dan string: String dikonversi ke angka
- Boolean dan angka: `true` → 1, `false` → 0
- `null` hanya sama dengan `null` (dan `""` dalam mode longgar)
- Objek dan array: Perbandingan referensi (hanya jika instansi yang sama)

---

## `===` - Sama Dengan Ketat

Memeriksa apakah dua nilai sama tanpa koersi tipe.

### Sintaks
```json
{"===": [value1, value2]}
```

### Parameter
Sama seperti `==`

### Tipe Kembalian
Boolean - `true` jika nilai-nilai tersebut sama dan bertipe sama

### Contoh

**Kesetaraan ketat:**
```json
{"===": [1, 1]}           // → true
{"===": [1, "1"]}         // → false (tipe berbeda)
{"===": [0, false]}       // → false (angka vs boolean)
{"===": [null, null]}     // → true
{"===": ["", ""]}         // → true
```

**Ketika tipe data penting:**
```json
// API mengembalikan string "0" untuk tidak aktif, angka 0 untuk error
// Data: {"status":0}
{"===": [{"var": "status"}, "0"]}    // → false
{"===": [{"var": "status"}, 0]}      // → true
```

---

## `!=` - Tidak Sama Dengan

Memeriksa apakah dua nilai tidak sama dengan koersi tipe.

### Sintaks
```json
{"!=": [value1, value2]}
```

### Parameter
Sama seperti `==`

### Tipe Kembalian
Boolean - `true` jika nilai-nilai tidak sama (setelah koersi tipe)

### Contoh

**Ketidaksamaan dasar:**
```json
{"!=": [1, 2]}            // → true
{"!=": [1, "1"]}          // → false (dikoersi menjadi sama)
{"!=": ["a", "b"]}        // → true
```

**Validasi:**
```json
// Pastikan password dan konfirmasi tidak berbeda
{"!=": [{"var": "password"}, {"var": "confirmPassword"}]}
// → true berarti password tidak cocok (validasi gagal)
```

---

## `!==` - Tidak Sama Dengan Ketat

Memeriksa apakah dua nilai tidak sama tanpa koersi tipe.

### Sintaks
```json
{"!==": [value1, value2]}
```

### Parameter
Sama seperti `==`

### Tipe Kembalian
Boolean - `true` jika nilai berbeda dalam nilai atau tipe

### Contoh

**Ketidaksamaan ketat:**
```json
{"!==": [1, "1"]}         // → true (tipe berbeda)
{"!==": [1, 1]}           // → false (nilai dan tipe sama)
{"!==": [0, false]}       // → true (tipe berbeda)
```

---

## `<` - Kurang Dari

Membandingkan apakah nilai pertama lebih kecil dari nilai kedua.

### Sintaks
```json
{"<": [value1, value2]}
```

### Parameter
- **value1** (number/string): Nilai pertama
- **value2** (number/string): Nilai kedua

### Tipe Kembalian
Boolean - `true` jika value1 < value2

### Contoh

**Perbandingan numerik:**
```json
{"<": [5, 10]}            // → true
{"<": [10, 5]}            // → false
{"<": [5, 5]}             // → false
```

**Perbandingan string (leksikografis):**
```json
{"<": ["a", "b"]}         // → true
{"<": ["apple", "banana"]} // → true (alfabetis)
{"<": ["10", "2"]}        // → true (perbandingan string, bukan numerik)
```

---

## `<=` - Kurang Dari atau Sama Dengan

Membandingkan apakah nilai pertama kurang dari atau sama dengan nilai kedua.

### Sintaks
```json
{"<=": [value1, value2]}
```

### Parameter
Sama seperti `<`

### Tipe Kembalian
Boolean - `true` jika value1 ≤ value2

### Contoh

**Perbandingan dasar:**
```json
{"<=": [5, 10]}           // → true
{"<=": [10, 10]}          // → true (sama dengan)
{"<=": [11, 10]}          // → false
```

---

## `>` - Lebih Dari

Membandingkan apakah nilai pertama lebih besar dari nilai kedua.

### Sintaks
```json
{">": [value1, value2]}
```

### Parameter
Sama seperti `<`

### Tipe Kembalian
Boolean - `true` jika value1 > value2

### Contoh

**Perbandingan numerik:**
```json
{">": [10, 5]}            // → true
{">": [5, 10]}            // → false
{">": [10, 10]}           // → false
```

---

## `>=` - Lebih Dari atau Sama Dengan

Membandingkan apakah nilai pertama lebih besar dari atau sama dengan nilai kedua.

### Sintaks
```json
{">=": [value1, value2]}
```

### Parameter
Sama seperti `<`

### Tipe Kembalian
Boolean - `true` jika value1 ≥ value2

### Contoh

**Perbandingan dasar:**
```json
{">=": [10, 5]}           // → true
{">=": [10, 10]}          // → true (sama dengan)
{">=": [5, 10]}           // → false
```

---

## Contoh Kompleks

### Validasi Rentang (Antara Min dan Max)

```json
{"and": [
  {">=": [{"var": "value"}, 10]},
  {"<=": [{"var": "value"}, 100]}
]}
// Mengembalikan true jika 10 ≤ value ≤ 100
```

### Kalkulator Nilai

```json
{"if": [
  {">=": [{"var": "score"}, 90]}, "A",
  {">=": [{"var": "score"}, 80]}, "B",
  {">=": [{"var": "score"}, 70]}, "C",
  {">=": [{"var": "score"}, 60]}, "D",
  "E"
]}
```

---

## Praktik Terbaik

1. **Gunakan Kesetaraan Ketat untuk Keamanan Tipe**
   Selalu gunakan `===` jika tipe data sangat penting.

2. **Gabungkan Perbandingan untuk Rentang**
   Gunakan `and` untuk memvalidasi rentang nilai secara jelas.

3. **Urutan Penting dalam Rantai Kondisi**
   Letakkan kondisi yang paling spesifik atau terbatas di awal.

4. **Gunakan Let untuk Perbandingan Berulang**
   Cache nilai yang digunakan berkali-kali untuk efisiensi.

5. **Pertimbangkan Presisi Floating Point**
   Untuk perbandingan desimal, gunakan pembulatan (`round`) terlebih dahulu.

---

## Troubleshooting

### Masalah: Hasil tidak terduga dengan koersi tipe
Gunakan kesetaraan ketat (`===`) untuk menghindari konversi tipe otomatis yang tidak diinginkan.

### Masalah: Perbandingan string vs angka
Pastikan kedua nilai memiliki tipe yang sama (misalnya, konversi string ke angka dengan `ToNumber`) sebelum dibandingkan secara numerik.

### Masalah: Perbandingan Null
Gunakan cek null secara eksplisit dengan `=== null` atau `!== null` untuk hasil yang lebih dapat diprediksi.
