> 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/pt-br/guide/account/iot-logic/nodes/logic-node/logic-node-expressions-and-syntax.md). # Expressões e sintaxe de Lógica Escreva expressões de Lógica usando a linguagem de expressão baseada em JEXL da Navixy. As expressões encaminham dados avaliando como verdadeiro ou falso, embora um valor ausente possa se comportar de maneira diferente. ## Fundamentos das expressões O nó de Lógica usa a [Linguagem de Expressões do Navixy IoT Logic](/docs/iot-logic-api/technologies/navixy-iot-logic-expression-language.md), com base na Linguagem de Expressões Java (JEXL). As expressões devem retornar `true` ou `false`, mas um valor ausente nem sempre segue essa regra. Alguns operadores encaminham um valor ausente para THEN em vez de ELSE, e alguns deixam o atributo armazenado `null` em vez de `false`. Veja [Valores ausentes e roteamento null](#missing-values-and-null-routing) antes de confiar em uma comparação para falhar com segurança. **Avaliação de expressões**: As expressões são avaliadas da esquerda para a direita, e você pode usar parênteses para controlar a ordem das operações. **Exemplo de sintaxe básica**: ```jexl condition1 && (condition2 || condition3 > condition4) ``` ## Operadores disponíveis ### Operadores de comparação

Operador	Descrição
`==`	Verifica se dois operandos são iguais. Se os operandos forem de tipos diferentes, JEXL os converte para um único tipo, se possível
`!=`	Verifica a desigualdade de dois operandos. Retorna true se os operandos não forem iguais
`<`	Verifica se o operando à esquerda é menor que o operando à direita
`<=`	Verifica se o operando à esquerda é menor ou igual ao operando à direita
`>`	Verifica se o operando à esquerda é maior que o operando à direita
`>=`	Verifica se o operando à esquerda é maior ou igual ao operando à direita

Para saber como os valores ausentes afetam o roteamento, consulte [Valores ausentes e roteamento null](#missing-values-and-null-routing). ### Operadores lógicos

Operador	Descrição
`&&` ou `e`	AND lógico - verifica se duas condições são verdadeiras. Retorna true se ambas as condições forem verdadeiras
`\|\|` ou `ou`	OU lógico - verifica se pelo menos uma das duas condições é verdadeira
`!` ou `not`	NOT lógico - converte o resultado da condição para o valor oposto

### Operadores de correspondência de padrões

Operador	Descrição
`=~`	Verifica se o valor do operando à esquerda está no conjunto do operando à direita. Para strings, verifica correspondência com padrão regex
`!~`	Verifica se o valor do operando à esquerda não está no conjunto do operando à direita. Para strings, verifica ausência de correspondência com padrão regex
`=^`	Verifica se o operando de string à esquerda começa com o operando de string à direita
`!^`	Verifica se o operando de string à esquerda não começa com o operando de string à direita
`=$`	Verifica se o operando de string à esquerda termina com o operando de string à direita
`!$`	Verifica se o operando de string à esquerda não termina com o operando de string à direita

### Funções de geocerca Três funções avaliam a posição de um dispositivo em relação a uma geocerca Navixy nomeada, e uma quarta retorna o nome da geocerca em que o dispositivo está. Para instruções de uso e exemplos, consulte [Funções de geocerca](/docs/user/pt-br/guide/account/iot-logic/nodes/geofence-functions.md).

Função	Parâmetro	Retorna true quando
`inGeofence(id)`	ID da geocerca	O dispositivo está atualmente dentro da geocerca
`enterGeofence(id)`	ID da geocerca	O dispositivo acabou de entrar na geocerca
`leaveGeofence(id)`	ID da geocerca	O dispositivo acabou de sair da geocerca

**Posição atual:** ```jexl inGeofence(35229 /* Delivery zone #4 */) ``` O nome da geocerca aparece como um comentário para facilitar a leitura e não afeta a avaliação. O seletor de geocerca insere esse formato automaticamente. **Posição histórica:** ```jexl inGeofence(35229 /* Delivery zone #4 */, 1, 'valid') ``` O segundo parâmetro é o índice do pacote de dados (0 para o atual, 1 para o anterior, até 11), e o terceiro é o filtro de validade, seguindo a mesma convenção de `value()`. Ambos são opcionais e ambos se aplicam a `inGeofence()` somente. `enterGeofence()` e `leaveGeofence()` pegue o ID da Geocerca e nada mais. Não envolva uma função de Geocerca dentro `value()`: o primeiro parâmetro de `value()` é um nome de atributo, não uma expressão. ## Exemplos de expressões

Exemplos de condições básicas

**Verificações de igualdade**: ``` value('lock_state', 0, 'valid') == 'sealed' door_state_2 == 0 ``` **Verificações de desigualdade**: ``` value('lock_state', 1, 'valid') != 'unknown' avl_io_221 != null ``` **Cuidado com valor ausente**: `!=` Em comparação com um literal não nulo, direciona os valores ausentes para THEN, não para ELSE. Seguro: uma guarda de presença limita a verificação aos pacotes que carregam o atributo. ``` value('temperature', 0, 'all') != null && value('temperature', 0, 'all') > 50 ``` Inseguro: isso é acionado em `temperatura`dos primeiros pacotes antes de ter qualquer histórico, já que `!=` trata um valor ausente como diferente de qualquer literal. ``` value('temperature', 1, 'all') != 75 ``` **Comparações numéricas**: ``` value('humidity', 1, 'all') < 80 value('humidity', 1, 'all') <= 80 value('humidity', 0, 'valid') > 80 value('humidity', 0, 'valid') >= 80 ``` **Monitoramento de temperatura**: ``` value('temperature', 0, 'valid') > 75 ``` Esta expressão é acionada quando a temperatura excede 75 graus, útil para Alertas de superaquecimento. **Detecção de Excesso de velocidade**: ``` value('speed', 0, 'valid') > 80 ``` Esta expressão identifica quando Veículos excedem os limites de velocidade de 80 km/h. **Monitoramento da integridade do dispositivo**: ``` value('battery_voltage', 0, 'valid') < 11.5 ``` Esta expressão detecta condições de Bateria fraca que exigem atenção de Manutenção. **Alertas de nível de combustível**: ``` value('nível_de_combustível', 0, 'válido') < 20 ``` Esta expressão identifica quando os níveis de combustível caem abaixo de 20%, permitindo o reabastecimento proativo.

Exemplos de operadores lógicos

**Operações AND**: ``` value('temperature', 0, 'valid') > 15 && value('humidity', 0, 'valid') > 80 value('temperature', 0, 'valid') > 15 e value('humidity', 0, 'valid') > 80 ``` **Operações OU**: ``` temperature < 10 || humidity > 80 temperature < 10 ou humidity > 80 ``` **Operações NÃO**: ``` !condition não condition ```

Exemplos de correspondência de padrões

**Pertencimento a conjunto**: ``` value('lock_state', 0, 'valid') =~ ['locked','unlocked'] value('driver_name', 0, 'valid') !~ ['John', 'Steve'] ``` **Correspondência de padrões em strings**: ``` motorista_id =^ 'cc6f8216' motorista_id !^ 'cc6f8216' value('engine_hours', 0, 'valid') =$ '1000' value('driver_id', 0, 'valid') !$ '8b38851c3c68' ```

Exemplos complexos com várias condições

**Alerta de excesso de velocidade fora do horário**: ``` value('speed', 0, 'valid') > 60 && (value('current_hour', 0, 'valid') >= 18 || value('current_hour', 0, 'valid') <= 6) ``` Isso combina o monitoramento de velocidade com condições baseadas em tempo para uma supervisão de segurança aprimorada durante os turnos noturnos. **Diagnósticos abrangentes do dispositivo**: ``` value('gps_satellites', 0, 'valid') >= 4 && value('battery_voltage', 0, 'valid') > 11.5 && value('signal_strength', 0, 'valid') > -80 ``` Isso valida simultaneamente vários parâmetros de integridade do dispositivo para garantir uma operação confiável. **Monitoramento de segurança do motorista**: ``` value('harsh_braking', 0, 'valid') == true && value('driver_identified', 0, 'valid') == false ``` Isso identifica um comportamento inseguro durante a Condução quando o Motorista não está devidamente identificado no sistema. **Agendamento de manutenção de equipamentos**: ``` value('engine_hours', 0, 'valid') > 250 && value('last_maintenance', 0, 'valid') > 30 ``` Isso aciona alertas de manutenção quando as Horas de motor excedem os limites e a manutenção está atrasada. **Conformidade com a faixa de temperatura**: ``` value('cargo_temperature', 0, 'valid') < -18 || value('cargo_temperature', 0, 'valid') > 4 ``` Isso detecta quando as temperaturas da carga refrigerada ficam fora da faixa aceitável.

Complexidade da expressão e parênteses

Você pode criar expressões complexas combinando várias condições com parênteses para controlar a ordem de avaliação: **Validação complexa de segurança**: ``` Motorista_identified == false && (vibration_active == true || speed > 3) ``` **Verificação de equipamento com múltiplos parâmetros**: {% code overflow="wrap" %} ``` (value('oil_pressure', 0, 'valid') < 20 || value('coolant_temp', 0, 'valid') > 95) && value('engine_running', 0, 'valid') == true ``` {% endcode %}

## Valores ausentes e roteamento null **Sintoma comum:** Uma condição é acionada nos primeiros pacotes de um dispositivo, antes de o atributo referenciado ter chegado sequer uma vez. Isso geralmente significa que a condição usa `!=` (ou um operador de padrão negado) contra um valor ausente. Veja [Operadores de comparação com operandos nulos](#comparison-operators-with-null-operands) e [Operadores lógicos com operandos nulos](#logical-operators-with-null-operands) quais operadores são seguros por padrão e quais precisam de uma verificação de proteção. Um atributo referenciado é resolvido como `null` em quatro casos: * Ele nunca foi enviado para este dispositivo. * Ele está ausente do pacote atual, mas um pacote anterior ainda contém um valor. * O índice de histórico solicitado ainda não existe. * O dispositivo não enviou nada por mais de 30 dias, então o Navixy descartou o histórico armazenado. O JEXL trata os quatro da mesma forma, como `null`, portanto, o comportamento de um operador em relação a um valor ausente não depende de qual dos quatro o causou. Um atributo nunca enviado não gera erro no fluxo. Para a retenção de 30 dias dos valores armazenados, consulte [Sintaxe completa](/docs/user/pt-br/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#full-syntax). Para saber por que um valor ausente interrompe uma expressão e para ver os padrões de comparação que evitam isso em ambos os tipos de nó, consulte [Valores ausentes em expressões](/docs/user/pt-br/guide/account/iot-logic/nodes/missing-values-in-expressions.md). Toda mensagem recebida sai do nó de lógica por exatamente um ramo, THEN ou ELSE, mesmo quando a condição faz referência a dados ausentes. Se o resultado geral da condição for qualquer coisa diferente de `true` (incluindo `null`, ou um valor que o nó não consegue avaliar), a mensagem é roteada para ELSE. O caminho ELSE, portanto, carrega tanto "a condição é falsa" quanto "a condição não pôde ser satisfeita com os dados disponíveis." ### Padrões de condição seguros para valores nulos **Verificação de presença** (recomendado quando uma condição deve se aplicar apenas a pacotes que carregam o atributo). O atributo armazenado é um valor real `true`/`false` aqui, não `null`: ```jexl value('temperature', 0, 'all') != null && value('temperature', 0, 'all') > 50 ``` **Verificação explícita de dados ausentes**: `null` literais são aceitos em condições. ```jexl value('attribute', 0, 'all') == null ``` **`||` ordenação da cadeia**: Coloque por último o termo que pode ser nulo. A ordenação só ajuda em pacotes em que o operando à esquerda é verdadeiro, então trate-a como uma melhoria, e não como uma correção. Inseguro: o operando à esquerda nulo encaminha para ELSE mesmo que `speed > 50` seja verdadeiro no mesmo pacote. ```jexl value('attribute', 0, 'all') > 5 || value('speed', 0, 'all') > 50 ``` Melhor: um operando à esquerda verdadeiro faz curto-circuito antes que o operando à direita nulo seja avaliado. Em um pacote em que a velocidade é 20, o operando à direita nulo ainda é avaliado, e a condição ainda encaminha para ELSE. ```jexl value('speed', 0, 'all') > 50 || value('attribute', 0, 'all') > 5 ``` Para um Formulário que funcione em cada pacote, compare cada termo explicitamente. Veja [Comparar um valor explicitamente](/docs/user/pt-br/guide/account/iot-logic/nodes/missing-values-in-expressions.md#compare-a-value-explicitly). **Não dependa de `!()` para detectar dados ausentes**: Quando `x` é nulo, ambos `x > 5` e `!(x > 5)` encaminham para ELSE. **`'all'` vs `'valid'`**: `value(attr, 0, 'valid')` pode retornar a última leitura não nula de um pacote anterior. A condição ainda pode ser avaliada em relação a um valor real mesmo quando o pacote atual não o tem. Use `'all'` quando a condição deve refletir apenas o pacote atual. ### Operadores de comparação com operandos nulos | Situação | Roteia para | Valor do atributo armazenado | | --------------------------------------------------------------------------------------------------- | ----------- | ---------------------------- | | `<`, `<=`, `>`, ou `>=` em relação a um valor ausente | ELSE | `null` | | `!=` em relação a um valor ausente e um literal não nulo (por exemplo, `value('a', 0, 'all') != 1`) | THEN | `true` | | `==` em relação a um valor ausente e um literal não nulo | ELSE | `false` | | `== null` em relação a um valor ausente | THEN | `true` | | `!= null` quando o atributo está ausente | ELSE | `false` | | `!= null` quando o atributo está presente | THEN | `true` | | `=~` em relação a um valor ausente e um literal de string ou uma lista | ELSE | `false` | | `!~` em relação a um valor ausente e um literal de string ou uma lista | THEN | `true` | | `=^` ou `=$` em relação a um valor ausente `value()` resultado | ELSE | `false` | | `!^` ou `!$` em relação a um valor ausente `value()` resultado | THEN | `true` | | `=^`, `!^`, `=$`, ou `!$` em relação a um atributo ausente referenciado pelo nome | ELSE | `null` | {% hint style="warning" %} `!=` em relação a um valor ausente e um literal não nulo, resulta em `true` e encaminha para THEN. Uma condição como `value('attribute', 1, 'all') != 1` pode ser acionada nos primeiros pacotes de um dispositivo, antes que esse atributo tenha qualquer histórico. Isso pode acontecer mesmo quando a intenção é encaminhar valores desconhecidos para ELSE. Para falhar com segurança quando um valor ainda pode não existir, use uma verificação de presença ou uma `== null` verificação explícita: ```jexl value('attribute', 1, 'all') != null && value('attribute', 1, 'all') != 1 ``` `null == null` é `true`e `null != null` é `false`. A verificação checa se o atributo tem um valor neste pacote, não se ele difere de um literal. {% endhint %} {% hint style="warning" %} `=~` e `!~` se resolvem para um valor real `true` ou `false` sobre um valor ausente, independentemente da sintaxe usada. Em um valor ausente, `=~` conta como "sem correspondência" e vai para ELSE, e `!~` vai para THEN. Os operadores starts-with e ends-with (`=^`, `!^`, `=$`, `!$`) são o único caso em que as duas opções de sintaxe diferem. Com `value()`, eles se comportam como `=~` e `!~`: `value('a', 0, 'all') =^ 'AB'` se resolve para `false` e vai para ELSE, e `!^` se resolve para `true` e vai para THEN. Com o atributo referenciado pelo nome, `a =^ 'AB'` se resolve para `null` em vez disso, e tanto a forma afirmativa quanto a negada vão para ELSE. A forma abreviada é o que [preenchimento automático](/docs/user/pt-br/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#autofill-attribute-names) insere, então uma condição criada com o seletor de atributos segue o segundo caminho. Escreva a comparação com `value()` quando você precisar `!^` ou `!$` disparar em um pacote que não contém o atributo. `!~` alcançar THEN é um mecanismo diferente de `!=` alcançar THEN. `!~` vai para lá porque um valor ausente conta como "sem correspondência", e `!=` vai para lá porque um valor ausente é "diferente" do literal. Não assuma que uma coisa explica a outra. {% endhint %} ### Operadores lógicos com operandos nulos | Situação | Roteia para | Valor do atributo armazenado | | ---------------------------------------------------------------------------- | ----------- | ----------------------------------------------------------- | | `!(x > 5)` quando `x` está ausente | ELSE | `null` | | Operando nulo em \` | | \` avaliado antes de um operando verdadeiro no mesmo pacote | | Operando verdadeiro em \` | | \` avaliado antes de um operando nulo (curto-circuita) | | Operando nulo em `&&` com um operando verdadeiro, em qualquer ordem | ELSE | `null` | | `false` operando em `&&` avaliado antes de um operando nulo (curto-circuita) | ELSE | `false` | | `false` operando em \` | | \` avaliado antes de um operando nulo | A ordem importa para ambos os operadores. Cada um avalia primeiro o operando esquerdo e para ali quando o operando esquerdo já define o resultado. Um `false` operando esquerdo define `&&`, e um `true` operando esquerdo define `||`. `null`na condição, e a mensagem vai para ELSE. Um operando verdadeiro não pode curto-circuitar um operando nulo em `&&`, pois AND ainda precisa saber se o lado nulo falharia na condição. Um `false` operando pode, e o nó então armazena um valor real `false` em vez de `null`. Para a mesma regra aplicada a fórmulas de atributos, e para os padrões de comparação que evitam isso, veja [Valores ausentes em expressões](/docs/user/pt-br/guide/account/iot-logic/nodes/missing-values-in-expressions.md). ## Cenários de tratamento de erros | Cenário | Resultado | Caminho do fluxo | Valor do atributo | | ------------------------------------------------------------------------------ | ----------------------- | ---------------- | ----------------- | | A expressão é avaliada como `true` | Sucesso | Conexão THEN | `true` | | A expressão é avaliada como `false` | Sucesso | Conexão ELSE | `false` | | O atributo referenciado é `null` e é usado sozinho, sem operador de comparação | Se resolve para `null` | Conexão ELSE | `null` | | Valor ausente comparado com `<`, `<=`, `>`, ou `>=` | Se resolve para `null` | Conexão ELSE | `null` | | Valor ausente comparado com `==` e um literal não nulo | É avaliado como `false` | Conexão ELSE | `false` | | Valor ausente comparado com `== null` | É avaliado como `true` | Conexão THEN | `true` | | Valor ausente comparado com `!=` e um literal não nulo | É avaliado como `true` | Conexão THEN | `true` | | Erro de sintaxe na expressão | Se resolve para `null` | Conexão ELSE | `null` | {% hint style="warning" %} Uma linha que vai para ELSE nem sempre significa que o atributo é armazenado como `false`.`<`, `<=`, `>`, `>=`) vão para ELSE, mas armazenam o atributo como `null`. Uma expressão a jusante que verifica o atributo diretamente (`my_flag == false` ou `my_flag == 0`) precisa de uma verificação segura contra nulos para capturar esse caso, já que não corresponderá a um `null` valor. Em um **Iniciar Atributo** nó, as mesmas falhas deixam o atributo de fora do pacote de dados de saída. Veja [Valores ausentes em expressões](/docs/user/pt-br/guide/account/iot-logic/nodes/missing-values-in-expressions.md). {% endhint %} ## Exemplos práticos de implementação

Monitoramento de temperatura da frota

**Requisito de negócio**: Monitore veículos refrigerados para garantir a conformidade da temperatura da carga ``` value('cargo_temperature', 0, 'valid') > 4 || value('cargo_temperature', 0, 'valid') < -18 ``` * **Caminho THEN**: Envie alertas imediatos para a central, registre violações de conformidade, acione ações corretivas * **Caminho ELSE**: Continue o processamento normal para temperaturas em conformidade, atualize os painéis de status

Fiscalização da segurança do motorista

**Requisito de negócio**: Identifique padrões inseguros de condução durante o horário de turno ativo ``` value('harsh_acceleration', 0, 'valid') == true && value('shift_active', 0, 'valid') == true ``` * **Caminho THEN**: Gere relatórios de orientação para motoristas, envie notificações de segurança, registre incidentes * **Caminho ELSE**: Processe dados normais de condução, atualize métricas de desempenho

Alertas de manutenção preditiva

**Requisito de negócio**: Detecte possíveis falhas de equipamento antes que ocorram ``` value('engine_temperature', 0, 'valid') > 95 && value('oil_pressure', 0, 'valid') < 30 ``` * **Caminho THEN**: Agende atendimentos de manutenção, envie alertas ao técnico, registre dados de diagnóstico * **Caminho ELSE**: Continue o monitoramento de rotina, atualize os painéis de saúde dos equipamentos

Monitoramento de conformidade da geocerca

**Requisito de negócio**: Garanta que os veículos operem dentro das áreas autorizadas durante o horário comercial ```jexl inGeofence(51577 /* Austin Warehouse */) == true && value('business_hours', 0, 'valid') == true ``` Esta expressão usa a `inGeofence()` função para verificar se um dispositivo está dentro de uma geocerca nomeada, combinada com um atributo de horário comercial. Os limites da geocerca são gerenciados na interface de geocercas do Navixy, portanto não é necessário manter valores de coordenadas na expressão. O `== true` A comparação mantém a condição funcionando em pacotes nos quais a função de geocerca não consegue decidir, como um pacote que não carrega posição. Sem ela, um único valor vazio interrompe toda a condição e a mensagem vai para ELSE. * **Caminho THEN**: Continue as operações normais; o dispositivo está na área autorizada durante o horário de trabalho. * **Caminho ELSE**: Gere um alerta de localização não autorizada, notifique a segurança e registre a violação. Para detectar o momento em que um veículo sai da geocerca em vez de verificar continuamente, use `leaveGeofence()` em vez disso: ```jexl leaveGeofence(51577 /* Austin Warehouse */) == true && value('business_hours', 0, 'valid') == true ``` Para a referência completa das funções de geocerca, incluindo `enterGeofence()`, `geofenceName()`, e testando uma posição anterior com `inGeofence()`, consulte [Funções de geocerca](/docs/user/pt-br/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 dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://navixy.com/docs/user/pt-br/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 optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. 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.