Avviso di fine del supporto: il 20 maggio 2026, AWS terminerà il supporto per AWS IoT Events. Dopo il 20 maggio 2026, non potrai più accedere alla AWS IoT Events console o AWS IoT Events alle risorse. Per ulteriori informazioni, consulta [AWS IoT Events Fine del supporto](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-end-of-support.html).
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Espressioni per filtrare, trasformare ed elaborare i dati degli eventi
Le espressioni vengono utilizzate per valutare i dati in entrata, eseguire calcoli e determinare le condizioni in base alle quali devono verificarsi azioni specifiche o transizioni di stato. AWS IoT Events offre diversi modi per specificare i valori durante la creazione e l'aggiornamento dei modelli di rilevatori. È possibile utilizzare le espressioni per specificare valori letterali o AWS IoT Events valutare le espressioni prima di specificare valori particolari.
**Topics**
+ [Sintassi per filtrare i dati del dispositivo e definire azioni in AWS IoT Events](#expression-syntax)
+ [Esempi di espressioni e utilizzo per AWS IoT Events](expression-usage.md)
## Sintassi per filtrare i dati del dispositivo e definire azioni in AWS IoT Events
Le espressioni offrono la sintassi per filtrare i dati del dispositivo e definire le azioni. È possibile utilizzare valori letterali, operatori, funzioni, riferimenti e modelli di sostituzione nelle espressioni. AWS IoT Events Combinando questi componenti, è possibile creare espressioni potenti e flessibili per elaborare dati IoT, eseguire calcoli, manipolare stringhe e prendere decisioni logiche all'interno dei modelli di rilevatori.
### Valori letterali
+ Numero intero
+ Decimale
+ Stringa
+ Booleano
### Operatori
Unario
+ Non (booleano): `!`
+ Non (bit per bit): `~`
+ Meno (aritmetico): `-`
Stringa
+ Concatenazione: **`+`**
Entrambi gli operandi devono essere stringhe. Le stringhe letterali devono essere racchiuse tra virgolette singole (').
Ad esempio: -> `'my' + 'string'` `'mystring'`
Aritmetica
+ Aggiunta: **`+`**
Entrambi gli operandi devono essere numerici.
+ Sottrazione: **`-`**
+ Divisione: **`/`**
Il risultato della divisione è un valore intero arrotondato a meno che almeno uno degli operandi (divisore o dividendo) sia un valore decimale.
+ Moltiplicazione: **`*`**
Bit per bit (numero intero)
+ OPPURE: **`|`**
Ad esempio: `13 | 5` -> `13`
+ E: **`&`**
Ad esempio: `13 & 5` -> `5`
+ XOR: **`^`**
Ad esempio: -> `13 ^ 5` `8`
+ NON: **`~`**
Ad esempio: `~13` -> `-14`
Booleano
+ Meno di: **`<`**
+ Minore o uguale a: **`<=`**
+ Uguale a: **`==`**
+ Non uguale a: **`!=`**
+ Maggiore o uguale a: **`>=`**
+ Maggiore di: **`>`**
+ E: **`&&`**
+ OPPURE: **`||`**
**Nota**
Quando una sottoespressione di `||` contiene dati non definiti, tale sottoespressione viene trattata come. `false`
Parentesi
È possibile utilizzare le parentesi per raggruppare i termini all'interno di un'espressione.
### Funzioni da utilizzare nelle espressioni AWS IoT Events
AWS IoT Events fornisce una serie di funzioni integrate per migliorare le funzionalità delle espressioni dei modelli di rivelatori. Queste funzioni consentono la gestione del timer, la conversione dei tipi, il controllo nullo, l'identificazione del tipo di trigger, la verifica degli input, la manipolazione delle stringhe e le operazioni bit per bit. Sfruttando queste funzioni, puoi creare una logica di AWS IoT Events elaborazione reattiva, migliorando l'efficacia complessiva delle tue applicazioni IoT.
Funzioni integrate
`timeout("timer-name")`
Valuta `true` se il timer specificato è scaduto. Sostituisci **timer-name** "" con il nome di un timer che hai definito, tra virgolette. In un'azione relativa a un evento, è possibile definire un timer e quindi avviarlo, resettarlo o cancellarne uno definito in precedenza. Vedi il campo`detectorModelDefinition.states.onInput|onEnter|onExit.events.actions.setTimer.timerName`.
Un timer impostato in uno stato può essere referenziato in uno stato diverso. È necessario visitare lo stato in cui è stato creato il timer prima di entrare nello stato a cui fa riferimento il timer.
Ad esempio, un modello di rilevatore ha due stati, `TemperatureChecked` e. `RecordUpdated` Hai creato un timer nello `TemperatureChecked` stato. È necessario visitare lo `TemperatureChecked` stato prima di poter utilizzare il timer nello `RecordUpdated` stato.
Per garantire la precisione, il tempo minimo per impostare un timer è di 60 secondi.
`timeout()`restituisce `true` solo la prima volta che viene controllato dopo la scadenza effettiva del timer e ritorna `false` successivamente.
`convert(type, expression)`
Restituisce il valore dell'espressione convertita nel tipo specificato. Il *type* valore deve essere `String``Boolean`, o`Decimal`. Utilizzate una di queste parole chiave o un'espressione che restituisca una stringa contenente la parola chiave. Solo le seguenti conversioni hanno esito positivo e restituiscono un valore valido:
+ Boolean -> stringa
Restituisce la stringa `"true"` o. `"false"`
+ Decimale -> stringa
+ Stringa -> Booleano
+ Stringa -> decimale
La stringa specificata deve essere una rappresentazione valida di un numero decimale o ha esito negativo. `convert()`
Se `convert()` non restituisce un valore valido, anche l'espressione di cui fa parte non è valida. Questo risultato è equivalente `false` e non attiverà la transizione `actions` o verso lo `nextState` specificato come parte dell'evento in cui si verifica l'espressione.
`isNull(expression)`
Restituisce `true` se l'espressione restituisce null. Ad esempio, se l'input `MyInput` riceve il messaggio`{ "a": null }`, quanto segue restituisce`true`, ma `isUndefined($input.MyInput.a)` restituisce sì. `false`
```
isNull($input.MyInput.a)
```
`isUndefined(expression)`
Restituisce `true` se l'espressione non è definita. Ad esempio, se l'input `MyInput` riceve il messaggio`{ "a": null }`, quanto segue restituisce`false`, ma `isNull($input.MyInput.a)` restituisce sì. `true`
```
isUndefined($input.MyInput.a)
```
`triggerType("type")`
Il *type* valore può essere `"Message"` o. `"Timer"` Valuta `true` se la condizione dell'evento in cui appare viene valutata perché un timer è scaduto, come nell'esempio seguente.
```
triggerType("Timer")
```
Oppure è stato ricevuto un messaggio di input.
```
triggerType("Message")
```
`currentInput("input")`
Valuta `true` se la condizione dell'evento in cui appare viene valutata perché è stato ricevuto il messaggio di input specificato. Ad esempio, se l'input `Command` riceve il messaggio`{ "value": "Abort" }`, quanto segue restituisce. `true`
```
currentInput("Command")
```
Utilizzate questa funzione per verificare che la condizione venga valutata perché è stato ricevuto un determinato input e non è scaduto un timer, come nell'espressione seguente.
```
currentInput("Command") && $input.Command.value == "Abort"
```
Funzioni di corrispondenza delle stringhe
`startsWith(expression1, expression2)`
Restituisce `true` se la prima espressione stringa inizia con la seconda espressione di stringa. Ad esempio, se input `MyInput` riceve il messaggio`{ "status": "offline"}`, viene restituito quanto segue. `true`
```
startsWith($input.MyInput.status, "off")
```
Entrambe le espressioni devono restituire un valore di stringa. Se nessuna delle espressioni restituisce un valore di stringa, il risultato della funzione non è definito. Non viene eseguita alcuna conversione.
`endsWith(expression1, expression2)`
Valuta `true` se la prima espressione stringa termina con la seconda espressione stringa. Ad esempio, se input `MyInput` riceve il messaggio`{ "status": "offline" }`, viene restituito quanto segue. `true`
```
endsWith($input.MyInput.status, "line")
```
Entrambe le espressioni devono restituire un valore di stringa. Se nessuna delle espressioni restituisce un valore di stringa, il risultato della funzione non è definito. Non viene eseguita alcuna conversione.
`contains(expression1, expression2)`
Valuta `true` se la prima espressione stringa contiene la seconda espressione stringa. Ad esempio, se input `MyInput` riceve il messaggio`{ "status": "offline" }`, viene restituito quanto segue. `true`
```
contains($input.MyInput.value, "fli")
```
Entrambe le espressioni devono restituire un valore di stringa. Se nessuna delle espressioni restituisce un valore di stringa, il risultato della funzione non è definito. Non viene eseguita alcuna conversione.
Funzioni di manipolazione di numeri interi bit a bit
`bitor(expression1, expression2)`
Valuta l'OR bit per bit delle espressioni intere (l'operazione OR binaria viene eseguita sui bit corrispondenti dei numeri interi). Ad esempio, se input `MyInput` riceve il messaggio`{ "value1": 13, "value2": 5 }`, quanto segue restituisce. `13`
```
bitor($input.MyInput.value1, $input.MyInput.value2)
```
Entrambe le espressioni devono restituire un valore intero. Se nessuna delle espressioni restituisce un valore intero, il risultato della funzione non è definito. Non viene eseguita alcuna conversione.
`bitand(expression1, expression2)`
Valuta l'AND bit per bit delle espressioni intere (l'operazione AND binaria viene eseguita sui bit corrispondenti dei numeri interi). Ad esempio, se input `MyInput` riceve il messaggio`{ "value1": 13, "value2": 5 }`, quanto segue restituisce. `5`
```
bitand($input.MyInput.value1, $input.MyInput.value2)
```
Entrambe le espressioni devono restituire un valore intero. Se nessuna delle espressioni restituisce un valore intero, il risultato della funzione non è definito. Non viene eseguita alcuna conversione.
`bitxor(expression1, expression2)`
Valuta lo XOR bit per bit delle espressioni intere (l'operazione XOR binaria viene eseguita sui bit corrispondenti dei numeri interi). Ad esempio, se input `MyInput` riceve il messaggio`{ "value1": 13, "value2": 5 }`, viene restituito quanto segue. `8`
```
bitxor($input.MyInput.value1, $input.MyInput.value2)
```
Entrambe le espressioni devono restituire un valore intero. Se nessuna delle espressioni restituisce un valore intero, il risultato della funzione non è definito. Non viene eseguita alcuna conversione.
`bitnot(expression)`
Valuta il NOT bit per bit dell'espressione intera (l'operazione binaria NOT viene eseguita sui bit del numero intero). Ad esempio, se input `MyInput` riceve il messaggio`{ "value": 13 }`, quanto segue restituisce. `-14`
```
bitnot($input.MyInput.value)
```
Entrambe le espressioni devono restituire un valore intero. Se nessuna delle espressioni restituisce un valore intero, il risultato della funzione non è definito. Non viene eseguita alcuna conversione.
### AWS IoT Events riferimento per input e variabili nelle espressioni
Input
`$input.input-name.path-to-data`
`input-name`è un input creato utilizzando l'[CreateInput](https://docs.aws.amazon.com/iotevents/latest/apireference/API_CreateInput.html)azione.
Ad esempio, se avete un input denominato `TemperatureInput` per il quale avete definito delle `inputDefinition.attributes.jsonPath` voci, i valori potrebbero apparire nei seguenti campi disponibili.
```
{
"temperature": 78.5,
"date": "2018-10-03T16:09:09Z"
}
```
Per fare riferimento al valore del `temperature` campo, utilizzate il comando seguente.
```
$input.TemperatureInput.temperature
```
Per i campi i cui valori sono matrici, è possibile fare riferimento ai membri dell'array utilizzando`[n]`. Ad esempio, dati i seguenti valori:
```
{
"temperatures": [
78.4,
77.9,
78.8
],
"date": "2018-10-03T16:09:09Z"
}
```
`78.8`È possibile fare riferimento al valore con il comando seguente.
```
$input.TemperatureInput.temperatures[2]
```
Variabili
`$variable.variable-name`
`variable-name`è una variabile che hai definito utilizzando l'[CreateDetectorModel](https://docs.aws.amazon.com/iotevents/latest/apireference/API_CreateDetectorModel.html)azione.
Ad esempio, se avete una variabile denominata `TechnicianID` che avete definito utilizzando`detectorDefinition.states.onInputEvents.actions.setVariable.variableName`, potete fare riferimento all'ultimo valore (stringa) assegnato alla variabile con il comando seguente.
```
$variable.TechnicianID
```
È possibile impostare i valori delle variabili solo utilizzando l'`setVariable`azione. Non è possibile assegnare valori alle variabili in un'espressione. Una variabile non può essere annullata. Ad esempio, non puoi assegnarle il valore. `null`
**Nota**
Nei riferimenti che utilizzano identificatori che non seguono il modello (espressione regolare)`[a-zA-Z][a-zA-Z0-9_]*`, è necessario racchiudere tali identificatori in backticks (). ``` Ad esempio, un riferimento a un input denominato `MyInput` con un campo denominato `_value` deve specificare questo campo come. `$input.MyInput.`_value``
Quando utilizzate riferimenti nelle espressioni, controllate quanto segue:
+ Quando utilizzate un riferimento come operando con uno o più operatori, assicuratevi che tutti i tipi di dati a cui fate riferimento siano compatibili.
Ad esempio, nell'espressione seguente, il numero intero `2` è un operando di entrambi gli `==` operatori and. `&&` Per garantire che gli operandi siano compatibili `$variable.testVariable + 1` e che `$variable.testVariable` debbano fare riferimento a un numero intero o decimale.
Inoltre, il numero intero `1` è un operando dell'operatore. `+` Pertanto, `$variable.testVariable` deve fare riferimento a un numero intero o decimale.
```
‘$variable.testVariable + 1 == 2 && $variable.testVariable’
```
+ Quando utilizzate un riferimento come argomento passato a una funzione, assicuratevi che la funzione supporti i tipi di dati a cui fate riferimento.
Ad esempio, la seguente `timeout("time-name")` funzione richiede una stringa con virgolette doppie come argomento. Se si utilizza un riferimento per il *timer-name* valore, è necessario fare riferimento a una stringa tra virgolette doppie.
```
timeout("timer-name")
```
**Nota**
Per la `convert(type, expression)` funzione, se si utilizza un riferimento per il *type* valore, il risultato valutato del riferimento deve essere `String``Decimal`, o`Boolean`.
AWS IoT Events le espressioni supportano i tipi di dati interi, decimali, stringhe e booleani. La tabella seguente fornisce un elenco di coppie di tipi incompatibili.
| Coppie di tipi incompatibili |
| --- |
| Numero intero, stringa |
| Numero intero, booleano |
| Decimale, stringa |
| Decimale, booleano |
| Stringa, booleana |
### Modelli sostitutivi per le espressioni AWS IoT Events
****
`'${expression}'`
`${}`identifica la stringa come stringa interpolata. `expression`Può essere qualsiasi espressione. AWS IoT Events Ciò include operatori, funzioni e riferimenti.
Ad esempio, hai usato l'[SetVariableAction](https://docs.aws.amazon.com/iotevents/latest/apireference/API_SetVariableAction.html)azione per definire una variabile. `variableName` è `SensorID`, e `value` è `10`. È possibile creare i seguenti modelli sostitutivi.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/iotevents/latest/developerguide/iotevents-expressions.html)
# Esempi di espressioni e utilizzo per AWS IoT Events
È possibile specificare i valori in un modello di rilevatore nei seguenti modi:
+ Immettete le espressioni supportate nella AWS IoT Events console.
+ Passa le espressioni ai parametri AWS IoT Events APIs as.
Le espressioni supportano valori letterali, operatori, funzioni, riferimenti e modelli sostitutivi.
**Importante**
Le espressioni devono fare riferimento a un numero intero, decimale, stringa o valore booleano.
## Scrittura di AWS IoT Events espressioni
Guarda i seguenti esempi per aiutarti a scrivere AWS IoT Events le tue espressioni:
**Letterale**
Per i valori letterali, le espressioni devono contenere virgolette singole. Un valore booleano deve essere o`true`. `false`
```
'123' # Integer
'123.12' # Decimal
'hello' # String
'true' # Boolean
```
**Documentazione di riferimento**
Per i riferimenti, è necessario specificare variabili o valori di input.
+ Il seguente input fa riferimento a un numero decimale,. `10.01`
```
$input.GreenhouseInput.temperature
```
+ La variabile seguente fa riferimento a una stringa,. `Greenhouse Temperature Table`
```
$variable.TableName
```
**Modello sostitutivo**
Per un modello di sostituzione, è necessario utilizzare `${}` e il modello deve essere racchiuso tra virgolette singole. Un modello di sostituzione può anche contenere una combinazione di valori letterali, operatori, funzioni, riferimenti e modelli di sostituzione.
+ Il risultato valutato della seguente espressione è una stringa,. `50.018 in Fahrenheit`
```
'${$input.GreenhouseInput.temperature * 9 / 5 + 32} in Fahrenheit'
```
+ Il risultato valutato della seguente espressione è una stringa,. `{\"sensor_id\":\"Sensor_1\",\"temperature\":\"50.018\"}`
```
'{\"sensor_id\":\"${$input.GreenhouseInput.sensors[0].sensor1}\",\"temperature\":\"${$input.GreenhouseInput.temperature*9/5+32}\"}'
```
**Concatenamento di stringhe**
Per una concatenazione di stringhe, è necessario utilizzare `+`. Una concatenazione di stringhe può anche contenere una combinazione di valori letterali, operatori, funzioni, riferimenti e modelli di sostituzione.
+ Il risultato valutato della seguente espressione è una stringa,. `Greenhouse Temperature Table 2000-01-01`
```
'Greenhouse Temperature Table ' + $input.GreenhouseInput.date
```