{"section":"tutorials","requestedLocale":"es","requestedSlug":"glossario-de-expressoes","locale":"es","slug":"glossario-de-expressoes","path":"docs/es/tutorials/weni-by-vtex/flujos/glossario-de-expressoes.md","branch":"main","content":"Las expresiones son fórmulas utilizadas en la plataforma de manera muy similar a las usadas en programas de hojas de cálculo, como Microsoft Excel. Aunque han evolucionado con el tiempo y estas similitudes son ahora menores, siguen siendo una herramienta poderosa. Es un lenguaje de modelado basado en expresiones que facilita la generación de texto a partir de un contexto de valores.\n\nEn este artículo abordaremos:\n\n- Modelos\n- Tipos\n- Operadores\n- Funciones\n\n## Modelos\n\nLas expresiones pueden invocarse usando el siguiente modelo: `@(...)`.\n\nPor ejemplo, el modelo `Hi `@(\"\"Dr \"\" & upper(foo))``toma el valor de la variable`@foo`, lo convierte a mayúsculas y lo prefija con otra palabra. Observa que dentro de una expresión compleja no es necesario poner `@` antes de todas las variables.\n\n## Tipos\n\nTenemos los siguientes tipos de expresiones aceptados en la plataforma:\n\n### Array\n\nUsado para la creación de un array de elementos.\n\n    ```\n    @(array(1, \"\"x\"\", true)) → [1, x, true]\n    @(array(1, \"\"x\"\", true)[1]) → x\n    @(count(array(1, \"\"x\"\", true))) → 3\n    @(json(array(1, \"\"x\"\", true))) → [1,\"\"x\"\",true]\n    ```\n\n### Booleano\n\nEs un valor booleano que puede ser verdadero o falso.\n\n    ```\n    @(true) → true\n    @(1 = 1) → true\n    @(1 = 2) → false\n    @(json(true)) → true\n    ```\n\n### Fecha\n\nEs un valor de fecha del calendario gregoriano.\n\n    ```\n    @(date_from_parts(2019, 4, 11)) → 2019-04-11@(format_date(date_from_parts(2019, 4, 11))) → 11-04-2019@(json(date_from_parts(2019, 4, 11))) → \"\"2019-04-11\"\"\n    ```\n\n### Fecha y hora\n\nEs un valor que incluye tanto la fecha como la hora.\n\n    ```\n    @(datetime(\"\"1979-07-18T10:30:45.123456Z\"\")) → 1979-07-18T10:30:45.123456Z\n    @(format_datetime(datetime(\"\"1979-07-18T10:30:45.123456Z\"\"))) → 18-07-1979 05:30@(json(datetime(\"\"1979-07-18T10:30:45.123456Z\"\"))) → \"\"1979-07-18T10:30:45.123456Z\"\"\n    ```\n\n### Función\n\nEs una operación o procedimiento que puede ser llamada para realizar una tarea específica o calcular un valor.\n\n    ```\n    @(upper) → function\n    @(array(upper)[0](\"\"abc\"\")) → ABC\n    @(json(upper)) → null\n    ```\n\n### Número\n\nEs un valor numérico que puede ser entero o fraccionado.\n\n    ```\n    @(1234) → 1234\n    @(1234.5678) → 1234.5678\n    @(format_number(1234.5670)) → 1,234.567\n    @(json(1234.5678)) → 1234.5678\n    ```\n\n### Objeto\n\nEs una estructura que contiene propiedades nombradas.\n\n    ```\n    @(object(\"\"foo\"\", 1, \"\"bar\"\", \"\"x\"\")) → {bar: x, foo: 1}\n    @(object(\"\"foo\"\", 1, \"\"bar\"\", \"\"x\"\").bar) → x\n    @(object(\"\"foo\"\", 1, \"\"bar\"\", \"\"x\"\")[\"\"bar\"\"]) → x\n    @(count(object(\"\"foo\"\", 1, \"\"bar\"\", \"\"x\"\"))) → 2\n    @(json(object(\"\"foo\"\", 1, \"\"bar\"\", \"\"x\"\"))) → {\"\"bar\"\":\"\"x\"\",\"\"foo\"\":1}\n    ```\n\n### Texto\n\nEs una secuencia de caracteres.\n\n    ```\n    @(\"\"abc\"\") → abc\n    @(text_length(\"\"abc\"\")) → 3\n    @(upper(\"\"abc\"\")) → ABC\n    @(json(\"\"abc\"\")) → \"\"abc\"\"\n    ```\n\n### Tiempo\n\nEs una hora del día.\n\n    ```\n    @(time_from_parts(16, 30, 45)) → 16:30:45.000000@(format_time(time_from_parts(16, 30, 45))) → 16:30@(json(time_from_parts(16, 30, 45))) → \"\"16:30:45.000000\"\"\n    ```\n\n## Operadores\n\nA continuación, se muestra la lista de todos los operadores que pueden utilizarse en la construcción de expresiones en la plataforma:\n\\+ : suma dos números\n\n    ```\n    @(2 + 3) → 5\n    @(fields.age + 10) → 33\n    ```\n\n& : une dos valores de texto\n\n    ```\n    @(\"\"hello\"\" & \"\" \"\" & \"\"bar\"\") → hello bar\n    @(\"\"hello\"\" & null) → hello\n    ```\n\n/ : divide un número por otro\n\n    ```\n    @(4 / 2) → 2@(3 / 2) → 1.5\n    @(46 / fields.age) → 2\n    @(3 / 0) → ERROR\n    ```\n\n= : retorna \"\"true\"\" si dos valores son textualmente iguales\n\n    ```\n    @(\"\"hello\"\" = \"\"hello\"\") → true\n    @(\"\"hello\"\" = \"\"bar\"\") → false\n    @(1 = 1) → true\n    ```\n\n^ : eleva un número a la potencia de otro\n\n    ```\n    @(2 ^ 8) → 256\n    ```\n\n**>** : retorna \"\"true\"\" si el primer número es mayor que el segundo\n\n    ```\n    @(2 > 3) → false@(3 > 3) → false@(4 > 3) → true\n    ```\n\n**> =** : retorna \"\"true\"\" si el primer número es mayor o igual que el segundo\n\n    ```\n    @(2 >= 3) → false\n    @(3 >= 3) → true\n    @(4 >= 3) → true\n    ```\n\n**<** : retorna \"\"true\"\" si el primer número es menor que el segundo\n\n    ```\n    @(2 < 3) → true\n    @(3 < 3) → false\n    @(4 < 3) → false\n    ```\n\n**< =** : retorna \"\"true\"\" si el primer número es menor o igual que el segundo\n\n    ```\n    @(2 <= 3) → true\n    @(3 <= 3) → true\n    @(4 <= 3) → false\n    ```\n\n**\\*** : multiplica dos números\n\n    ```\n    @(3 * 2) → 6\n    @(fields.age * 3) → 69\n    ```\n\n**-** (unario) : niega un número\n\n    ```\n    @(-fields.age) → -23\n    ```\n\n**!** : retorna \"\"true\"\" si dos valores no son textualmente iguales\n\n    ```\n    @(\"\"hello\"\" != \"\"hello\"\") → false\n    @(\"\"hello\"\" != \"\"bar\"\") → true\n    @(1 != 2) → true\n    ```\n\n**\\- (binario) :** resta dos números\n\n    ```\n    @(3 - 2) → 1\n    @(2 - 3) → -1\n    ```\n\n## Funciones\n\nLas expresiones tienen acceso a un conjunto de funciones internas que pueden utilizarse para ejecutar tareas más complejas. Las funciones se llaman utilizando la sintaxis `@(function_name(args..))` y pueden recibir como argumentos valores literales `@(length(split(\"\"1 2 3\"\", \"\" \"\")))` o variables en el contexto `@(title(contact.name))`.\n\n`abs(número)`: devuelve el valor absoluto de un `number`.\n\n    ```\n    @(abs(-10)) → 10\n    @(abs(10.5)) → 10.5\n    @(abs(\"\"foo\"\")) → ERROR\n    ```\n\n`and(valores...)`: devuelve \"\"`true`\"\" si todos los datos de `values` son verdaderos.\n\n    ```\n    @(and(true)) → true\n    @(and(true, false, true)) → false\n    ```\n\n`array(valores...)`: toma varios `values` y los devuelve como una matriz.\n\n    ```\n    @(array(\"\"a\"\", \"\"b\"\", 356)[1]) → b\n    @(join(array(\"\"a\"\", \"\"b\"\", \"\"c\"\"), \"\"|\"\")) → a|b|c\n    @(count(array())) → 0\n    @(count(array(\"\"a\"\", \"\"b\"\"))) → 2\n    ```\n\n`attachment_parts(anexo)`: analiza un anexo en sus diferentes partes.\n\n    ```\n    @(attachment_parts(\"\"image/jpeg:https://example.com/test.jpg\"\")) → {content_type: image/jpeg, url: https://example.com/test.jpg}\n    ```\n\n`boolean(valor)`: intenta convertir `value` en un booleano. Se devolverá un error si el valor no puede ser convertido.\n\n    @(boolean(array(1, 2))) → true\n    @(boolean(\"\"FALSE\"\")) → false\n    @(boolean(1 / 0)) → ERROR\n\n`char(código)`: devuelve el carácter para el código UNICODE proporcionado. Es el inverso de código.\n\n    @(char(33)) → !\n\n    @(char(128512)) → 😀\n    @(char(\"\"foo\"\")) → ERROR\n\n`clean(texto)`: elimina todos los caracteres no imprimibles del `text`. Es el inverso de `char`.\n\n    @(clean(\"\"😃 Hello \\nwo\\tr\\rld\"\")) → 😃 Hello world\n    @(clean(123)) → 123\n\n`code(texto)`: devuelve el código UNICODE del primer carácter del `text`. Es el inverso de `char`.\n\n    @(code(\"\"a\"\")) → 97\n    @(code(\"\"abc\"\")) → 97\n    @(code(\"\"😀\"\")) → 128512\n    @(code(\"\"15\"\")) → 49\n    @(code(15)) → 49\n    @(code(\"\"\"\")) → ERROR\n\n`count(valor)`: devuelve el número de elementos en la matriz o las propiedades especificadas en un objeto. Devolverá un error si se pasa un elemento que no es contable.\n\n    @(count(contact.fields)) → 5\n    @(count(array())) → 0\n    @(count(array(\"\"a\"\", \"\"b\"\", \"\"c\"\"))) → 3\n    @(count(1234)) → ERROR\n\n`date(valor)`: intenta convertir `value` en una fecha. Si es texto, se analizará utilizando el formato de fecha predeterminado. Se devolverá un error si el valor no puede ser convertido.\n\n    @(date(\"\"1979-07-18\"\")) → 1979-07-18\n    @(date(\"\"1979-07-18T10:30:45.123456Z\"\")) → 1979-07-18@(date(\"\"10/05/2010\"\")) → 2010-05-10\n    @(date(\"\"NOT DATE\"\")) → ERROR\n\n`date_from_parts(año, mes, día)`: crea una fecha a partir de `year``month``day`\n\n    @(date_from_parts(2017, 1, 15)) → 2017-01-15\n    @(date_from_parts(2017, 2, 31)) → 2017-03-03\n    @(date_from_parts(2017, 13, 15)) → ERROR\n\n`datetime(valor)`: intenta convertir `_value_` en una `datatime`. Si es texto, se analizará utilizando los formatos predeterminados de fecha y hora. Se devolverá un error si el valor no puede ser convertido.\n\n    @(datetime(\"\"1979-07-18\"\")) → 1979-07-18T00:00:00.000000-05:00@(datetime(\"\"1979-07-18T10:30:45.123456Z\"\")) → 1979-07-18T10:30:45.123456Z\n    @(datetime(\"\"10/05/2010\"\")) → 2010-05-10T00:00:00.000000-05:00\n    @(datetime(\"\"NOT DATE\"\")) → ERROR\n\n`datetime_add(datetime, offset, unit)`: Calcula el valor de la fecha sumando el `offset` número de `unit` a la `datetime`. Las unidades de duración válidas son \"\"Y\"\" para años, \"\"M\"\" para meses, \"\"W\"\" para semanas, \"\"D\"\" para días, \"\"h\"\" para horas, \"\"m\"\" para minutos y \"\"s\"\" para segundos.\n\n    @(datetime_add(\"\"2017-01-15\"\", 5, \"\"D\"\")) → 2017-01-20T00:00:00.000000-05:00\n    @(datetime_add(\"\"2017-01-15 10:45\"\", 30, \"\"m\"\")) → 2017-01-15T11:15:00.000000-05:00\n\n`datetime_diff(date1, date2, unidade)`: devuelve la duración entre `date1` y `date2` en la `unit` especificada. Las unidades de duración válidas son \"\"Y\"\" para años, \"\"M\"\" para meses, \"\"W\"\" para semanas, \"\"D\"\" para días, \"\"h\"\" para horas, \"\"m\"\" para minutos y \"\"s\"\" para segundos.\n\n    @(datetime_diff(\"\"2017-01-15\"\", \"\"2017-01-17\"\", \"\"D\"\")) → 2@(datetime_diff(\"\"2017-01-15\"\", \"\"2017-05-15\"\", \"\"W\"\")) → 17@(datetime_diff(\"\"2017-01-15\"\", \"\"2017-05-15\"\", \"\"M\"\")) → 4\n    @(datetime_diff(\"\"2017-01-17 10:50\"\", \"\"2017-01-17 12:30\"\", \"\"h\"\")) → 1@(datetime_diff(\"\"2017-01-17\"\", \"\"2015-12-17\"\", \"\"Y\"\")) → -2\n\n`datetime_from_epoch(segundos)`: convierte el tiempo de la época UNIX en seconds a una nueva fecha.\n\n    ```\n    @(datetime_from_epoch(1497286619)) → 2017-06-12T11:56:59.000000-05:00@(datetime_from_epoch(1497286619.123456)) → 2017-06-12T11:56:59.123456-05:00\n    ```\n\n`default(valor, padrão)`: devuelve `value` si no está vacío o con error, de lo contrario, devolverá `default`.\n\n    ```\n    @(default(undeclared.var, \"\"default_value\"\")) → default_value@(default(\"\"10\"\", \"\"20\"\")) → 10\n    @(default(\"\"\"\", \"\"value\"\")) → value\n    @(default(\"\"  \"\", \"\"value\"\")) → \\x20\\x20\n    @(default(datetime(\"\"invalid-date\"\"), \"\"today\"\")) → today@(default(format_urn(\"\"invalid-urn\"\"), \"\"ok\"\")) → ok\n    ```\n\n`epoch(data)`: convierte `date` en un tiempo de época UNIX. El número devuelto puede contener segundos fraccionarios.\n\n    ```\n    @(epoch(\"\"2017-06-12T16:56:59.000000Z\"\")) → 1497286619\n    @(epoch(\"\"2017-06-12T18:56:59.000000+02:00\"\")) → 1497286619@(epoch(\"\"2017-06-12T16:56:59.123456Z\"\")) → 1497286619.123456@(round_down(epoch(\"\"2017-06-12T16:56:59.123456Z\"\"))) → 1497286619\n    ```\n\n`extract(objeto, propriedades`: toma un objeto y extrae la propiedad nombrada.\n\n    ```\n    @(extract(contact, \"\"name\"\")) → Ryan Lewis\n    @(extract(contact.groups[0], \"\"name\"\")) → Testers\n    ```\n\n`extract_object(objeto, propriedades...)`: toma un objeto y devuelve un nuevo objeto extrayendo solo las propiedades nombradas.\n\n    ```\n    @(extract_object(contact.groups[0], \"\"name\"\")) → {name: Testers}\n    ```\n\n`field(texto, índice, delimitador)`: divide el `text` utilizando el `delimiter` dado y devuelve el campo correspondiente al `index`. El índice comienza en cero. Al dividir con un espacio, el delimitador se considera como todo el espacio en blanco.\n\n    ```\n    @(field(\"\"a,b,c\"\", 1, \"\",\"\")) → b\n    @(field(\"\"a,,b,c\"\", 1, \"\",\"\")) →\n    @(field(\"\"a   b c\"\", 1, \"\" \"\")) → b\n    @(field(\"\"a      b   c   d\"\", 1, \"\"    \"\")) →\n    @(field(\"\"a\\t\\tb\\tc\\td\"\", 1, \"\" \"\")) →\n    @(field(\"\"a,b,c\"\", \"\"foo\"\", \"\",\"\")) → ERROR\n    ```\n\n`foreach(valores, func, [argumentos...])`: crea una nueva matriz aplicando `func` a cada valor en `values`. Si la función proporcionada acepta más de un argumento, puedes pasar argumentos adicionales después de la función.\n\n    ```\n    @(foreach(array(\"\"a\"\", \"\"b\"\", \"\"c\"\"), upper)) → [A, B, C]@(foreach(array(\"\"the man\"\", \"\"fox\"\", \"\"jumped up\"\"), word, 0)) → [the, fox, jumped]\n    ```\n\n`foreach_value(objeto, func, [args...])`: crea un nuevo objeto aplicando `func` a cada valor de propiedad de `object`. Si la función proporcionada acepta más de un argumento, puedes pasar argumentos adicionales después de la función.\n\n    ```\n    @(foreach_value(object(\"\"a\"\", \"\"x\"\", \"\"b\"\", \"\"y\"\"), upper)) → {a: X, b: Y}@(foreach_value(object(\"\"a\"\", \"\"hi there\"\", \"\"b\"\", \"\"good bye\"\"), word, 1)) → {a: there, b: bye}\n    ```\n\n`format(valor)`: formatea `value` según su tipo.\n\n    ```\n    @(format(1234.5670)) → 1,234.567\n    @(format(now())) → 11-04-2018 13:24\n    @(format(today())) → 11-04-2018\n    ```\n\n`format_date(data, [, formato])`: formatea `date` como texto según el formato dado. Si no se especifica formato, se utilizará el formato predeterminado del entorno. La cadena de formato puede consistir en los siguientes caracteres. Los caracteres '', ':', ',', 'T', '-' y '\\_' son ignorados. Cualquier otro carácter es un error.\n\n\\- `YY`: últimos dos dígitos del año 0-99\n\\- `YYYY`: cuatro dígitos del año 0000-9999\n\\- `M`: devuelve el mes sin ceros 1-12\n\\- `MM`: devuelve el mes con ceros 01-12\n\\- `D`: día del mes 1-31\n\\- `DD`: día del mes con ceros 01-31\n\n    @(format_date(\"\"1979-07-18T15:00:00.000000Z\"\")) → 18-07-1979@(format_date(\"\"1979-07-18T15:00:00.000000Z\"\", \"\"YYYY-MM-DD\"\")) → 1979-07-18@(format_date(\"\"2010-05-10T19:50:00.000000Z\"\", \"\"YYYY M DD\"\")) → 2010 5 10@(format_date(\"\"1979-07-18T15:00:00.000000Z\"\", \"\"YYYY\"\")) → 1979\n    @(format_date(\"\"1979-07-18T15:00:00.000000Z\"\", \"\"M\"\")) → 7\n    @(format_date(\"\"NOT DATE\"\", \"\"YYYY-MM-DD\"\")) → ERROR\n\n`format_datetime (data e hora [, formato [, fuso horário]])`\nFormatea `datetime` como texto según el formato dado. Si no se especifica formato, se utilizará el formato predeterminado del entorno. La cadena de formato puede consistir en los siguientes caracteres. Los caracteres '', ':', ',', 'T', '-' y '\\_' son ignorados. Cualquier otro carácter es un error.\n\n\\- `YY`: últimos dos dígitos del año 0-99\n\\- `YYYY`: cuatro dígitos del año 0000-9999\n\\- `M`: devuelve el mes sin ceros 1-12\n\\- `MM`: devuelve el mes con ceros 01-12\n\\- `D`: día del mes 1-31\n\\- `DD`: día del mes con ceros 01-31\n\\- `h`: hora del día 1-12\n\\- `hh`: hora del día 01-12\n\\- `tt`: veinticuatro horas del día 00-23\n\\- `m`: minuto sin ceros 0-59\n\\- `mm`: minuto con ceros 00-59\n\\- `s`: segundo sin ceros 0-59\n\\- `ss`: segundo con ceros 00-59\n\\- `fff`: milisegundos\n\\- `ffffff`: microsegundos\n\\- `fffffffff`: nanosegundos\n\\- `aa`: AM o PM\n\\- `AA`: AM o PM\n\\- `Z`: desplazamiento de hora y minuto de UTC o Z de UTC\n\\- `ZZZ`: desplazamiento de hora y minuto de UTC\nEl huso horario debe ser el nombre de la ubicación, según lo especificado en la base de datos de husos horarios de IANA, como \"\"America/Guayaquil\"\" o \"\"America/Los_Angeles\"\". Si no se especifica, se utilizará el huso horario actual. Se devolverá un error si el huso horario no es reconocido.\n\n    ```\n    @(format_datetime(\"\"1979-07-18T15:00:00.000000Z\"\")) → 18-07-1979 10:00@(format_datetime(\"\"1979-07-18T15:00:00.000000Z\"\", \"\"YYYY-MM-DD\"\")) → 1979-07-18\n    @(format_datetime(\"\"2010-05-10T19:50:00.000000Z\"\", \"\"YYYY M DD tt:mm\"\")) → 2010 5 10 14:50\n    @(format_datetime(\"\"2010-05-10T19:50:00.000000Z\"\", \"\"YYYY-MM-DD hh:mm AA\"\", \"\"America/Los_Angeles\"\")) → 2010-05-10 12:50 PM\n    @(format_datetime(\"\"1979-07-18T15:00:00.000000Z\"\", \"\"YYYY\"\")) → 1979@(format_datetime(\"\"1979-07-18T15:00:00.000000Z\"\", \"\"M\"\")) → 7\n    @(format_datetime(\"\"NOT DATE\"\", \"\"YYYY-MM-DD\"\")) → ERROR\n    ```\n\n`format_location(local)`: formatea el `location` dado como su nombre.\n\n    ```\n    @(format_location(\"\"Rwanda\"\")) → Rwanda\n    @(format_location(\"\"Rwanda > Kigali\"\")) → Kigali\n    ```\n\n`format_number(número, lugares [, humanizar])`: formatea `number` al número decimal especificado en `places`. Un tercer argumento opcional `humanize` puede ser falso para desactivar el uso de separadores de miles.\n\n    ```\n    @(format_number(1234)) → 1,234@(format_number(1234.5670)) → 1,234.567@(format_number(1234.5670, 2, true)) → 1,234.57@(format_number(1234.5678, 0, false)) → 1235@(format_number(\"\"foo\"\", 2, false)) → ERROR\n    ```\n\n`format_time(hora, [, formato])`: formatea `time` como texto según el formato dado. Si no se especifica formato, se utilizará el formato predeterminado del entorno. La cadena de formato puede consistir en los siguientes caracteres. Los caracteres '', ':', ',', 'T', '-' y '\\_' son ignorados. Cualquier otro carácter es un error.\n\n\\- `h`: hora del día 1-12\n\\- `hh`: hora del día 01-12\n\\- `tt`: veinticuatro horas del día 00-23\n\\- `m`: minuto sin ceros 0-59\n\\- `mm`: minuto con ceros 00-59\n\\- `s`: segundo sin ceros 0-59\n\\- `ss`: segundo con ceros 00-59\n\\- `fff`: milisegundos\n\\- `ffffff`: microsegundos\n\\- `fffffffff`: nanosegundos\n\\- `aa`: AM o PM\n\\- `AA`: AM o PM\n\n    ```\n    @(format_time(\"\"14:50:30.000000\"\")) → 14:50@(format_time(\"\"14:50:30.000000\"\", \"\"h:mm aa\"\")) → 2:50 pm@(format_time(\"\"15:00:27.000000\"\", \"\"s\"\")) → 27\n    @(format_time(\"\"NOT TIME\"\", \"\"hh:mm\"\")) → ERROR\n    ```\n\n`format_urn(urn)`: formatea `urn` en un texto amigable para humanos.\n\n    ```\n    @(format_urn(\"\"tel:+250781234567\"\")) → 0781 234 567@(format_urn(\"\"twitter:134252511151#billy_bob\"\")) → billy_bob@(format_urn(contact.urn)) → (202) 456-1111\n    @(format_urn(urns.tel)) → (202) 456-1111\n    @(format_urn(urns.mailto)) → foo@bar.com\n    @(format_urn(\"\"NOT URN\"\")) → ERROR\n    ```\n\n`html_decode(texto)`: decodifica el HTML text.\n\n    ```\n    @(html_decode(\"\"Red &amp; Blue\"\")) → Red & Blue\n    @(html_decode(\"\"5 + 10\"\")) → 5 + 10\n    ```\n\n`if(teste, valor1, valor2)`: devuelve `valor1` si test es verdadero y `valor2` si no lo es. Si el primer argumento es un error, ese error será devuelto.\n\n    ```\n    @(if(1 = 1, \"\"foo\"\", \"\"bar\"\")) → foo\n    @(if(\"\"foo\"\" > \"\"bar\"\", \"\"foo\"\", \"\"bar\"\")) → ERROR\n    ```\n\n`is_error(valor)`: devuelve true si value tiene un error.\n\n    ```\n    @(is_error(datetime(\"\"foo\"\"))) → true\n    @(is_error(run.not.existing)) → true\n    @(is_error(\"\"hello\"\")) → false\n    ```\n\n`join(matriz, separador)`: une el array de cadenas utilizando el separator dado para formar un texto.\n\n    ```\n    @(join(array(\"\"a\"\", \"\"b\"\", \"\"c\"\"), \"\"|\"\")) → a|b|c\n    @(join(split(\"\"a.b.c\"\", \"\".\"\"), \"\" \"\")) → a b c\n    ```\n\n`json(valor)`: devuelve la representación JSON de value.\n\n    ```\n    @(json(\"\"string\"\")) → \"\"string\"\"\n    @(json(10)) → 10\n    @(json(null)) → null\n    @(json(contact.uuid)) → \"\"5d76d86b-3bb9-4d5a-b822-c9d86f5d8e4f\"\"\n    ```\n\n`lower(texto)`: convierte `text` a minúsculas.\n\n    ```\n    @(lower(\"\"HellO\"\")) → hello\n    @(lower(\"\"hello\"\")) → hello\n    @(lower(\"\"123\"\")) → 123\n    @(lower(\"\"😀\"\")) → 😀\n    ```\n\n`max(números...)`: devuelve el valor máximo en `numbers`.\n\n    ```\n    @(max(1, 2)) → 2\n    @(max(1, -1, 10)) → 10\n    @(max(1, 10, \"\"foo\"\")) → ERROR\n    ```\n\n`mean(números...)`: devuelve el promedio aritmético de `numbers`.\n\n    ```\n    @(mean(1, 2)) → 1.5\n    @(mean(1, 2, 6)) → 3\n    @(mean(1, \"\"foo\"\")) → ERROR\n    ```\n\n`min(números...)`: devuelve el valor mínimo en `numbers`.\n\n    ```\n    @(min(1, 2)) → 1\n    @(min(2, 2, -10)) → -10\n    @(min(1, 2, \"\"foo\"\")) → ERROR\n    ```\n\n`mod(dividendo, divisor)`: devuelve el resto de la división de dividend por divisor.\n\n    ```\n    @(mod(5, 2)) → 1\n    @(mod(4, 2)) → 0\n    @(mod(5, \"\"foo\"\")) → ERROR\n    ```\n\n`now()`: devuelve la fecha y la hora actuales en la zona horaria actual.\n\n    ```\n    @(now()) → 2018-04-11T13:24:30.123456-05:00\n    ```\n\n`number(valores)`: intenta convertir `value` en un número. Se devolverá un error si el valor no puede ser convertido.\n\n    ```\n    @(number(10)) → 10\n    @(number(\"\"123.45000\"\")) → 123.45\n    @(number(\"\"what?\"\")) → ERROR\n    ```\n\n`object(pares...)`: toma los pares de valores de nombre de propiedad y los devuelve como un nuevo objeto.\n\n    ```\n    @(object()) → {}\n    @(object(\"\"a\"\", 123, \"\"b\"\", \"\"hello\"\")) → {a: 123, b: hello}\n    @(object(\"\"a\"\")) → ERROR\n    ```\n\n`or(valores...)`: devuelve true si alguno de los values es verdadero.\n\n    ```\n    @(or(true)) → true\n    @(or(true, false, true)) → true\n    ```\n\n`parse_datetime(texto, formato [, fuso horário])`: analiza text en una fecha usando el formato dado. La cadena de formato puede consistir en los siguientes caracteres. Los caracteres '', ':', ',', 'T', '-' y '\\_' son ignorados. Cualquier otro carácter es un error.\n\n\\- `YY`: últimos dos dígitos del año 0-99\n\\- `YYYY`: cuatro dígitos del año 0000-9999\n\\- `M`: mes 1-12\n\\- `MM`: mes 01-12\n\\- `D`: día del mes sin ceros 1-31\n\\- `DD`: día del mes con ceros 01-31\n\\- `h`: hora del día sin ceros 1-12\n\\- `hh`: hora del día con ceros 01-12\n\\- `tt`: veinticuatro horas del día 00-23\n\\- `m`: minuto sin ceros 0-59\n\\- `mm`: minuto con ceros 00-59\n\\- `s`: segundo sin ceros 0-59\n\\- `ss`: segundo con ceros 00-59\n\\- `fff`: milisegundos\n\\- `ffffff`: microsegundos\n\\- `fffffffff`: nanosegundos\n\\- `aa`: AM o PM\n\\- `AA`: AM o PM\n\\- `Z`: desplazamiento de hora y minuto de UTC o Z de UTC\n\\- `ZZZ`: desplazamiento de hora y minuto de UTC\nEl huso horario debe ser el nombre de la ubicación, según lo especificado en la base de datos de husos horarios de IANA, como \"\"America/Guayaquil\"\" o \"\"America/Los_Angeles\"\". Si no se especifica, se utilizará el huso horario actual. Se devolverá un error si el huso horario no es reconocido.\n\nTen en cuenta que los segundos fraccionarios serán analizados incluso sin un identificador de formato explícito. Solo debes especificar segundos fraccionarios cuando desees establecer el número de lugares en el formato de entrada.\n\n`parse_datetime` devolverá un error si no puede convertir el texto en una `datetime`.\n\n    ```\n    @(parse_datetime(\"\"1979-07-18\"\", \"\"YYYY-MM-DD\"\")) → 1979-07-18T00:00:00.000000-05:00\n    @(parse_datetime(\"\"2010 5 10\"\", \"\"YYYY M DD\"\")) → 2010-05-10T00:00:00.000000-05:00@(parse_datetime(\"\"2010 5 10 12:50\"\", \"\"YYYY M DD tt:mm\"\", \"\"America/Los_Angeles\"\")) → 2010-05-10T12:50:00.000000-07:00\n    @(parse_datetime(\"\"NOT DATE\"\", \"\"YYYY-MM-DD\"\")) → ERROR\n    ```\n\n`parse_json(texto)`: intenta analizar text como JSON. Si el text JSON proporcionado no es válido, se devolverá un error.\n\n    ```\n    @(parse_json(\"\"{\\\"\"foo\\\"\": \\\"\"bar\\\"\"}\"\").foo) → bar\n    @(parse_json(\"\"[1,2,3,4]\"\")[2]) → 3\n    @(parse_json(\"\"invalid json\"\")) → ERROR\n    ```\n\n`parse_time(texto, formato)`: analiza text en un tiempo usando el formato dado. La cadena de formato puede consistir en los siguientes caracteres. Los caracteres '', ':', ',', 'T', '-' y '\\_' son ignorados. Cualquier otro carácter es un error.\n\n\\- `h`: hora del día 1-12\n\\- `hh`: hora del día 01-12\n\\- `tt`: veinticuatro horas del día 00-23\n\\- `m`: minuto sin ceros 0-59\n\\- `mm`: minuto con ceros 00-59\n\\- `s`: segundo sin ceros 0-59\n\\- `ss`: segundo con ceros 00-59\n\\- `fff`: milisegundos\n\\- `ffffff`: microsegundos\n\\- `fffffffff`: nanosegundos\n\\- `aa`: AM o PM\n\\- `AA`: AM o PM\nTen en cuenta que los segundos fraccionarios serán analizados incluso sin un identificador de formato explícito. Solo debes especificar segundos fraccionarios cuando desees establecer el número de lugares en el formato de entrada.\n\n`parse_time` devolverá un error si no puede convertir el texto en un `datetime`.\n\n    ```\n    @(parse_time(\"\"15:28\"\", \"\"tt:mm\"\")) → 15:28:00.000000\n    @(parse_time(\"\"2:40 pm\"\", \"\"h:mm aa\"\")) → 14:40:00.000000\n    @(parse_time(\"\"NOT TIME\"\", \"\"tt:mm\"\")) → ERROR\n    ```\n\n`percent(número)`: formatea number como un porcentaje.\n\n    ```\n    @(percent(0.54234)) → 54%\n    @(percent(1.2)) → 120%\n    @(percent(\"\"foo\"\")) → ERROR\n    ```\n\n`rand()`: devuelve un único número aleatorio entre [0.0-1.0).\n\n    ```\n    @(rand()) → 0.607552015674623913099594574305228888988494873046875@(rand()) → 0.484677570947340263796121462291921488940715789794921875\n    ```\n\n`rand_between()`: devuelve un único entero aleatorio dentro del intervalo inclusivo proporcionado.\n\n    ```\n    @(rand_between(1, 10)) → 10\n    @(rand_between(1, 10)) → 2\n    ```\n\n`read_chars(texto)`: convierte text en algo que puede ser leído por sistemas de IVR. ReadChars dividirá los números de manera que sean más fáciles de entender, lo que incluye la división en grupos de 3 o 4, si es apropiado.\n\n    ```\n    @(read_chars(\"\"1234\"\")) → 1 2 3 4\n    @(read_chars(\"\"abc\"\")) → a b c\n    @(read_chars(\"\"abcdef\"\")) → a b c , d e f\n    ```\n\n`regex_match(texto, padrão [, grupo])`: devuelve la primera coincidencia de la expresión regular pattern en text. Un tercer parámetro opcional, grupo, determina qué grupo coincidente será devuelto.\n\n    ```\n    @(regex_match(\"\"sda34dfddg67\"\", \"\"\\d+\"\")) → 34\n    @(regex_match(\"\"Bob Smith\"\", \"\"(\\w+) (\\w+)\"\", 1)) → Bob\n    @(regex_match(\"\"Bob Smith\"\", \"\"(\\w+) (\\w+)\"\", 2)) → Smith\n    @(regex_match(\"\"Bob Smith\"\", \"\"(\\w+) (\\w+)\"\", 5)) → ERROR\n    @(regex_match(\"\"abc\"\", \"\"[\\.\"\")) → ERROR\n    ```\n\n`remove_first_word(texto)`: elimina la primera palabra de text.\n\n    ```\n    @(remove_first_word(\"\"foo bar\"\")) → bar\n    @(remove_first_word(\"\"Hi there. I'm a flow!\"\")) → there. I'm a flow!\n    ```\n\n`repeat(texto, contagem)`: devuelve el `text` repetido `count` veces.\n\n    ```\n    @(repeat(\"\"*\"\", 8)) → ********\n    @(repeat(\"\"*\"\", \"\"foo\"\")) → ERROR\n    ```\n\n`replace(texto, agulha, substituição [, contagem])`: reemplaza hasta count ocurrencias de `needle` con `replacement` en `text`. Si `count` se omite o es menor que 0, se reemplazarán todas las ocurrencias.\n\n    ```\n    @(replace(\"\"foo bar foo\"\", \"\"foo\"\", \"\"zap\"\")) → zap bar zap\n    @(replace(\"\"foo bar foo\"\", \"\"foo\"\", \"\"zap\"\", 1)) → zap bar foo\n    @(replace(\"\"foo bar\"\", \"\"baz\"\", \"\"zap\"\")) → foo bar\n    ```\n\n`replace_time(datetime)`: devuelve un nuevo datetime con la parte de la hora reemplazada por time.\n\n    ```\n    @(replace_time(now(), \"\"10:30\"\")) → 2018-04-11T10:30:00.000000-05:00@(replace_time(\"\"2017-01-15\"\", \"\"10:30\"\")) → 2017-01-15T10:30:00.000000-05:00@(replace_time(\"\"foo\"\", \"\"10:30\"\")) → ERROR\n    ```\n\n`round(número [, lugares])`: redondea number al valor más cercano. Opcionalmente, puedes pasar el número de decimales para redondear a places. Si `places < 0`, redondeará la parte entera al `10^` más cercano (- lugares).\n\n    ```\n    @(round(12)) → 12\n    @(round(12.141)) → 12\n    @(round(12.6)) → 13\n    @(round(12.141, 2)) → 12.14\n    @(round(12.146, 2)) → 12.15\n    @(round(12.146, -1)) → 10\n    @(round(\"\"notnum\"\", 2)) → ERROR\n    ```\n\n`round_down(número [, lugares])`: redondea number hacia abajo al valor entero más cercano. Opcionalmente, puedes pasar el número de decimales para redondear a places.\n\n    ```\n    @(round_down(12)) → 12\n    @(round_down(12.141)) → 12\n    @(round_down(12.6)) → 12\n    @(round_down(12.141, 2)) → 12.14\n    @(round_down(12.146, 2)) → 12.14\n    @(round_down(\"\"foo\"\")) → ERROR\n    ```\n\n`round_up(número [, lugares])`: redondea number hacia arriba al valor entero más cercano. Opcionalmente, puedes pasar el número de decimales para redondear a places.\n\n    ```\n    @(round_up(12)) → 12\n    @(round_up(12.141)) → 13\n    @(round_up(12.6)) → 13\n    @(round_up(12.141, 2)) → 12.15\n    @(round_up(12.146, 2)) → 12.15\n    @(round_up(\"\"foo\"\")) → ERROR\n    ```\n\n`split(texto, [, delimitadores])`: divide `text` en una matriz de palabras separadas. Los valores vacíos se eliminan de la lista devuelta. Hay un parámetro opcional final, `delimiters`, que es una secuencia de caracteres utilizada para dividir el texto en palabras.\n\n    ```\n    @(split(\"\"a b c\"\")) → [a, b, c]\n    @(split(\"\"a\"\", \"\" \"\")) → [a]\n    @(split(\"\"abc..d\"\", \"\".\"\")) → [abc, d]\n    @(split(\"\"a.b.c.\"\", \"\".\"\")) → [a, b, c]\n    @(split(\"\"a|b,c  d\"\", \"\" .|,\"\")) → [a, b, c, d]\n    ```\n\n`text(valor)`: intenta convertir value en texto. Se devolverá un error si el valor no puede ser convertido.\n\n    ```\n    @(text(3 = 3)) → true\n    @(json(text(123.45))) → \"\"123.45\"\"\n    @(text(1 / 0)) → ERROR\n    ```\n\n`text_compare(texto1, texto2)`: devuelve el orden del diccionario entre `text1` y `text2`. El valor devuelto será -1 si `text1` viene antes de `text2`, 0 si son iguales, y 1 si `text1` viene después de `text2`.\n\n    ```\n    @(text_compare(\"\"abc\"\", \"\"abc\"\")) → 0\n    @(text_compare(\"\"abc\"\", \"\"def\"\")) → -1\n    @(text_compare(\"\"zzz\"\", \"\"aaa\"\")) → 1\n    ```\n\n`text_length(valor)`: devuelve la longitud (número de caracteres) de value cuando se convierte en texto.\n\n    @(text_length(\"\"abc\"\")) → 3\n    @(text_length(array(2, 3))) → 6\n\n`text_slice(texto, início [, fim])`: devuelve la parte de text entre start (inclusive) y end (exclusivo). Si end no está especificado, se incluirá todo el resto de text. Valores negativos para start o end comienzan desde el final de text.\n\n    ```\n    @(text_slice(\"\"hello\"\", 2)) → llo\n    @(text_slice(\"\"hello\"\", 1, 3)) → el\n    @(text_slice(\"\"hello😁\"\", -3, -1)) → lo\n    @(text_slice(\"\"hello\"\", 7)) →\n    ```\n\n`time(valor do tempo)`: intenta convertir value en una hora. Si es un texto, se analizará en una hora usando el formato de hora estándar. Se devolverá un error si el valor no puede ser convertido.\n\n    ```\n    @(time(\"\"10:30\"\")) → 10:30:00.000000\n    @(time(\"\"10:30:45 PM\"\")) → 22:30:45.000000\n    @(time(datetime(\"\"1979-07-18T10:30:45.123456Z\"\"))) → 10:30:45.123456\n    @(time(\"\"what?\"\")) → ERROR\n    ```\n\n`time_from_parts(hora, minuto, segundo)`: crea un tiempo de hour, minute y second.\n\n    ```\n    @(time_from_parts(14, 40, 15)) → 14:40:15.000000\n    @(time_from_parts(8, 10, 0)) → 08:10:00.000000\n    @(time_from_parts(25, 0, 0)) → ERROR\n\n`title(texto)`: pone en mayúscula cada palabra en text.\n\n    ```\n    @(title(\"\"foo\"\")) → Foo\n    @(title(\"\"ryan lewis\"\")) → Ryan Lewis\n    @(title(\"\"RYAN LEWIS\"\")) → Ryan Lewis\n    @(title(123)) → 123\n    ```\n\n`today()`: retorna la fecha actual en la zona horaria del entorno.\n\n    ```\n    @(today()) → 2018-04-11\n    ```\n\n`trim(texto, [, caracteres])`: elimina el espacio en blanco en los extremos de text. Hay un parámetro opcional, chars, que es una secuencia de caracteres a eliminar en lugar del espacio en blanco.\n\n    ```\n    @(trim(\"\" hello world    \"\")) → hello world\n    @(trim(\"\"+123157568\"\", \"\"+\"\")) → 123157568\n    ```\n\n`trim_left(texto, [, caracteres])`: elimina el espacio en blanco desde el inicio de text. Hay un parámetro opcional, chars, que es una secuencia de caracteres a eliminar en lugar del espacio en blanco.\n\n    ```\n    @(\"\"*\"\" & trim_left(\"\" hello world   \"\") & \"\"*\"\") → *hello world   *@(trim_left(\"\"+12345+\"\", \"\"+\"\")) → 12345+\n    ```\n\n`trim_right(texto, [, caracteres])`: elimina el espacio en blanco del final de text. Hay un parámetro opcional, chars, que es una secuencia de caracteres a eliminar en lugar del espacio en blanco.\n\n    ```\n    @(\"\"*\"\" & trim_right(\"\" hello world   \"\") & \"\"*\"\") → * hello world*@(trim_right(\"\"+12345+\"\", \"\"+\"\")) → +12345\n    ```\n\n`tz(data)`: devuelve el nombre de la zona horaria de date. Si no hay información de zona horaria presente en la fecha, se devolverá la zona horaria actual.\n\n    ```\n    @(tz(\"\"2017-01-15T02:15:18.123456Z\"\")) → UTC\n    @(tz(\"\"2017-01-15 02:15:18PM\"\")) → America/Guayaquil\n    @(tz(\"\"2017-01-15\"\")) → America/Guayaquil\n    @(tz(\"\"foo\"\")) → ERROR\n    ```\n\n`tz_offset(data)`: devuelve el desplazamiento de la zona horaria de date. El desplazamiento se devuelve en el formato [+/-]HH:MM. Si no hay información de zona horaria presente en la fecha, se devolverá la zona horaria actual.\n\n    ```\n    @(tz_offset(\"\"2017-01-15T02:15:18.123456Z\"\")) → +0000\n    @(tz_offset(\"\"2017-01-15 02:15:18PM\"\")) → -0500\n    @(tz_offset(\"\"2017-01-15\"\")) → -0500\n    @(tz_offset(\"\"foo\"\")) → ERROR\n    ```\n\n`upper(texto)`: convierte text a mayúsculas.\n\n    ```\n    @(upper(\"\"Asdf\"\")) → ASDF\n    @(upper(123)) → 123\n    ```\n\n`url_encode(texto)`: codifica text para su uso como parámetro de URL.\n\n    ```\n    @(url_encode(\"\"two & words\"\")) → two%20%26%20words\n    @(url_encode(10)) → 10\n    ```\n\n`url_parts(urn)`: analiza una URL en sus diferentes partes.\n\n    ```\n    @(urn_parts(\"\"tel:+593979012345\"\")) → \\{display: , path: +593979012345, scheme: tel\\}\n    @(urn_parts(\"\"twitterid:3263621177#bobby\"\")) → \\{display: bobby, path: 3263621177, scheme: twitterid\\}@(urn_parts(\"\"not a urn\"\")) → ERROR\n    ```\n\n`week_number(data)`: retorna el número de la semana (1-54) de date.\n\n    ```\n    @(week_number(\"\"2019-01-01\"\")) → 1\n    @(week_number(\"\"2019-07-23T16:56:59.000000Z\"\")) → 30\n    @(week_number(\"\"xx\"\")) → ERROR\n    ```\n\n`weekday(data)`: retorna el día de la semana para date. Se considera que la semana comienza el domingo; por lo tanto, un domingo retorna 0, un lunes retorna 1, etc.\n\n    ```\n    @(weekday(\"\"2017-01-15\"\")) → 0\n    @(weekday(\"\"foo\"\")) → ERROR\n    ```\n\n`word(texto, índice [, delimitadores])`: retorna la palabra index en text. Los índices comienzan en cero. Hay un parámetro opcional, delimiters, que es una secuencia de caracteres utilizada para dividir el texto en palabras.\n\n    ```\n    @(word(\"\"bee cat dog\"\", 0)) → bee\n    @(word(\"\"bee.cat,dog\"\", 0)) → bee\n    @(word(\"\"bee.cat,dog\"\", 1)) → cat\n    @(word(\"\"bee.cat,dog\"\", 2)) → dog\n    @(word(\"\"bee.cat,dog\"\", -1)) → dog\n    @(word(\"\"bee.cat,dog\"\", -2)) → cat\n    @(word(\"\"bee.*cat,dog\"\", 1, \"\".*=|\"\")) → cat,dog\n    @(word(\"\"O'Grady O'Flaggerty\"\", 1, \"\" \"\")) → O'Flaggerty\n    ```\n\n`word_count(texto, [, delimitadores])`: retorna el número de palabras en text. Hay un parámetro opcional, delimiters, que es una secuencia de caracteres utilizada para dividir el texto en palabras.\n\n    ```\n    @(word_count(\"\"foo bar\"\")) → 2\n    @(word_count(10)) → 1\n    @(word_count(\"\"\"\")) → 0\n    @(word_count(\"\"😀😃😄😁\"\")) → 4\n    @(word_count(\"\"bee.*cat,dog\"\", \"\".*=|\"\")) → 2\n    @(word_count(\"\"O'Grady O'Flaggerty\"\", \"\" \"\")) → 2\n    ```\n\n`word_slice(texto, início, fim [, delimitadores])`: extrae una sub-secuencia de palabras de text. Las palabras devueltas son aquellas que incluyen start, pero no incluyen end.\n\nLos índices comienzan en cero y un valor final negativo significa que se deben devolver todas las palabras después del inicio. Hay un parámetro opcional, delimiters, que es una secuencia de caracteres usada para dividir el texto en palabras.\n\n    ```\n    @(word_slice(\"\"bee cat dog\"\", 0, 1)) → bee\n    @(word_slice(\"\"bee cat dog\"\", 0, 2)) → bee cat\n    @(word_slice(\"\"bee cat dog\"\", 1, -1)) → cat dog\n    @(word_slice(\"\"bee cat dog\"\", 1)) → cat dog\n    @(word_slice(\"\"bee cat dog\"\", 2, 3)) → dog\n    @(word_slice(\"\"bee cat dog\"\", 3, 10)) →\n    @(word_slice(\"\"bee.*cat,dog\"\", 1, -1, \"\".*=|,\"\")) → cat dog\n    @(word_slice(\"\"O'Grady O'Flaggerty\"\", 1, 2, \"\" \"\")) → O'Flaggerty\"\n    ```"}