> 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/logic-node/logic-node-expressions-and-syntax.md). # Ekspresi dan sintaks Logika Tulis ekspresi Logika menggunakan bahasa ekspresi berbasis JEXL Navixy. Ekspresi merutekan data dengan mengevaluasi menjadi benar atau salah, meskipun nilai yang hilang dapat berperilaku berbeda. ## Dasar-dasar ekspresi Node Logika menggunakan [Bahasa Ekspresi IoT Logic Navixy](/docs/iot-logic-api/technologies/navixy-iot-logic-expression-language.md), yang berbasis Java Expression Language (JEXL). Ekspresi dimaksudkan untuk mengembalikan `true` atau `false`, tetapi nilai yang hilang tidak selalu mengikuti aturan itu. Beberapa operator meneruskan nilai yang hilang ke THEN alih-alih ELSE, dan beberapa membiarkan atribut yang disimpan `null` daripada `false`. Lihat [Nilai yang hilang dan perutean null](#missing-values-and-null-routing) sebelum mengandalkan perbandingan agar gagal dengan aman. **Evaluasi ekspresi**: Ekspresi dievaluasi dari kiri ke kanan, dan Anda dapat menggunakan tanda kurung untuk mengontrol urutan operasi. **Contoh sintaks dasar**: ```jexl condition1 && (condition2 || condition3 > condition4) ``` ## Operator yang tersedia ### Operator perbandingan

Operator	Deskripsi
`==`	Memeriksa apakah dua operan sama. Jika operan memiliki jenis yang berbeda, JEXL mengonversinya menjadi satu jika memungkinkan
`!=`	Memeriksa ketidaksamaan dua operan. Mengembalikan true jika operan tidak sama
`<`	Memeriksa apakah operan kiri lebih kecil daripada operan kanan
`<=`	Memeriksa apakah operan kiri lebih kecil atau sama dengan operan kanan
`>`	Memeriksa apakah operan kiri lebih besar daripada operan kanan
`>=`	Memeriksa apakah operan kiri lebih besar atau sama dengan operan kanan

Untuk mengetahui bagaimana nilai yang hilang memengaruhi perutean, lihat [Nilai yang hilang dan perutean null](#missing-values-and-null-routing). ### Operator logika

Operator	Deskripsi
`&&` atau `dan`	Logical AND - memeriksa apakah dua kondisi bernilai benar. Mengembalikan true jika kedua kondisi bernilai benar
`\|\|` atau `atau`	Logical OR - memeriksa kebenaran setidaknya salah satu dari dua kondisi
`!` atau `tidak`	Logical NOT - mengubah hasil kondisi menjadi nilai kebalikannya

### Operator pencocokan pola

Operator	Deskripsi
`=~`	Memeriksa apakah nilai operan kiri berada dalam himpunan operan kanan. Untuk string, memeriksa kecocokan pola regex
`!~`	Memeriksa apakah nilai operan kiri tidak berada dalam himpunan operan kanan. Untuk string, memeriksa ketidakcocokan pola regex
`=^`	Memeriksa apakah operan string kiri diawali dengan operan string kanan
`!^`	Memeriksa apakah operan string kiri tidak diawali dengan operan string kanan
`=$`	Memeriksa apakah operan string kiri diakhiri dengan operan string kanan
`!$`	Memeriksa apakah operan string kiri tidak diakhiri dengan operan string kanan

### Fungsi Perimeter Tiga fungsi mengevaluasi posisi perangkat relatif terhadap perimeter Navixy yang diberi nama, dan satu fungsi keempat mengembalikan nama perimeter yang ditempati perangkat. Untuk petunjuk penggunaan dan contoh, lihat [Fungsi Perimeter](/docs/user/id/guide/account/iot-logic/nodes/geofence-functions.md).

Fungsi	Parameter	Mengembalikan true ketika
`inGeofence(id)`	ID perimeter	Perangkat saat ini berada di dalam perimeter
`enterGeofence(id)`	ID perimeter	Perangkat baru saja memasuki perimeter
`leaveGeofence(id)`	ID perimeter	Perangkat baru saja keluar dari perimeter

**Posisi saat ini:** ```jexl inGeofence(35229 /* Delivery zone #4 */) ``` Nama perimeter muncul sebagai komentar untuk keterbacaan dan tidak memengaruhi evaluasi. Pemilih perimeter menyisipkan format ini secara otomatis. **Posisi historis:** ```jexl inGeofence(35229 /* Delivery zone #4 */, 1, 'valid') ``` Parameter kedua adalah indeks paket data (0 untuk yang saat ini, 1 untuk yang sebelumnya, hingga 11), dan parameter ketiga adalah filter validitas, mengikuti konvensi yang sama seperti `value()`. Keduanya opsional, dan keduanya berlaku untuk `inGeofence()` saja. `enterGeofence()` dan `leaveGeofence()` mengambil ID perimeter dan tidak ada yang lain. Jangan membungkus fungsi perimeter di dalam `value()`: parameter pertama dari `value()` adalah nama atribut, bukan ekspresi. ## Contoh ekspresi

Contoh kondisi dasar

**Pemeriksaan kesetaraan**: ``` value('lock_state', 0, 'valid') == 'sealed' door_state_2 == 0 ``` **Pemeriksaan ketaksamaan**: ``` value('lock_state', 1, 'valid') != 'unknown' avl_io_221 != null ``` **Peringatan nilai hilang**: `!=` terhadap literal non-null akan mengarahkan nilai yang hilang ke THEN, bukan ELSE. Aman: penjaga keberadaan membatasi pemeriksaan pada paket yang membawa atribut tersebut. ``` value('temperature', 0, 'all') != null && value('temperature', 0, 'all') > 50 ``` Tidak aman: ini aktif pada `temperature`paket-paket pertamanya sebelum ia memiliki riwayat apa pun, karena `!=` memperlakukan nilai yang hilang sebagai tidak sama dengan literal apa pun. ``` value('temperature', 1, 'all') != 75 ``` **Perbandingan numerik**: ``` value('humidity', 1, 'all') < 80 value('humidity', 1, 'all') <= 80 value('humidity', 0, 'valid') > 80 value('humidity', 0, 'valid') >= 80 ``` **Pemantauan suhu**: ``` value('temperature', 0, 'valid') > 75 ``` Ekspresi ini dipicu saat suhu melebihi 75 derajat, berguna untuk Aturan peringatan panas berlebih. **Deteksi pelanggaran kecepatan**: ``` value('speed', 0, 'valid') > 80 ``` Ekspresi ini mengidentifikasi ketika Kendaraan melampaui batas kecepatan 80 km/jam. **Pemantauan kesehatan perangkat**: ``` value('battery_voltage', 0, 'valid') < 11.5 ``` Ekspresi ini mendeteksi kondisi baterai rendah yang memerlukan perhatian pemeliharaan. **Aturan peringatan level Bahan bakar**: ``` value('fuel_level', 0, 'valid') < 20 ``` Ekspresi ini mengidentifikasi ketika tingkat bahan bakar turun di bawah 20%, sehingga memungkinkan pengisian bahan bakar secara proaktif.

Contoh operator logika

**operasi AND**: ``` value('temperature', 0, 'valid') > 15 && value('humidity', 0, 'valid') > 80 value('temperature', 0, 'valid') > 15 and value('humidity', 0, 'valid') > 80 ``` **Operasi OR**: ``` temperature < 10 || humidity > 80 temperature < 10 or humidity > 80 ``` **Operasi NOT**: ``` !condition not condition ```

Contoh pencocokan pola

**Keanggotaan himpunan**: ``` value('lock_state', 0, 'valid') =~ ['locked','unlocked'] value('driver_name', 0, 'valid') !~ ['John', 'Steve'] ``` **Pencocokan pola string**: ``` supir_id =^ 'cc6f8216' supir_id !^ 'cc6f8216' value('engine_hours', 0, 'valid') =$ '1000' value('driver_id', 0, 'valid') !$ '8b38851c3c68' ```

Contoh multi-kondisi yang kompleks

**Peringatan kecepatan berlebih di luar jam operasional**: ``` value('speed', 0, 'valid') > 60 && (value('current_hour', 0, 'valid') >= 18 || value('current_hour', 0, 'valid') <= 6) ``` Ini menggabungkan pemantauan kecepatan dengan kondisi berbasis waktu untuk meningkatkan pengawasan keselamatan selama shift malam. **Diagnostik perangkat komprehensif**: ``` value('gps_satellites', 0, 'valid') >= 4 && value('battery_voltage', 0, 'valid') > 11.5 && value('signal_strength', 0, 'valid') > -80 ``` Ini memvalidasi beberapa parameter kesehatan perangkat secara bersamaan untuk memastikan pengoperasian yang andal. **Pemantauan keselamatan Supir**: ``` value('harsh_braking', 0, 'valid') == true && value('Supir_identified', 0, 'valid') == false ``` Ini mengidentifikasi perilaku Mengemudi yang tidak aman ketika Supir tidak teridentifikasi dengan benar di dalam sistem. **Penjadwalan pemeliharaan peralatan**: ``` value('engine_hours', 0, 'valid') > 250 && value('last_maintenance', 0, 'valid') > 30 ``` Ini memicu Aturan peringatan Pemeliharaan saat Mesin jam melebihi ambang batas dan Pemeliharaan sudah lewat waktu. **Kepatuhan rentang suhu**: ``` value('cargo_temperature', 0, 'valid') < -18 || value('cargo_temperature', 0, 'valid') > 4 ``` Ini mendeteksi ketika suhu muatan berpendingin berada di luar rentang yang dapat diterima.

Kompleksitas ekspresi dan tanda kurung

Anda dapat membuat ekspresi kompleks dengan menggabungkan beberapa kondisi dengan tanda kurung untuk mengontrol urutan evaluasi: **Validasi keselamatan kompleks**: ``` driver_identified == false && (vibration_active == true || speed > 3) ``` **Pemeriksaan peralatan multi-parameter**: {% code overflow="wrap" %} ``` (value('oil_pressure', 0, 'valid') < 20 || value('coolant_temp', 0, 'valid') > 95) && value('engine_running', 0, 'valid') == true ``` {% endcode %}

## Nilai yang hilang dan perutean null **Gejala umum:** Suatu kondisi terpicu pada paket-paket pertama perangkat, sebelum atribut yang dirujuk pernah tiba. Ini biasanya berarti kondisi tersebut menggunakan `!=` (atau operator pola yang dinegasikan) terhadap nilai yang hilang. Lihat [Operator perbandingan dengan operand null](#comparison-operators-with-null-operands) dan [Operator logika dengan operand null](#logical-operators-with-null-operands) operator mana yang aman secara default dan mana yang memerlukan pengaman. Atribut yang dirujuk bernilai `null` dalam empat kasus: * Atribut tersebut belum pernah dikirim untuk perangkat ini. * Atribut tersebut tidak ada di paket saat ini, tetapi paket sebelumnya masih menyimpan nilai. * Indeks riwayat yang diminta belum ada. * Perangkat tidak mengirim apa pun selama lebih dari 30 hari, jadi Navixy menghapus riwayat yang tersimpan. JEXL memperlakukan keempatnya dengan cara yang sama, sebagai `null`jadi perilaku operator terhadap nilai yang hilang tidak bergantung pada mana dari keempat hal yang menyebabkannya. Atribut yang tidak pernah dikirim tidak menimbulkan kesalahan pada aliran. Untuk retensi 30 hari atas nilai tersimpan, lihat [Sintaks lengkap](/docs/user/id/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#full-syntax). Untuk alasan nilai yang hilang menghentikan sebuah ekspresi, dan untuk pola perbandingan yang mencegahnya pada kedua jenis node, lihat [Nilai yang hilang dalam ekspresi](/docs/user/id/guide/account/iot-logic/nodes/missing-values-in-expressions.md). Setiap pesan masuk keluar dari node Logic melalui tepat satu cabang, THEN atau ELSE, bahkan ketika kondisi merujuk pada data yang hilang. Jika hasil keseluruhan kondisi bukan `true` (termasuk `null`atau nilai yang tidak dapat dievaluasi oleh node), pesan akan diteruskan ke ELSE. Karena itu, jalur ELSE memuat baik "kondisi bernilai salah" maupun "kondisi tidak dapat dipenuhi dari data yang tersedia." ### Pola kondisi aman terhadap null **Pemeriksaan keberadaan** (disarankan ketika suatu kondisi harus berlaku hanya untuk paket yang membawa atribut tersebut). Atribut yang tersimpan adalah riil `true`/`false` di sini, bukan `null`: ```jexl value('temperature', 0, 'all') != null && value('temperature', 0, 'all') > 50 ``` **Pemeriksaan data hilang secara eksplisit**: `null` literal diterima dalam kondisi. ```jexl value('attribute', 0, 'all') == null ``` **`||` pengurutan rantai**: Letakkan istilah yang mungkin bernilai null di akhir. Pengurutan hanya membantu pada paket ketika operand kiri bernilai true, jadi anggaplah ini sebagai peningkatan, bukan perbaikan. Tidak aman: operand kiri bernilai null diarahkan ke ELSE meskipun `speed > 50` benar pada paket yang sama. ```jexl value('attribute', 0, 'all') > 5 || value('speed', 0, 'all') > 50 ``` Lebih baik: operand kiri yang bernilai true menghentikan evaluasi lebih awal sebelum operand kanan null dievaluasi. Pada paket dengan kecepatan 20, operand kanan null tetap dievaluasi, dan kondisi tetap mengarah ke ELSE. ```jexl value('speed', 0, 'all') > 50 || value('attribute', 0, 'all') > 5 ``` Untuk formulir yang berfungsi pada setiap paket, bandingkan setiap istilah secara eksplisit. Lihat [Bandingkan nilai secara eksplisit](/docs/user/id/guide/account/iot-logic/nodes/missing-values-in-expressions.md#compare-a-value-explicitly). **Jangan mengandalkan `!()` untuk mendeteksi data yang hilang**: Saat `x` bernilai null, keduanya `x > 5` dan `!(x > 5)` mengarah ke ELSE. **`'all'` vs `'valid'`**: `value(attr, 0, 'valid')` dapat mengembalikan pembacaan terakhir yang bukan null dari paket sebelumnya. Kondisi ini masih dapat dievaluasi terhadap nilai nyata bahkan ketika paket saat ini tidak memilikinya. Gunakan `'all'` ketika kondisi harus hanya mencerminkan paket saat ini. ### Operator perbandingan dengan operand null | Situasi | Mengarah ke | Nilai atribut yang tersimpan | | --------------------------------------------------------------------------------------------- | ----------- | ---------------------------- | | `<`, `<=`, `>`, atau `>=` terhadap nilai yang hilang | ELSE | `null` | | `!=` terhadap nilai yang hilang dan literal non-null (mis., `value('a', 0, 'all') != 1`) | THEN | `true` | | `==` terhadap nilai yang hilang dan literal non-null | ELSE | `false` | | `== null` terhadap nilai yang hilang | THEN | `true` | | `!= null` saat atribut tidak ada | ELSE | `false` | | `!= null` saat atribut ada | THEN | `true` | | `=~` terhadap nilai yang hilang dan literal string atau daftar | ELSE | `false` | | `!~` terhadap nilai yang hilang dan literal string atau daftar | THEN | `true` | | `=^` atau `=$` terhadap nilai yang hilang `value()` hasil | ELSE | `false` | | `!^` atau `!$` terhadap nilai yang hilang `value()` hasil | THEN | `true` | | `=^`, `!^`, `=$`, atau `!$` terhadap atribut yang hilang yang direferensikan berdasarkan nama | ELSE | `null` | {% hint style="warning" %} `!=` terhadap nilai yang hilang dan literal non-null dievaluasi menjadi `true` dan mengarah ke THEN. Kondisi seperti `value('attribute', 1, 'all') != 1` dapat aktif pada paket pertama perangkat, sebelum atribut tersebut memiliki riwayat apa pun. Hal ini dapat terjadi bahkan ketika tujuannya adalah mengarahkan nilai yang tidak diketahui ke ELSE. Untuk gagal dengan aman saat suatu nilai mungkin belum ada, gunakan pengaman keberadaan atau `== null` pemeriksaan eksplisit: ```jexl value('attribute', 1, 'all') != null && value('attribute', 1, 'all') != 1 ``` `null == null` adalah `true`, dan `null != null` adalah `false`. Pengaman memeriksa apakah atribut memiliki nilai pada paket ini, bukan apakah nilainya berbeda dari literal. {% endhint %} {% hint style="warning" %} `=~` dan `!~` menghasilkan nilai nyata `true` atau `false` pada nilai yang hilang, apa pun sintaks yang Anda gunakan. Pada nilai yang hilang, `=~` dianggap sebagai "tidak cocok" dan berakhir di ELSE, dan `!~` berakhir di THEN. Operator starts-with dan ends-with (`=^`, `!^`, `=$`, `!$`) adalah satu-satunya tempat kedua opsi sintaks berbeda. Dengan `value()`, perilakunya seperti `=~` dan `!~`: `value('a', 0, 'all') =^ 'AB'` menjadi `false` dan berakhir di ELSE, dan `!^` menjadi `true` dan berakhir di THEN. Dengan atribut yang dirujuk berdasarkan nama, `a =^ 'AB'` menjadi `null` sebaliknya, dan baik bentuk positif maupun bentuk negasinya berakhir di ELSE. Bentuk singkatnya adalah yang [pengisian otomatis](/docs/user/id/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#autofill-attribute-names) dimasukkan, jadi kondisi yang dibangun dengan pemilih atribut mengambil jalur kedua. Tulis perbandingannya dengan `value()` saat Anda perlu `!^` atau `!$` dipicu pada paket yang tidak membawa atribut tersebut. `!~` berakhirnya di THEN adalah mekanisme yang berbeda dari `!=` berakhirnya di THEN. `!~` berakhir di sana karena nilai yang hilang dihitung sebagai "bukan kecocokan", dan `!=` berakhir di sana karena nilai yang hilang "tidak sama" dengan literalnya. Jangan asumsikan bahwa yang satu menjelaskan yang lain. {% endhint %} ### Operator logika dengan operand null | Situasi | Mengarah ke | Nilai atribut yang tersimpan | | --------------------------------------------------------------------------------- | ----------- | --------------------------------------------------------- | | `!(x > 5)` saat `x` hilang | ELSE | `null` | | Operand null dalam \` | | \` dievaluasi sebelum operand benar pada paket yang sama | | Operand benar dalam \` | | \` dievaluasi sebelum operand null (pemutusan lebih awal) | | Operand null dalam `&&` dengan operand benar, urutan apa pun | ELSE | `null` | | `false` operand dalam `&&` dievaluasi sebelum operand null (pemutusan lebih awal) | ELSE | `false` | | `false` operand dalam \` | | \` dievaluasi sebelum operand null | Urutan penting untuk kedua operator. Masing-masing mengevaluasi operand kiri terlebih dahulu dan berhenti di sana ketika operand kiri sudah menentukan hasil. Sebuah `false` operand kiri menentukan `&&`, dan sebuah `true` operand kiri menentukan `||`. Dalam setiap kombinasi lainnya, operand null dievaluasi, kondisi diselesaikan menjadi `null`, dan pesan dirutekan ke ELSE. Operand benar tidak dapat melakukan pemutusan lebih awal melewati operand null dalam `&&`, karena AND masih perlu mengetahui apakah sisi null akan gagal memenuhi kondisi. Sebuah `false` operand dapat, dan node kemudian menyimpan sebuah nilai nyata `false` daripada `null`. Untuk aturan yang sama yang diterapkan pada formula atribut, dan untuk pola perbandingan yang menghindarinya, lihat [Nilai yang hilang dalam ekspresi](/docs/user/id/guide/account/iot-logic/nodes/missing-values-in-expressions.md). ## Skenario penanganan error | Skenario | Hasil | Jalur aliran | Nilai atribut | | ------------------------------------------------------------------------------------- | --------------------------- | ------------ | ------------- | | Ekspresi bernilai `true` | Berhasil | Koneksi THEN | `true` | | Ekspresi bernilai `false` | Berhasil | Koneksi ELSE | `false` | | Atribut yang dirujuk adalah `null` dan digunakan sendiri, tanpa operator perbandingan | Diselesaikan menjadi `null` | Koneksi ELSE | `null` | | Nilai yang hilang dibandingkan dengan `<`, `<=`, `>`, atau `>=` | Diselesaikan menjadi `null` | Koneksi ELSE | `null` | | Nilai yang hilang dibandingkan dengan `==` dan literal non-null | Bernilai `false` | Koneksi ELSE | `false` | | Nilai yang hilang dibandingkan dengan `== null` | Bernilai `true` | Koneksi THEN | `true` | | Nilai yang hilang dibandingkan dengan `!=` dan literal non-null | Bernilai `true` | Koneksi THEN | `true` | | Kesalahan sintaks dalam ekspresi | Diselesaikan menjadi `null` | Koneksi ELSE | `null` | {% hint style="warning" %} Baris yang dirutekan ke ELSE tidak selalu berarti atribut disimpan sebagai `false`. Referensi null mentah dan operator relasional (`<`, `<=`, `>`, `>=`) dirutekan ke ELSE tetapi menyimpan atribut sebagai `null`. Ekspresi hilir yang memeriksa atribut secara langsung (`my_flag == false` atau `my_flag == 0`) memerlukan pengaman yang aman terhadap null untuk menangani kasus tersebut, karena ekspresi itu tidak akan cocok dengan sebuah `null` nilai. Dalam sebuah **Inisiasi Atribut** Pada node, kegagalan yang sama justru tidak menyertakan atribut dalam paket data keluaran. Lihat [Nilai yang hilang dalam ekspresi](/docs/user/id/guide/account/iot-logic/nodes/missing-values-in-expressions.md). {% endhint %} ## Contoh implementasi praktis

Pemantauan suhu armada

**Kebutuhan bisnis**: Pantau kendaraan berpendingin untuk memastikan kepatuhan suhu muatan ``` value('cargo_temperature', 0, 'valid') > 4 || value('cargo_temperature', 0, 'valid') < -18 ``` * **Jalur THEN**: Kirim aturan peringatan segera ke pusat penugasan, catat pelanggaran kepatuhan, picu tindakan korektif * **Jalur ELSE**: Lanjutkan pemrosesan normal untuk suhu yang sesuai, perbarui dasbor status

Penegakan keselamatan supir

**Kebutuhan bisnis**: Identifikasi pola mengemudi yang tidak aman selama jam shift aktif ``` value('harsh_acceleration', 0, 'valid') == true && value('shift_active', 0, 'valid') == true ``` * **Jalur THEN**: Hasilkan laporan pembinaan supir, kirim notifikasi keselamatan, catat insiden * **Jalur ELSE**: Proses data perilaku mengemudi normal, perbarui metrik kinerja

Aturan peringatan pemeliharaan prediktif

**Kebutuhan bisnis**: Deteksi potensi kegagalan peralatan sebelum terjadi ``` value('engine_temperature', 0, 'valid') > 95 && value('oil_pressure', 0, 'valid') < 30 ``` * **Jalur THEN**: Jadwalkan janji temu pemeliharaan, kirim aturan peringatan ke teknisi, catat data diagnostik * **Jalur ELSE**: Lanjutkan pemantauan rutin, perbarui dasbor kesehatan peralatan

Pemantauan kepatuhan perimeter

**Kebutuhan bisnis**: Pastikan kendaraan beroperasi di dalam area yang diotorisasi selama jam kerja ```jexl inGeofence(51577 /* Austin Warehouse */) == true && value('business_hours', 0, 'valid') == true ``` Ekspresi ini menggunakan `inGeofence()` fungsi untuk memeriksa apakah sebuah perangkat berada di dalam perimeter yang dinamai, dikombinasikan dengan atribut jam kerja. Batas perimeter dikelola di antarmuka perimeter Navixy, sehingga tidak perlu mempertahankan nilai koordinat di dalam ekspresi. Blok `== true` perbandingan menjaga kondisi tetap bekerja pada paket di mana fungsi perimeter tidak dapat menentukan, seperti paket yang tidak membawa posisi. Tanpa itu, satu nilai kosong menghentikan seluruh kondisi dan pesan dirutekan ke ELSE. * **Jalur THEN**: Lanjutkan operasi normal; perangkat berada di area yang diotorisasi selama jam kerja. * **Jalur ELSE**: Hasilkan peringatan lokasi tidak sah, beri tahu Keamanan, dan catat pelanggaran. Untuk mendeteksi saat kendaraan meninggalkan area yang diotorisasi, alih-alih memeriksanya terus-menerus, gunakan `leaveGeofence()` sebagai gantinya: ```jexl leaveGeofence(51577 /* Austin Warehouse */) == true && value('business_hours', 0, 'valid') == true ``` Untuk referensi lengkap tentang fungsi perimeter termasuk `enterGeofence()`, `geofenceName()`, dan menguji posisi sebelumnya dengan `inGeofence()`, lihat [Fungsi Perimeter](/docs/user/id/guide/account/iot-logic/nodes/geofence-functions.md).

--- # 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/logic-node/logic-node-expressions-and-syntax.md?ask=&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.