> For the complete documentation index, see [llms.txt](https://navixy.com/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://navixy.com/docs/user/id/guide/account/iot-logic/nodes/missing-values-in-expressions.md).

# Nilai yang hilang dalam ekspresi

Pahami mengapa rumus atau kondisi IoT Logic tidak menghasilkan nilai ketika nilai yang dibutuhkannya tidak tersedia, dan pola perbandingan mana yang mencegahnya.

Rumus dan kondisi di IoT Logic bekerja pada nilai yang dikirimkan perangkat GPS. Ketika nilai yang dibutuhkan sebuah rumus tidak ada, sebagian besar operator tidak dapat menghasilkan hasil, dan rumus tidak menghasilkan apa pun sama sekali: bukan `false`, dan bukan nol. Halaman ini menjelaskan kapan sebuah nilai hilang, seperti apa kegagalannya, dan bagaimana menulis rumus dan kondisi yang tetap berfungsi. Halaman ini ditujukan bagi siapa saja yang mengonfigurasi aliran IoT Logic, dan tidak mengasumsikan latar belakang pemrograman.

Halaman ini berlaku untuk kedua tempat Anda menulis ekspresi:  **Formula** kolom pada sebuah [Inisiasi Atribut](https://navixy.com/docs/user/id/guide/account/iot-logic/nodes/initiate-attribute-node.md) node, dan **Ekspresi kondisi (JEXL)** kolom pada sebuah [Logika](https://navixy.com/docs/user/id/guide/account/iot-logic/nodes/logic-node.md) node.

## Ketika sebuah ekspresi tidak dapat menghasilkan nilai

Nilai kosong menghentikan seluruh ekspresi. Hal ini berlaku di kedua sisi perhitungan, perbandingan ukuran, pengujian awalan teks, atau operator logika `!`, `&&`, atau `||`. Dalam rumus dan di Penganalisis Data, nilai kosong muncul sebagai `null`.

Membaca atribut yang belum pernah dikirim oleh perangkat GPS bukanlah kesalahan itu sendiri. Yang terhenti adalah operator yang kemudian harus bekerja dengan nilai kosong. Satu nilai kosong menghentikan seluruh ekspresi, termasuk bagian yang memiliki nilai. Sebuah kondisi yang menguji empat geofence berhenti pada geofence pertama yang tidak dapat memberikan jawaban, dan tiga lainnya tidak pernah diuji. Pengecualiannya adalah istilah yang lebih awal dalam ekspresi yang sudah menentukan hasil.

## Apa yang Anda lihat ketika sebuah ekspresi tidak menghasilkan apa pun

Tidak ada penanda kegagalan. Hasilnya bergantung pada node mana yang memuat ekspresi:

| Tempat ekspresi dijalankan                                      | Apa yang terjadi pada paket data itu                                                                                 |
| --------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
| **Formula** kolom pada sebuah **Inisiasi Atribut** simpul       | Atribut tersebut tidak memiliki nilai untuk paket itu, dan Penganalisis Data menampilkannya sebagai `null`.          |
| **Ekspresi kondisi (JEXL)** kolom pada sebuah **Logika** simpul | Data keluar melalui koneksi ELSE, dan node menyimpan atributnya sendiri sebagai nilai kosong, bukan sebagai `false`. |

{% hint style="warning" %}
Tidak ada yang melaporkan kegagalan itu. Tidak ada kesalahan yang muncul di aliran, tidak ada penghitung yang berubah, dan setiap atribut lainnya tetap dihitung secara normal. Satu-satunya tanda adalah nilai yang hilang itu sendiri, sehingga sebuah aliran dapat terlihat sehat sementara satu atribut tidak menghasilkan nilai selama berminggu-minggu.

Menyimpan aliran juga tidak membuktikan bahwa sebuah rumus berfungsi. Pemeriksaan yang berjalan saat Anda menyimpan memastikan bahwa ekspresi ditulis dengan benar. Pemeriksaan itu tidak menjalankan ekspresi terhadap data perangkat GPS Anda, sehingga rumus yang tidak menghasilkan apa pun pada setiap paket tetap tersimpan tanpa peringatan.
{% endhint %}

## Bagaimana setiap operator menangani nilai kosong

Empat operator selalu tetap bekerja pada nilai kosong: `==`, `!=`, `=~`, dan `!~`. Operator `&&` dan `||` tetap bekerja hanya ketika sisi yang dibaca terlebih dahulu sudah menentukan jawabannya. Semua operator lainnya berhenti.

Tabel ini mencakup atribut yang Anda rujuk berdasarkan nama, yang merupakan bentuk yang [autofill](https://navixy.com/docs/user/id/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#autofill-attribute-names) disisipkan. Empat operator berperilaku berbeda ketika nilai berasal dari `value()` sebagai gantinya. Lihat [Membaca berdasarkan nama atau dengan value()](#reading-by-name-or-with-value).

| Operator                                                   | Dengan nilai kosong di salah satu sisi                                                                                                  |
| ---------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| `==`, `!=` (sama dengan, tidak sama dengan)                | Memberikan ya atau tidak yang sebenarnya. `null == null` adalah `true`, dan `null != null` adalah `false`.                              |
| `=~`, `!~` (ada dalam daftar, atau cocok dengan pola teks) | Memberikan ya atau tidak yang sebenarnya. Nilai kosong tidak pernah cocok, sehingga `=~` memberikan `false` dan `!~` memberikan `true`. |
| `??` (gunakan nilai cadangan)                              | Memberikan nilai di sebelah kanan. Nilai ini hanya menggantikan nilai kosong.                                                           |
| `?:` (gunakan nilai cadangan)                              | Memberikan nilai di sebelah kanan. Nilai ini juga menggantikan `false`, untuk `0`, dan untuk teks kosong.                               |
| `a ? b : c` (memilih antara dua nilai)                     | Mengambil cabang `c` , sama seperti pada `false`.                                                                                       |
| `=^`, `!^`, `=$`, `!$` (diawali dengan, diakhiri dengan)   | Ekspresi tidak menghasilkan apa pun.                                                                                                    |
| `<`, `<=`, `>`, `>=` (perbandingan ukuran)                 | Ekspresi tidak menghasilkan apa pun.                                                                                                    |
| `+`, `-`, `*`, `/`, `%` (aritmetika)                       | Ekspresi tidak menghasilkan apa pun.                                                                                                    |
| `&`, `\|`, `^` (operasi bit)                               | Ekspresi tidak menghasilkan apa pun.                                                                                                    |
| `!` (tidak)                                                | Ekspresi tidak menghasilkan apa pun.                                                                                                    |
| `&&`, `\|\|` (dan, atau)                                   | Ekspresi tidak menghasilkan apa pun, kecuali sisi yang dibaca terlebih dahulu sudah menentukan jawabannya.                              |

Enam operator teks terbagi menjadi dua. `=~` dan `!~` bertahan pada nilai kosong, tetapi `=^`, `!^`, `=$`, dan `!$` tidak ketika atribut dirujuk dengan nama. Suatu kondisi seperti `hardware_key !^ 'AB'` terlihat seperti cara aman untuk mengecualikan prefiks, tetapi tidak menghasilkan apa pun pada setiap paket tanpa `hardware_key`.

Tab `matematika:` fungsi tidak menghasilkan apa pun ketika menerima nilai kosong, jadi `math:round(engine_temp)` tidak menghasilkan apa pun ketika `engine_temp` hilang. The `util:` fungsi lebih toleran dan mengembalikan nilai kosong sebagai gantinya, sehingga `util:join` dan `util:joinNonNull` tetap menghasilkan hasil saat salah satu argumennya hilang. Menggabungkan teks dengan `+` tidak toleran: `'Zone: ' + zone_label` tidak menghasilkan apa pun.

## Operator logika dengan nilai kosong

Urutan penting untuk keduanya `&&` dan `||`. Setiap operator membaca sisi kiri terlebih dahulu dan berhenti di sana ketika sisi kiri sudah menentukan hasil. Sebuah `false` sisi kiri menentukan `&&`, dan sebuah `true` sisi kiri menentukan `||`.

| Ekspresi                | Hasil                                                                                      |
| ----------------------- | ------------------------------------------------------------------------------------------ |
| `false && (kosong)`     | `false`. Sisi kiri bernilai false menentukan AND, sehingga sisi kanan tidak pernah dibaca. |
| `true && (kosong)`      | Tidak menghasilkan apa pun.                                                                |
| `(kosong) && apa pun`   | Tidak menghasilkan apa pun. Sisi kiri dibaca terlebih dahulu.                              |
| `true \|\| (kosong)`    | `true`. Sisi kiri bernilai true menentukan OR, sehingga sisi kanan tidak pernah dibaca.    |
| `false \|\| (kosong)`   | Tidak menghasilkan apa pun.                                                                |
| `(kosong) \|\| apa pun` | Tidak menghasilkan apa pun. Sisi kiri dibaca terlebih dahulu.                              |

Menempatkan istilah yang mungkin kosong di akhir hanya membantu ketika sisi kiri menetapkan hasil pada paket itu. Anda jarang dapat menjamin hasil tersebut, jadi bandingkan nilainya secara eksplisit saja.

## Membaca berdasarkan nama atau dengan value()

Empat operator memberikan hasil berbeda untuk nilai yang sama yang hilang, bergantung pada bagaimana rumus membacanya. Operatornya adalah `=^`, `!^`, `=$` dan `!$`, yang menguji awal atau akhir nilai teks.

| Formula                                | Hasil saat `supir_id` tidak pernah dikirim |
| -------------------------------------- | ------------------------------------------ |
| `supir_id !^ 'AB'`                     | Tidak menghasilkan apa pun                 |
| `value('driver_id', 0, 'all') !^ 'AB'` | `true`                                     |

Mereferensikan atribut berdasarkan nama adalah Formulir yang [autofill](https://navixy.com/docs/user/id/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#autofill-attribute-names) penyisipan, sehingga kondisi yang dibuat dengan pemilih atribut mengambil jalur pertama. Tuliskan perbandingan dengan `value()` saat Anda perlu `!^` atau `!$` untuk melaporkan `true` pada paket yang tidak membawa atribut tersebut.

Setiap operator lainnya berperilaku sama dalam kedua bentuk. Perbandingan ukuran, aritmetika, dan `!` semuanya tidak menghasilkan apa pun dengan cara apa pun, dan `==`, `!=`, `=~` dan `!~` semuanya memberikan jawaban ya atau tidak yang jelas, apa pun pilihannya.

Pemisahan yang sama berlaku untuk kedua bentuk cadangan. `??` dan `? :` dapat berisi hasil perhitungan yang gagal ketika nilainya berasal dari `value()`, dan tidak dapat jika berasal dari nama:

| Formula                                  | Hasil saat `odometer` tidak pernah dikirim |
| ---------------------------------------- | ------------------------------------------ |
| `(odometer + 1) ?? 0`                    | Tidak menghasilkan apa pun                 |
| `(value('odometer', 0, 'all') + 1) ?? 0` | `0`                                        |

Ekspresi biasa `??` pada sebuah nama masih berfungsi, karena tidak ada perhitungan yang terjadi sebelumnya. Hanya perhitungan yang dibungkus di dalam `??` atau `? :` berperilaku berbeda.

## Bandingkan nilai secara eksplisit

Untuk membuat nilai yang mungkin kosong aman dalam sebuah kondisi, bandingkan dengan `== true` atau `== false` daripada menggunakannya sendiri. Keduanya `==` dan `!=` memberikan jawaban ya atau tidak yang nyata untuk nilai kosong, sehingga satu istilah yang tidak memiliki data tidak lagi menghentikan seluruh kondisi.

Kondisi ini berhenti pada paket apa pun ketika salah satu dari dua atribut hilang:

```jexl
door_open || hood_open
```

Kondisi ini tetap berfungsi, dan melaporkan ya ketika salah satu pintu terbuka:

```jexl
door_open == true || hood_open == true
```

Fungsi perimeter berperilaku sama, karena fungsi tersebut mengembalikan nilai kosong ketika sebuah paket tidak membawa posisi. Kondisi ini berhenti segera setelah salah satu fungsi tidak dapat menjawab:

```jexl
leaveGeofence(51577 /* Austin Warehouse */) || leaveGeofence(85269 /* Construction site 1 */)
```

Kondisi ini menguji kedua perimeter pada setiap paket:

```jexl
leaveGeofence(51577 /* Austin Warehouse */) == true || leaveGeofence(85269 /* Construction site 1 */) == true
```

Pilih perbandingan yang sesuai dengan bagaimana paket tanpa data harus dihitung:

* `== true` berarti "diketahui bernilai ya". Nilai kosong menghasilkan `false`false
* `== false` berarti "diketahui bernilai tidak". Nilai kosong menghasilkan `false`false
* `!= true` berarti "tidak diketahui bernilai ya". Nilai kosong menghasilkan `true`false

{% hint style="warning" %}
Jangan gunakan `!` pada nilai yang mungkin kosong. `!inGeofence(35229)` tidak menghasilkan apa pun ketika posisi tidak diketahui, sehingga tidak dapat mendeteksi perangkat di luar perimeter. Tulis `inGeofence(35229) == false` untuk "diketahui berada di luar", atau `inGeofence(35229) != true` untuk "tidak diketahui berada di dalam".
{% endhint %}

## Asal nilai kosong

Atribut dalam sebuah rumus menjadi nilai kosong dalam kasus berikut:

* Atribut tersebut tidak pernah dikirim untuk perangkat GPS itu.
* Paket saat ini tidak membawa atribut tersebut, meskipun paket sebelumnya membawanya.
* Posisi riwayat yang Anda minta dengan `value()` belum ada, karena perangkat telah mengirim lebih sedikit paket daripada yang disyaratkan oleh posisi tersebut.
* Perangkat tidak mengirim apa pun selama lebih dari 30 hari, sehingga Navixy menghapus riwayat yang disimpannya. Lihat [Sintaks lengkap](https://navixy.com/docs/user/id/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#full-syntax).
* `inGeofence()`, `enterGeofence()`, atau `leaveGeofence()` tidak dapat menjawab, karena paket tidak membawa koordinat atau perimeter tidak lagi ada di akun. Lihat [Saat fungsi Perimeter tidak memberikan jawaban](https://navixy.com/docs/user/id/guide/account/iot-logic/nodes/geofence-functions.md#when-a-geofence-function-gives-no-answer).
* `geofenceName()` tidak memiliki nama untuk dikembalikan. Lihat [Apa yang Anda dapatkan kembali](https://navixy.com/docs/user/id/guide/account/iot-logic/nodes/geofence-functions.md#what-you-get-back).

Semua penyebab ini tampak sama dalam sebuah rumus. Rumus yang harus tetap berfungsi harus menangani nilai kosong, bukan penyebabnya.

## Rumus yang harus selalu menghasilkan nilai

Lindungi perhitungan dengan `!= null`, dan letakkan pengecekan itu terlebih dahulu. Pengecekan itu menggunakan `!=`, yang memberikan jawaban ya atau tidak yang nyata untuk nilai kosong, sehingga pengecekan itu sendiri tidak pernah berhenti:

```jexl
value('odometer', 0, 'all') != null && value('odometer', 0, 'all') > 100
```

Urutan inilah yang membuat pengecekan bekerja. Jika Anda membalik istilah-istilah tersebut, perbandingan dijalankan sebelum pengecekan, dan seluruh kondisi tidak menghasilkan apa pun.

Untuk menggantikan nilai cadangan sebagai gantinya, gunakan `??`. Nilai di sisi kanan hanya dikembalikan ketika sisi kiri kosong:

```jexl
can_speed ?? 0
```

`??` menggantikan nilai yang hilang, bukan hasil perhitungan yang gagal. `(can_speed * 1.1) ?? 0` tidak menghasilkan apa pun ketika `can_speed` tidak ada, karena perkalian berhenti sebelum `??` dicapai. Letakkan `??` di sekitar atribut, bukan di sekitar perhitungannya:

```jexl
(can_speed ?? 0) * 1.1
```

{% hint style="warning" %}
`?:` dan `??` terlihat serupa dan berperilaku berbeda. `??` menggantikan sisi kanan hanya untuk nilai kosong. `?:` menggantinya untuk nilai kosong dan juga untuk `false`, untuk `0`, dan untuk teks kosong. Rumus `pengapian ?: true` oleh karena itu laporan `true` ketika pengapian benar-benar mati. Gunakan `??` ketika yang Anda maksud adalah "jika nilai tidak ada".
{% endhint %}

Anda juga dapat mengendalikan perhitungan dari luar rumus. Letakkan sebuah **Logika** node sebelum **Inisiasi Atribut** node, dan uji keberadaan atribut dalam kondisinya. Hubungkan jalur THEN ke node penghitungan, sehingga node tersebut hanya menerima paket yang memuat nilai yang dibutuhkannya.

Hubungkan jalur ELSE ke sebuah **Titik Akhir Output** node juga. Cabang yang berakhir tanpa node akan membuang setiap paket yang mencapainya, sehingga paket yang gagal dalam uji keberadaan tidak pernah keluar dari aliran.

Ketika tidak ada nilai lebih baik daripada nilai yang salah, atribut tanpa nilai adalah hasil yang benar. Tambahkan nilai cadangan hanya ketika sistem di hilir aliran memerlukan nilai pada setiap paket.

## Periksa apakah sebuah ekspresi tidak menghasilkan apa pun

Mulailah dari apa yang dapat Anda lihat di [Penganalisis Data](https://navixy.com/docs/user/id/guide/account/iot-logic/data-stream-analyzer.md):

1. Pilih aliran, lalu perangkat GPS dan atribut terhitung.
2. Nonaktifkan **Kecualikan null** sakelar. Perhitungan yang gagal muncul sebagai sebuah `null` nilai. Sakelar tersebut menyembunyikan nilai-nilai itu saat diaktifkan.
3. Tingkatkan kedalaman jika paket yang Anda cari lebih lama daripada nilai yang ditampilkan di layar.
4. Bandingkan atribut dengan atribut yang dibaca oleh formulanya. Paket yang input formulanya memiliki nilai dan atribut terhitungnya adalah `null` mengarah ke formula.
5. Periksa setiap operator dalam formula terhadap [Bagaimana setiap operator menangani nilai kosong](#how-each-operator-handles-an-empty-value).
6. Tulis ulang setiap bagian yang mungkin kosong. Gunakan `== true`, `== false`, atau sebuah `??` cadangan.

{% hint style="warning" %}
Saat **Kecualikan null** aktif, nilai terakhir yang dihasilkan formula tetap tampil di layar dengan cap waktu lamanya sendiri. Pembacaan tampak terkini, tetapi berasal dari paket sebelumnya. Matikan sakelar sebelum Anda menilai apakah IoT Logic masih menghitung suatu atribut.
{% endhint %}

## Pertanyaan yang sering diajukan

#### Apakah nilai kosong sama dengan `false`?

Tidak. Kondisi yang benar-benar `false` menyimpan `false`, dan kondisi yang tidak dapat dievaluasi menyimpan nilai kosong. Keduanya mengirim data melalui koneksi ELSE dari sebuah **Logika** node, jadi dari cabang itu saja Anda tidak dapat mengetahui mana yang terjadi. Ekspresi berikutnya yang menguji atribut dengan `my_flag == false` mencocokkan hanya kasus pertama.

#### Mengapa satu perangkat GPS berhenti cocok dengan suatu kondisi yang masih berfungsi untuk yang lain?

Perangkat dari model yang berbeda tidak semuanya mengirim atribut yang sama, dan satu perangkat dapat berhenti melaporkan atribut yang masih dikirim perangkat lainnya. Kondisi yang membaca atribut itu tanpa perbandingan kemudian tidak menghasilkan apa-apa hanya untuk perangkat tersebut. Bandingkan setiap istilah secara eksplisit dengan `== true` atau `== false`.

## Lihat juga

* [ekspresi dan sintaks Logika](https://navixy.com/docs/user/id/guide/account/iot-logic/nodes/logic-node/logic-node-expressions-and-syntax.md#missing-values-and-null-routing) untuk melihat cabang mana yang diambil node Logic dan apa yang disimpannya.
* [Fungsi perimeter](https://navixy.com/docs/user/id/guide/account/iot-logic/nodes/geofence-functions.md) untuk kasus saat fungsi Perimeter tidak dapat menjawab.
* [Mengelola atribut](https://navixy.com/docs/user/id/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#expression-language) untuk `value()` fungsi dan dua opsi sintaks.
* [Contoh perhitungan](https://navixy.com/docs/user/id/guide/account/iot-logic/nodes/initiate-attribute-node/calculation-examples.md) untuk contoh formula.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://navixy.com/docs/user/id/guide/account/iot-logic/nodes/missing-values-in-expressions.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
