# Expresiones y operadores Una expresión sigue la forma `término operador término`, donde un término es una constante numérica, una constante de cadena, una variable, una llamada a función o una expresión entre paréntesis. `A + 5` y `a < b || c > d` son expresiones válidas. ## Constantes numéricas Empiezan con un dígito, un signo menos o un punto; el resto son dígitos y, opcionalmente, un punto decimal: `10`, `10.58`, `0.58`, `.69`, `-5`, `-.25`, `-0.58`. No hay notación científica en las expresiones (`1.5e3` da `Se esperaba un operador`; `val("1e3")` da 0). Sí se acepta en los bloques `$$ … $$` y en `from.json`. ## Constantes de cadena Van entre comillas dobles o simples, pueden contener cualquier carácter imprimible y ocupar varias líneas. Vea [Símbolos primitivos](/es/devkron/2.0/lenguaje/declarativo/simbolos-primitivos.md). ## Llamadas a funciones Nombre de la función y paréntesis con los argumentos separados por comas, existan o no: `F()`, `Funcion(10, 25.5, "hola")`. Los nombres de funciones **no** distinguen mayúsculas: `funcion1(10)` es la misma función que `FunCION(10)`. ## Operadores | Tipo | Operadores | |---|---| | Aritméticos | `+` suma, `-` resta, `*` multiplicación, `/` división | | Concatenación | `+` entre cadenas | | Comparación | `<`, `>`, `<=`, `>=`, `==` (igual), `!=` (distinto) | | Lógicos | `&&` (y), `\|\|` (o) | No existen `%` (use `mod()`), `!` como negación (use `not()`), `+=`/`-=` como sentencias ni el menos unario sobre una variable (`-n` da `Símbolo inválido`; escriba `0 - n` o `n * -1`). Las constantes negativas (`-5`, `5 - -3`) sí funcionan. `=` es asignación y `==` comparación; no los confunda. ## Prioridad De mayor a menor: 1. `*` y `/` 2. `+` y `-` 3. comparaciones (`<`, `>`, `<=`, `>=`, `==`, `!=`) 4. `&&` y `||` (misma prioridad, de izquierda a derecha) Use paréntesis para cambiar el orden. ```dkl do print(4 + 5 * 3) do print((4 + 5) * 3) do print(10 - 4 - 3) do print(2 * 3 + 4 * 5) do print(1 + 2 > 2) do print(1 < 2 && 3 < 4) do print(1 || 0 && 0) do print(1 || (0 && 0)) ``` ```text 19 27 3 26 1 1 0 1 ``` Como `&&` y `||` tienen la misma prioridad, `1 || 0 && 0` se evalúa como `(1 || 0) && 0` = 0. Ponga paréntesis siempre que mezcle ambos. `&&` y `||` evalúan **siempre** los dos operandos (no hay evaluación de cortocircuito): en `if 0 && f()`, `f()` se ejecuta. Para proteger un acceso use `if` anidados: `if not(isnull(o)) { if o.total > 0 { … } }`. Si una función falla dentro de una expresión, la expresión continúa con 0 en lugar de su valor y la asignación se hace (`total = f() + 1` deja `total` en 1); después, el error se atiende en el `exception` más cercano o termina el programa. Vea [Comportamientos no obvios](/es/devkron/2.0/lenguaje/rarezas.md). ## Aritmética decimal Todos los números son `decimal` de .NET: los centavos no se pierden y la escala (número de decimales) se conserva. ```dkl do print(0.1 + 0.2) do print(0.1 + 0.2 == 0.3) do print(1.10 * 2) do print(99.99 * 3) do print(10 / 4) do print(10 / 3) do print(1 / 3 * 3) do print(123456789 * 987654321) ``` ```text 0.3 1 2.20 299.97 2.5 3.3333333333333333333333333333 0.9999999999999999999999999999 121932631112635269 ``` Para mostrar importes, redondee con `round(x, 2)` o formatee con `format(x, "#,#.00")`. `round` usa redondeo bancario (`round(2.5, 0)` es 2, `round(3.5, 0)` es 4). Vea [Matemáticas](/es/devkron/2.0/lenguaje/funciones-incorporadas/matematicas.md). Dividir entre cero detiene el programa con `Attempted to divide by zero`; si necesita que devuelva 0, use `div(a, b)`. ## Cadenas `+` concatena dos cadenas. Para concatenar un número, conviértalo con `str()`: ```dkl nombre = "Ana" total = 3 do print("Hola " + nombre) do print("Total: " + str(total)) do print("abc" == "abc") do print("abc" == "ABC") do print("a" != "b") ``` ```text Hola Ana Total: 3 1 0 1 ``` Las cadenas se comparan con `==` y `!=` (distinguen mayúsculas). `<` y `>` entre cadenas dan `Operación de cadenas inválida`; para ordenar o comparar sin importar mayúsculas use las funciones de cadena de `functions.dkh`. ## Errores de tipos Un número y una cadena no se mezclan en ninguna operación, ni siquiera en `==`: ```dkl do print("inicio") do print("abc" + 5) ``` ```text inicio {1} Error en expresión: Tipos no coinciden [ejemplo.dkl][Ln= 8] ``` ```dkl do print("5" == 5) ``` ```text {1} Error en expresión: Tipos no coinciden [ejemplo.dkl][Ln= 7] ``` Si el error aparece en una línea que no tiene nada raro, revise las funciones que usa: una función sin `return` devuelve 0, y un 0 donde se esperaba una cadena produce este mismo error. Vea [Errores frecuentes](/es/devkron/2.0/lenguaje/errores-frecuentes.md). ## Objetos en expresiones Una variable de referencia usada en una expresión vale su **índice** en la tabla de objetos (un número). Por eso `@"k": f(x)` guarda un número si `f` devuelve un objeto, y en los bloques `$$` existe `&expr`. Vea [Registros](/es/devkron/2.0/lenguaje/imperativo/registros.md).