Operadores

Los operadores son caracteres especiales o palabras clave que representan una acción matemática o lógica a realizar en un programa. Por ejemplo, el operador matemático + se utiliza para sumar dos números, mientras que el operador lógico and se utiliza para verificar si dos expresiones son verdaderas. Los operadores se utilizan en combinación con valores o variables para crear expresiones que pueden ser evaluadas en un resultado.

Cuando una expresión tiene varios operadores, el orden en que se calculan está en Prioridad de los operadores.

Operadores aritméticos

Los operadores aritméticos permiten realizar operaciones matemáticas básicas como suma, resta, multiplicación y división. Los operadores aritméticos en JARU son:

Operador	Descripción	Ejemplo
`+`	Sumar dos números	`5 + 2 = 7`
`-`	Restar dos números	`5 - 2 = 3`
`*`	Multiplicar dos números	`5 * 2 = 10`
`/`	Dividir dos números; el resultado es siempre decimal, también entre enteros	`5 / 2 = 2.5`
`div`	División entera: se queda con la parte entera, truncando hacia cero	`5 div 2 = 2`, `-5 div 2 = -2`
`%`	Permite obtener el resto de una división	`5 % 2 = 1`
`mod`	Lo mismo que `%`	`5 mod 2 = 1`
`++`	Incrementar un número en uno	`x++`
`--`	Decrementar un número en uno	`x--`

Es posible utilizar estos operadores para crear expresiones matemáticas más complejas, y pueden ser utilizados tanto con variables como con valores constantes.

var num1 = 5
var num2 = 2

// Suma
println(num1 + num2) // 7

// Resta
println(num1 - num2) // 3

// Multiplicación
println(num1 * num2) // 10

// División
println(num1 / num2) // 2.5

// División entera
println(num1 div num2) // 2

// Módulo
println(num1 % num2) // 1

// Incremento
num1++
println(num1) // 6

// Decremento
num2--
println(num2) // 1

El resto lleva el signo del primer número (-7 % 3 da -1), y también vale con decimales: 7.5 % 2 da 1.5.
Dividir entre cero con / o div para el programa con el error «Division by zero»; con % o mod, con «Modulo by zero.». Puedes capturarlo con try: ver Errores y excepciones.
+ también une dos cadenas, "Hola, " + nombre, pero no una cadena y un número: ver Unir cadenas.
x++ da el valor que tenía x antes de sumar uno, y ++x, el de después: si a vale 5, a++ + 10 da 15 y ++a + 10 da 16; en los dos casos a acaba valiendo 6. -- funciona igual.
Valen con una variable, una propiedad o un elemento de una lista o de un mapa: vidas++, jugador.vidas--, lista[0]++, ++puntos["ana"]. Con otra cosa, como 5++, el compilador da un error.

Operadores de asignación

Los operadores de asignación son aquellos que se utilizan para asignar un valor a una variable. En JARU, los operadores de asignación son:

Operador	Descripción
`=`	Asigna el valor a la derecha de la expresión a la variable a la izquierda
`+=`	Suma el valor a la derecha de la expresión al valor actual de la variable a la izquierda
`-=`	Resta el valor a la derecha de la expresión al valor actual de la variable a la izquierda
`*=`	Multiplica el valor actual de la variable a la izquierda por el valor a la derecha de la expresión
`/=`	Divide el valor actual de la variable a la izquierda por el valor a la derecha de la expresión
`%=`	Calcula el resto de la división del valor actual de la variable a la izquierda por el valor a la derecha de la expresión y lo asigna a la variable a la izquierda

var num1 = 10
num1 += 2  // num1 = 12
num1 -= 5  // num1 = 7
num1 *= 3  // num1 = 21
num1 /= 2  // num1 = 10.5
num1 %= 3  // num1 = 1.5

Las operaciones bit a bit no tienen forma corta: escribe banderas = banderas | 4.

Operadores de comparación

Los operadores de comparación en JARU son similares a los de otros lenguajes de programación. Estos operadores comparan dos valores y devuelven un valor booleano (verdadero o falso).

Operador	Descripción
`==`	Comprueba si dos valores son iguales
`!=`	Comprueba si dos valores son diferentes
`>`	Comprueba si el valor a la izquierda es mayor que el valor a la derecha
`<`	Comprueba si el valor a la izquierda es menor que el valor a la derecha
`>=`	Comprueba si el valor a la izquierda es mayor o igual que el valor a la derecha
`<=`	Comprueba si el valor a la izquierda es menor o igual que el valor a la derecha

var num1 = 5
var num2 = 10

// usando el operador ==
if (num1 == num2) then 
  println("num1 es igual a num2")
else 
  println("num1 no es igual a num2")
end

// usando el operador !=
if (num1 != num2) then 
  println("num1 es diferente a num2")
else 
  println("num1 es igual a num2")
end

// usando el operador >
if (num1 > num2) then 
  println("num1 es mayor que num2")
else 
  println("num1 no es mayor que num2")
end

// usando el operador <
if (num1 < num2) then
  println("num1 es menor que num2")
else 
  println("num1 no es menor que num2")
end

== y != comparan los números por su valor (1 == 1.0 da true) y las cadenas por su contenido.
Dos listas, mapas u objetos solo son iguales si son el mismo: [1, 2] == [1, 2] da false.
<, >, <= y >= comparan números. Con cadenas no miran el orden alfabético: "a" < "b" da false (ver Comparar cadenas).

Operadores lógicos

Los operadores lógicos sirven para combinar, comparar y evaluar expresiones lógicas y se utilizan para tomar decisiones basadas en el valor de las expresiones booleanas (que solo pueden tener dos valores posibles: verdadero o falso).

Operador	Descripción
`and`	Devuelve verdadero si ambas expresiones son verdaderas
`or`	Devuelve verdadero si al menos una de las expresiones es verdadera
`not`	Invierte el valor lógico de la expresión
`!`	Lo mismo que `not`
`^`	Da verdadero si una de las expresiones es verdadera, pero no las dos

var x = (5 > 3) and (2 < 4)  // x es verdadero 
var y = (5 > 3) or (2 > 4)   // y es verdadero 
var z = not(5 > 3)           // z es falso
var v = !(5 > 3)             // v es falso
var w = (5 > 3) ^ (2 > 4)    // w es verdadero

var x = 5
var y = 8
var z = 10

println(x < y and y < z) // true
println(x > y or y < z)  // true
println(not(x > y))      // true

En el primer caso la comparación x < y es verdadera y y < z también es verdadera, entonces la expresión x < y and y < z es verdadera.

En el segundo caso la comparación x > y es falsa pero y < z es verdadera, entonces la expresión x > y or y < z es verdadera.

En el tercer caso la comparación x > y es falsa, entonces not(x > y) es verdadera.

and y or dejan de calcular en cuanto saben el resultado. En i < lista.size() and lista[i] > 0, si i se sale de la lista, lista[i] no llega a leerse. Y dan siempre true o false: 0 or 5 da true, no 5.

and y or tienen la misma prioridad

Se calculan de izquierda a derecha: true or false and false da false, porque se calcula como (true or false) and false. En otros lenguajes, and va antes que or. Usa paréntesis para dejar claro el orden que quieres: true or (false and false) da true.

not y ! se calculan antes que las comparaciones: not 1 == 2 es (not 1) == 2, y da false. Para negar una comparación, escríbela entre paréntesis, como en not(x > y). El operador ^ también se calcula antes que las comparaciones: escribe cada comparación entre paréntesis, como en (5 > 3) ^ (2 > 4). El orden de todos los operadores está en Prioridad de los operadores.

Operadores bit a bit

Trabajan con los bits de los números enteros: sirven para leer los registros de un sensor, para las máscaras de los pines o para separar las partes de un color 0xRRGGBB.

Operador	Qué hace	Ejemplo
`&`	Y: un 1 donde los dos tienen un 1	`0x0F & 0x3C` da `12` (`0x0C`)
`\|`	O: un 1 donde alguno tiene un 1	`0x0F \| 0x30` da `63` (`0x3F`)
`^`	O exclusivo: un 1 donde solo uno de los dos tiene un 1	`0x0F ^ 0x3C` da `51` (`0x33`)
`~`	Invierte todos los bits	`~5` da `-6`
`<<`	Desplaza los bits a la izquierda	`1 << 4` da `16`
`>>`	Desplaza los bits a la derecha	`256 >> 4` da `16`

var color = 0xFF8800                  // naranja, en 0xRRGGBB
var rojo = (color >> 16) & 0xFF
var verde = (color >> 8) & 0xFF
var azul = color & 0xFF
println(rojo, " ", verde, " ", azul)   // 255 136 0

Son para enteros. Con decimales, &, | y ^ quitan antes la parte decimal (5.7 & 3 da 1), << y >> paran el programa («Both operands for the '<<' operator must be integers.»), y ~ da -1 sin avisar.
Los enteros son de 32 bits: 1 << 31 da -2147483648. Desplaza de 0 a 31 posiciones.
>> mete ceros por la izquierda, también en los negativos: -8 >> 1 da 2147483644, no -4. Para dividir un negativo entre 2, usa div.
Con dos booleanos, &, | y ^ dan un booleano, pero calculan siempre los dos lados: no se paran como and y or.
^ no es la potencia: 2 ^ 3 da 1. Para las potencias está Math.pow(2, 3), en el módulo Math.
Se calculan antes que las comparaciones, y &, | y ^ tienen la misma prioridad entre ellos: 4 | 1 & 2 da 0, porque es (4 | 1) & 2. Usa paréntesis.

Todos los problemas conocidos de JARU, juntos, están en Problemas conocidos.

Operador condicional (ternario)

El operador condicional ?, también conocido como operador ternario, es un operador condicional que se utiliza en muchos lenguajes de programación, incluyendo JARU. El operador ternario permite tomar una decisión basada en una expresión booleana y ejecutar diferentes acciones en función del resultado de la evaluación.

La sintaxis general del operador ternario es la siguiente:

condición ? expresión_verdadera : expresión_falsa

La condición es una expresión booleana que se evalúa como verdadera o falsa. Si la condición es verdadera, se evalúa la expresión_verdadera; si no, se evalúa la expresión_falsa.

var edad = 18
var mensaje = (edad >= 18) ? "Eres mayor de edad" : "Eres menor de edad"
println(mensaje)  // Eres mayor de edad

En este ejemplo, la condición es edad >= 18, que se evalúa como verdadera porque edad es igual a 18. Por lo tanto, la expresión_verdadera es "Eres mayor de edad", que se asigna a la variable mensaje.

Uso moderado

El operador ternario puede hacer el código más breve, pero también más difícil de entender si se abusa de él. Úsalo para elegir entre dos valores sencillos.

Operadores ternarios anidados

Es posible anidar operadores ternarios para tomar decisiones complejas basadas en múltiples condiciones:

var edad = 18
var mensaje = (edad >= 18) ? "Eres mayor de edad" : (edad >= 13) ? "Eres un adolescente" : "Eres un niño"
println(mensaje)

En este ejemplo, se evalúan dos condiciones anidadas para determinar el mensaje que se debe mostrar en función de la edad de una persona. Si la edad es mayor o igual a 18, el mensaje será "Eres mayor de edad". Si no, se evalúa la siguiente condición: si la edad es mayor o igual a 13, el mensaje será "Eres un adolescente". Si la edad no cumple ninguna de estas condiciones, el mensaje será "Eres un niño".

Operadores aritméticos​

Operadores de asignación​

Operadores de comparación​

Operadores lógicos​

Operadores bit a bit​

Operador condicional (ternario)​

Operadores ternarios anidados​