Expressões e sintaxe da Lógica
Escreva expressões de Lógica usando a linguagem de expressão baseada em JEXL do Navixy. As expressões encaminham dados ao avaliar como verdadeiro ou falso, embora um valor ausente possa se comportar de forma diferente.
Fundamentos de expressões
O nó Lógica usa o Linguagem de Expressão do Navixy IoT Logic, com base na Java Expression Language (JEXL). As expressões têm como objetivo retornar true https://api.eu.navixy.com/v2/... falso, mas um valor ausente nem sempre segue essa regra. Alguns operadores direcionam um valor ausente para THEN em vez de ELSE, e alguns deixam o atributo armazenado null em vez de falso. Veja Valores ausentes e roteamento de null 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:
condition1 && (condition2 || condition3 > condition4)Operadores disponíveis
Operadores de comparação
==
Verifica se dois operandos são iguais. Se os operandos forem de tipos diferentes, o JEXL os converte para um tipo comum, 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 valores ausentes afetam o roteamento, consulte Valores ausentes e roteamento de null.
Operadores lógicos
&& https://api.eu.navixy.com/v2/... Webhook
E lógico - verifica se duas condições são verdadeiras. Retorna true se ambas as condições forem verdadeiras
|| https://api.eu.navixy.com/v2/... https://api.eu.navixy.com/v2/...
OU lógico - verifica se pelo menos uma das duas condições é verdadeira
! https://api.eu.navixy.com/v2/... not
NÃO lógico - converte o resultado da condição para o valor oposto
Operadores de correspondência de padrões
=~
Verifica se o valor do operando à esquerda pertence ao conjunto do operando à direita. Para strings, verifica correspondência com padrão regex
!~
Verifica se o valor do operando à esquerda não pertence ao 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 nomeada da Navixy, 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.
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:
O nome da geocerca aparece como um comentário para facilitar a leitura e não tem efeito na avaliação. O seletor de geocerca insere esse formato automaticamente.
Posição histórica:
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 que value(). Ambos são opcionais e se aplicam a inGeofence() somente. enterGeofence() Webhook leaveGeofence() use o ID da geocerca e nada mais. Não coloque uma função de geocerca dentro de value(): o primeiro parâmetro de value() é um nome de atributo, não uma expressão.
Exemplos de expressões
Valores ausentes e roteamento de null
Sintoma comum: Uma condição é disparada nos primeiros pacotes de um dispositivo, antes que o atributo referenciado tenha sequer chegado. Isso normalmente significa que a condição usa != (ou um operador de padrão negado) em relação a um valor ausente. Veja Operadores de comparação com operandos nulos Webhook Operadores lógicos com operandos nulos quais operadores são seguros por padrão e quais precisam de uma verificação.
Um atributo referenciado se resolve em 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 a Navixy descartou o histórico armazenado.
O JEXL trata os quatro da mesma forma, como null, então 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.
Para saber por que um valor ausente interrompe uma expressão e para os padrões de comparação que evitam isso nos dois tipos de nó, consulte Valores ausentes em expressões.
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 é encaminhada para ELSE. Portanto, o caminho ELSE 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 nulos
Guarda de presença (recomendado quando uma condição deve ser aplicada somente aos pacotes que contenham o atributo). O atributo armazenado é um valor real true/falso aqui, não null:
Verificação explícita de ausência de dados: null literais são aceitos em condições.
|| ordenação em cadeia: Coloque por último o termo que pode ser nulo. A ordenação ajuda apenas em pacotes em que o operando esquerdo é verdadeiro, então trate isso como um aprimoramento, e não como uma correção.
Inseguro: o operando esquerdo nulo é encaminhado para ELSE embora speed > 50 seja verdadeiro no mesmo pacote.
Melhor: um operando esquerdo verdadeiro faz short-circuit antes que o operando direito nulo seja avaliado. Em um pacote em que a velocidade é 20, o operando direito nulo ainda é avaliado, e a condição ainda roteia para ELSE.
Para um formulário que funcione em cada pacote, compare cada termo explicitamente. Veja Comparar um valor explicitamente.
Não dependa de !() para detectar dados ausentes: Quando x é nulo, ambos x > 5 Webhook !(x > 5) roteia para ELSE.
'todos' vs 'válido': 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 contém. Use 'todos' quando a condição deve refletir apenas o pacote atual.
Operadores de comparação com operandos nulos
<, <=, >, ou >= em relação a um valor ausente
ELSE
null
!= em relação a um valor ausente e a um literal não nulo (por exemplo, value('a', 0, 'all') != 1)
THEN
true
== em relação a um valor ausente e a um literal não nulo
ELSE
falso
== null em relação a um valor ausente
THEN
true
!= null quando o atributo está ausente
ELSE
falso
!= null quando o atributo está presente
THEN
true
=~ em relação a um valor ausente e a um literal de string ou uma lista
ELSE
falso
!~ em relação a um valor ausente e a um literal de string ou uma lista
THEN
true
=^ https://api.eu.navixy.com/v2/... =$ em relação a um valor ausente value() resultado
ELSE
falso
!^ https://api.eu.navixy.com/v2/... !$ em relação a um valor ausente value() resultado
THEN
true
=^, !^, =$, ou !$ em relação a um atributo ausente referenciado pelo nome
ELSE
null
!= em relação a um valor ausente e a um literal não nulo avalia para true e roteia para THEN. Uma condição como value('attribute', 1, 'all') != 1 pode disparar nos primeiros pacotes de um dispositivo, antes que esse atributo tenha qualquer histórico. Isso pode acontecer mesmo quando a intenção é rotear 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:
null == null é true{{longitude}} null != null é falso. A verificação confirma se o atributo tem um valor neste pacote, e não se ele é diferente de um literal.
=~ Webhook !~ se resolve para um valor real true https://api.eu.navixy.com/v2/... falso em um valor ausente, independentemente da sintaxe usada. Em um valor ausente, =~ conta como "não corresponde" e cai em ELSE, e !~ cai em 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 =~ Webhook !~: value('a', 0, 'all') =^ 'AB' se resolve para falso e cai em ELSE, e !^ se resolve para true e cai em THEN. Com o atributo referenciado pelo nome, a =^ 'AB' se resolve para null em vez disso, e tanto a forma positiva quanto a negada caem em ELSE.
A forma abreviada é a que preenchimento automático é inserida, então uma condição construída com o seletor de atributos toma o segundo caminho. Escreva a comparação com value() quando você precisar !^ https://api.eu.navixy.com/v2/... !$ disparar em um pacote que não carrega o atributo.
!~ alcançar THEN é um mecanismo diferente de != alcançar THEN. !~ cai lá porque um valor ausente conta como "não corresponde", e != cai lá porque um valor ausente é "diferente" do literal. Não presuma que um explica o outro.
Operadores lógicos com operandos nulos
!(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 (encurta a avaliação)
Operando nulo em && com um operando verdadeiro, em qualquer ordem
ELSE
null
falso operando em && avaliado antes de um operando nulo (encurta a avaliação)
ELSE
falso
falso operando em `
` avaliado antes de um operando nulo
A ordem importa para ambos os operadores. Cada um avalia primeiro o operando à esquerda e para ali quando o operando à esquerda já determina o resultado. Um falso operando à esquerda determina &&, e um true operando à esquerda determina ||. Em qualquer outra combinação, o operando nulo é avaliado, a condição se resolve como null, e a mensagem é roteada para ELSE.
Um operando verdadeiro não consegue encurtar a avaliação de um nulo em &&, pois o AND ainda precisa saber se o lado nulo falharia na condição. Um falso operando pode, e o nó então armazena um verdadeiro falso em vez de null. Para a mesma regra aplicada a fórmulas de atributo, e para os padrões de comparação que a evitam, veja Valores ausentes em expressões.
Cenários de tratamento de erro
A expressão é avaliada como true
Sucesso
Conexão THEN
true
A expressão é avaliada como falso
Sucesso
Conexão ELSE
falso
O atributo referenciado está null e é usado sozinho, sem operador de comparação
Resolve-se para null
Conexão ELSE
null
Valor ausente comparado com <, <=, >, ou >=
Resolve-se para null
Conexão ELSE
null
Valor ausente comparado com == e um literal não nulo
É avaliado como falso
Conexão ELSE
falso
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
Resolve-se para null
Conexão ELSE
null
Uma linha que roteia para ELSE nem sempre significa que o atributo está armazenado como falso. Uma referência nula isolada e os operadores relacionais (<, <=, >, >=) roteiam para ELSE, mas armazenam o atributo como null. Uma expressão a jusante que verifica o atributo diretamente (my_flag == false https://api.eu.navixy.com/v2/... my_flag == 0) precisa de uma proteção à prova de nulos para capturar esse caso, já que não corresponderá a um null valor.
Em um Iniciar Atributo no nó, as mesmas falhas deixam o atributo fora do pacote de dados de saída, em vez disso. Veja Valores ausentes em expressões.
Exemplos práticos de implementação
Atualizado
Isto foi útil?