Aviso de fin de soporte: el 20 de mayo de 2026, AWS finalizará el soporte para AWS IoT Events. Después del 20 de mayo de 2026, ya no podrás acceder a la AWS IoT Events consola ni a AWS IoT Events los recursos. Para obtener más información, consulta [AWS IoT Events el fin del soporte](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-end-of-support.html).
Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Expresiones para filtrar, transformar y procesar datos de eventos
Las expresiones se utilizan para evaluar los datos entrantes, realizar cálculos y determinar las condiciones en las que deben producirse acciones o transiciones de estado específicas. AWS IoT Events proporciona varias formas de especificar valores al crear y actualizar modelos de detectores. Puede usar expresiones para especificar valores literales o AWS IoT Events puede evaluar las expresiones antes de especificar valores determinados.
**Topics**
+ [Sintaxis para filtrar los datos del dispositivo y definir acciones en AWS IoT Events](#expression-syntax)
+ [Ejemplos de expresiones y uso para AWS IoT Events](expression-usage.md)
## Sintaxis para filtrar los datos del dispositivo y definir acciones en AWS IoT Events
Las expresiones ofrecen una sintaxis para filtrar los datos del dispositivo y definir acciones. Puede utilizar literales, operadores, funciones, referencias y plantillas de sustitución en las expresiones de AWS IoT Events . Al combinar estos componentes, puede crear expresiones potentes y flexibles para procesar datos de IoT, realizar cálculos, manipular cadenas y tomar decisiones lógicas dentro de sus modelos de detectores.
### Literales
+ Entero
+ Decimal
+ Cadena
+ Booleano
### Operadores
Unario
+ Not (Booleano): `!`
+ Not (bit a bit): `~`
+ Menos (aritmético): `-`
Cadena
+ Concatenación: **`+`**
Ambos operandos deben ser cadenas. Los literales de cadena se deben incluir entre comillas simples (').
Por ejemplo: `'my' + 'string'` -> `'mystring'`
Aritmético
+ Adición: **`+`**
Ambos operandos deben ser numéricos.
+ Sustracción: **`-`**
+ División: **`/`**
El resultado de la división es un valor entero redondeado, a menos que al menos uno de los operandos (divisor o dividendo) sea un valor decimal.
+ Multiplicación: **`*`**
Bit a bit (entero)
+ O BIEN: **`|`**
Por ejemplo: `13 | 5` -> `13`
+ Y: **`&`**
Por ejemplo: `13 & 5` -> `5`
+ XOR: **`^`**
Por ejemplo: `13 ^ 5` -> `8`
+ NOT: **`~`**
Por ejemplo: `~13` -> `-14`
Booleano
+ Menor que: **`<`**
+ Menor o igual que: **`<=`**
+ Igual a: **`==`**
+ No igual a: **`!=`**
+ Mayor o igual que: **`>=`**
+ Mayor que: **`>`**
+ Y: **`&&`**
+ O BIEN: **`||`**
**nota**
Cuando una subexpresión de `||` contiene datos indefinidos, esa subexpresión se trata como `false`.
Paréntesis
Puede usar paréntesis para agrupar términos dentro de una expresión.
### Funciones para usar en expresiones AWS IoT Events
AWS IoT Events proporciona un conjunto de funciones integradas para mejorar las capacidades de las expresiones del modelo de su detector. Estas funciones permiten la gestión del temporizador, la conversión de tipos, la comprobación de valores nulos, la identificación del tipo de disparador, la verificación de las entradas, la manipulación de cadenas y las operaciones bit a bit. Al aprovechar estas funciones, puede crear una lógica de AWS IoT Events procesamiento receptiva, lo que mejora la eficacia general de sus aplicaciones de IoT.
Funciones integradas
`timeout("timer-name")`
Da como resultado `true` si ha transcurrido el tiempo especificado. Sustituya **timer-name** "" por el nombre del temporizador que haya definido, entre comillas. En una acción de evento, puede definir un temporizador y luego iniciarlo, restablecerlo o borrar uno que haya definido con anterioridad. Consulte el campo `detectorModelDefinition.states.onInput|onEnter|onExit.events.actions.setTimer.timerName`.
Un temporizador creado en un estado puede ser referenciado en un estado diferente. Debe visitar el estado en el que creó el temporizador antes de entrar en el estado en el que se hace referencia al temporizador.
Por ejemplo, un modelo de detector tiene dos estados: `TemperatureChecked` y`RecordUpdated`. Ha creado un temporizador en el `TemperatureChecked` estado. Primero debe visitar el `TemperatureChecked` estado antes de poder usar el temporizador en el `RecordUpdated` estado.
Para garantizar la precisión, el tiempo mínimo que debe fijarse un temporizador es de 60 segundos.
`timeout()` devuelve `true` solo la primera vez que se comprueba tras el vencimiento real del temporizador y devuelve `false` a partir de entonces.
`convert(type, expression)`
Da como resultado el valor de la expresión convertida al tipo especificado. El *type* valor debe ser`String`,`Boolean`, o`Decimal`. Utilice una de estas palabras clave o una expresión que dé como resultado una cadena que contenga la palabra clave. Solo las siguientes conversiones tienen éxito y devuelven un valor válido:
+ Booleano -> cadena
Devuelve la cadena `"true"` o `"false"`.
+ Decimal -> cadena
+ Cadena -> Booleano
+ Cadena -> decimal
La cadena especificada debe ser una representación válida de un número decimal o `convert()` falla.
Si `convert()` no devuelve un valor válido, la expresión de la que forma parte tampoco es válida. Este resultado equivale a `false` y no activará las `actions` o la transición al `nextState` especificado como parte del evento en el que se produce la expresión.
`isNull(expression)`
Da como resultado `true` si la expresión devuelve un valor nulo. Por ejemplo, si la entrada `MyInput` recibe el mensaje `{ "a": null }`, entonces lo siguiente da como resultado `true`, pero `isUndefined($input.MyInput.a)` da como resultado `false`.
```
isNull($input.MyInput.a)
```
`isUndefined(expression)`
Da como resultado `true` si la expresión es indefinida. Por ejemplo, si la entrada `MyInput` recibe el mensaje `{ "a": null }`, entonces lo siguiente da como resultado `false`, pero `isNull($input.MyInput.a)` da como resultado `true`.
```
isUndefined($input.MyInput.a)
```
`triggerType("type")`
El valor de *type* puede ser `"Message"` o `"Timer"`. Se evalúa como `true` si la condición del evento en la que aparece se está evaluando porque un temporizador se ha vencido, como en el siguiente ejemplo.
```
triggerType("Timer")
```
O se ha recibido un mensaje de entrada.
```
triggerType("Message")
```
`currentInput("input")`
Da como resultado `true` si la condición del evento en la que aparece se está evaluando porque se ha recibido el mensaje de entrada especificado. Por ejemplo, si la entrada `Command` recibe el mensaje `{ "value": "Abort" }`, entonces da como resultado `true`.
```
currentInput("Command")
```
Utilice esta función para verificar que la condición se está evaluando porque se ha recibido un mensaje de entrada concreto y no se ha vencido un temporizador, como en la siguiente expresión.
```
currentInput("Command") && $input.Command.value == "Abort"
```
Funciones de coincidencia de cadenas
`startsWith(expression1, expression2)`
Da como resultado `true` si la primera expresión de cadena comienza con la segunda expresión de cadena. Por ejemplo, si la entrada `MyInput` recibe el mensaje `{ "status": "offline"}`, entonces lo siguiente da como resultado `true`.
```
startsWith($input.MyInput.status, "off")
```
Ambas expresiones deben dar como resultado un valor de cadena. Si alguna de las expresiones no da como resultado un valor de cadena, entonces el resultado de la función es indefinido. No se realiza ninguna conversión.
`endsWith(expression1, expression2)`
Da como resultado `true` si la primera expresión de cadena termina con la segunda expresión de cadena. Por ejemplo, si la entrada `MyInput` recibe el mensaje `{ "status": "offline" }`, entonces lo siguiente da como resultado `true`.
```
endsWith($input.MyInput.status, "line")
```
Ambas expresiones deben dar como resultado un valor de cadena. Si alguna de las expresiones no da como resultado un valor de cadena, entonces el resultado de la función es indefinido. No se realiza ninguna conversión.
`contains(expression1, expression2)`
Da como resultado `true` si la primera expresión de cadena contiene la segunda expresión de cadena. Por ejemplo, si la entrada `MyInput` recibe el mensaje `{ "status": "offline" }`, entonces lo siguiente da como resultado `true`.
```
contains($input.MyInput.value, "fli")
```
Ambas expresiones deben dar como resultado un valor de cadena. Si alguna de las expresiones no da como resultado un valor de cadena, entonces el resultado de la función es indefinido. No se realiza ninguna conversión.
Funciones de manipulación de enteros bit a bit
`bitor(expression1, expression2)`
Evalúa el OR bit a bit de las expresiones de enteros (la operación OR binaria se realiza en los bits correspondientes de los enteros). Por ejemplo, si la entrada `MyInput` recibe el mensaje `{ "value1": 13, "value2": 5 }`, entonces lo siguiente da como resultado `13`.
```
bitor($input.MyInput.value1, $input.MyInput.value2)
```
Ambas expresiones deben dar como resultado un valor entero. Si cualquiera de las expresiones no da como resultado un valor entero, el resultado de la función es indefinido. No se realiza ninguna conversión.
`bitand(expression1, expression2)`
Evalúa el AND bit a bit de las expresiones de enteros (la operación AND binaria se realiza en los bits correspondientes de los enteros). Por ejemplo, si la entrada `MyInput` recibe el mensaje `{ "value1": 13, "value2": 5 }`, entonces lo siguiente da como resultado `5`.
```
bitand($input.MyInput.value1, $input.MyInput.value2)
```
Ambas expresiones deben dar como resultado un valor entero. Si cualquiera de las expresiones no da como resultado un valor entero, el resultado de la función es indefinido. No se realiza ninguna conversión.
`bitxor(expression1, expression2)`
Evalúa el XOR bit a bit de las expresiones de enteros (la operación XOR binaria se realiza en los bits correspondientes de los enteros). Por ejemplo, si la entrada `MyInput` recibe el mensaje `{ "value1": 13, "value2": 5 }`, entonces lo siguiente da como resultado `8`.
```
bitxor($input.MyInput.value1, $input.MyInput.value2)
```
Ambas expresiones deben dar como resultado un valor entero. Si cualquiera de las expresiones no da como resultado un valor entero, el resultado de la función es indefinido. No se realiza ninguna conversión.
`bitnot(expression)`
Evalúa el NOT bit a bit de la expresión de enteros (la operación NOT binaria se realiza en los bits del entero). Por ejemplo, si la entrada `MyInput` recibe el mensaje `{ "value": 13 }`, entonces lo siguiente da como resultado `-14`.
```
bitnot($input.MyInput.value)
```
Ambas expresiones deben dar como resultado un valor entero. Si cualquiera de las expresiones no da como resultado un valor entero, el resultado de la función es indefinido. No se realiza ninguna conversión.
### AWS IoT Events referencia para las entradas y variables en las expresiones
Entradas
`$input.input-name.path-to-data`
`input-name`es una entrada que se crea mediante la [CreateInput](https://docs.aws.amazon.com/iotevents/latest/apireference/API_CreateInput.html)acción.
Por ejemplo, si tiene una entrada llamada `TemperatureInput` para la que ha definido entradas de `inputDefinition.attributes.jsonPath`, los valores podrían aparecer en los siguientes campos disponibles.
```
{
"temperature": 78.5,
"date": "2018-10-03T16:09:09Z"
}
```
Para hacer referencia al valor del campo `temperature`, utilice el siguiente comando.
```
$input.TemperatureInput.temperature
```
Para los campos cuyos valores son matrices, puede hacer referencia a los miembros de la matriz mediante `[n]`. Por ejemplo, dados los siguientes valores:
```
{
"temperatures": [
78.4,
77.9,
78.8
],
"date": "2018-10-03T16:09:09Z"
}
```
Se puede hacer referencia al valor `78.8` con el siguiente comando.
```
$input.TemperatureInput.temperatures[2]
```
Variables
`$variable.variable-name`
`variable-name`Es una variable que se definió mediante la [CreateDetectorModel](https://docs.aws.amazon.com/iotevents/latest/apireference/API_CreateDetectorModel.html)acción.
Por ejemplo, si tiene una variable llamada `TechnicianID` que ha definido mediante `detectorDefinition.states.onInputEvents.actions.setVariable.variableName`, puede hacer referencia al valor (cadena) dado más recientemente a la variable con el siguiente comando.
```
$variable.TechnicianID
```
Solo puede establecer los valores de las variables mediante la acción `setVariable`. No puede asignar valores a variables en una expresión. Una variable no se puede destruir. Por ejemplo, no puede asignarle el valor `null`.
**nota**
En las referencias que utilicen identificadores que no sigan el patrón (expresión regular) `[a-zA-Z][a-zA-Z0-9_]*`, debe encerrar dichos identificadores entre tildes graves (```). Por ejemplo, una referencia a una entrada llamada `MyInput` con un campo llamado `_value` debe especificar este campo como `$input.MyInput.`_value``.
Cuando utilice referencias en expresiones, compruebe lo siguiente:
+ Cuando utilice una referencia como operando con uno o más operadores, asegúrese de que todos los tipos de datos a los que hace referencia sean compatibles.
Por ejemplo, en la siguiente expresión, el entero `2` es un operando de los operadores `==` y `&&`. Para asegurarse de que los operandos sean compatibles, `$variable.testVariable + 1` y `$variable.testVariable` deben hacer referencia a un número entero o decimal.
Además, el entero `1` es un operando del operador `+`. Por lo tanto, `$variable.testVariable` debe hacer referencia a un número entero o decimal.
```
‘$variable.testVariable + 1 == 2 && $variable.testVariable’
```
+ Cuando utilice una referencia como argumento pasado a una función, asegúrese de que la función admita los tipos de datos a los que hace referencia.
Por ejemplo, la siguiente función `timeout("time-name")` requiere una cadena con comillas dobles como argumento. Si utiliza una referencia para el *timer-name* valor, debe hacer referencia a una cadena con comillas dobles.
```
timeout("timer-name")
```
**nota**
Para la `convert(type, expression)` función, si utiliza una referencia para el *type* valor, el resultado evaluado de la referencia debe ser `String``Decimal`, o`Boolean`.
AWS IoT Events las expresiones admiten tipos de datos enteros, decimales, de cadena y booleanos. En la tabla siguiente se ofrece una lista de pares de tipos incompatibles.
| Pares de tipos incompatibles |
| --- |
| Entero, cadena |
| Entero, booleano |
| Decimal, cadena |
| Decimal, booleano |
| Cadena, booleano |
### Plantillas de sustitución para expresiones AWS IoT Events
****
`'${expression}'`
`${}` identifica la cadena como una cadena interpolada. `expression`Puede ser cualquier AWS IoT Events expresión. Esto incluye operadores, funciones y referencias.
Por ejemplo, ha utilizado la [SetVariableAction](https://docs.aws.amazon.com/iotevents/latest/apireference/API_SetVariableAction.html)acción para definir una variable. El `variableName` es `SensorID` y el `value` es `10`. Puede crear las siguientes plantillas de sustitución.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/iotevents/latest/developerguide/iotevents-expressions.html)
# Ejemplos de expresiones y uso para AWS IoT Events
Puede especificar valores en un modelo de detector de las siguientes maneras:
+ Introduzca las expresiones compatibles en la AWS IoT Events consola.
+ Pase las expresiones a los parámetros AWS IoT Events APIs as.
Las expresiones admiten literales, operadores, funciones, referencias y plantillas de sustitución.
**importante**
Sus expresiones deben hacer referencia a un valor entero, decimal, de cadena o booleano.
## Escribir AWS IoT Events expresiones
Consulta los siguientes ejemplos para ayudarte a escribir tus AWS IoT Events expresiones:
**Literal**
En los valores literales, las expresiones deben contener comillas simples. Un valor booleano debe ser `true` o `false`.
```
'123' # Integer
'123.12' # Decimal
'hello' # String
'true' # Boolean
```
**Referencia**
En las referencias, debe especificar variables o valores de entrada.
+ La siguiente entrada hace referencia a un número decimal, `10.01`.
```
$input.GreenhouseInput.temperature
```
+ La siguiente variable hace referencia a una cadena, `Greenhouse Temperature Table`.
```
$variable.TableName
```
**Plantilla de sustitución**
En una plantilla de sustitución, debe usar `${}` y la plantilla debe estar entre comillas simples. Una plantilla de sustitución también puede contener una combinación de literales, operadores, funciones, referencias y plantillas de sustitución.
+ El resultado evaluado de la siguiente expresión es una cadena, `50.018 in Fahrenheit`.
```
'${$input.GreenhouseInput.temperature * 9 / 5 + 32} in Fahrenheit'
```
+ El resultado evaluado de la siguiente expresión es una cadena, `{\"sensor_id\":\"Sensor_1\",\"temperature\":\"50.018\"}`.
```
'{\"sensor_id\":\"${$input.GreenhouseInput.sensors[0].sensor1}\",\"temperature\":\"${$input.GreenhouseInput.temperature*9/5+32}\"}'
```
**Concatenación de cadenas**
En una concatenación de cadenas, debe usar `+`. Una concatenación de cadenas también puede contener una combinación de literales, operadores, funciones, referencias y plantillas de sustitución.
+ El resultado evaluado de la siguiente expresión es una cadena, `Greenhouse Temperature Table 2000-01-01`.
```
'Greenhouse Temperature Table ' + $input.GreenhouseInput.date
```