Operadores

Los operadores son símbolos especiales que nos brindan los lenguajes para interactuar con uno o dos operando y devolver un resultado, en base al tipo de operador que usemos, veremos si funciona con un solo operando o son ambos requeridos.
Como venimos haciendo hasta ahora presentaremos una lista con los distintos tipos de operadores y luego entraremos en los detalles de cada uno.

Operadores:

• Assignment Operators
• Arithmetic Operators
• Unary Operators
• Equality and Relational Operators
• Conditional Operators
• Type Comparison Operator
  

Assignment Operators
Este es uno de los operadores más comunes que podremos encontrar, básicamente se usa para asignación entre las variables y lo datos que queremos almacenar en ella. Este operador está representado con el símbolo "=".

var example1 = 2;
var example2 = "Test";

En este caso vemos dos asignaciones en el ejemplo 1 guardamos el valor 2 en la variable example1, y en el segundo caso guardamos la cadena de caracteres example2 (En realidad hablamos que guardamos las referencias ya que son objetos, pero no me parece importante para este tema igual quería dejarlo aclarado).

Arithmetic Operators
Los operadores aritméticos son utilizados para los cálculos entre las variables.
+ (additive operator)
- (subtraction operator)
* (multiplication operator)
/ (division operator)
mod (remainder operator)
Estos operadores cubren las 4 operaciones básicas y la operación del resto por medio del modificador mod

Ejemplo

var example = 1 + 2;
println(example);      // example vale 3

example = example - 1;
println(example);      // example vale 2

example = example * 2;
println(example);      // example vale 4

example = example / 2;
println(example);      // example vale 2

example = example + 8;
println(example);      // example vale 10

example = example mod 7;
println(example);      // example vale 3

Unary Operators
Los operadores unarios son aquellos que se puede usar teniendo un solo operando.

example = 0;
example += 1;
println(example); // result vale 1

example -= 1;
println(example); // result vale 0

example = 2;
example *= 5;
println(example); // result vale 10

example /= 2;
println(example); // result vale 5

Equality and Relational Operators
Aquí están los operadores que usamos para las comparaciones y relaciones del tipo, es más grande que, es distinto que, etc.

== // Igual que
!= // Distinto que
> // Mayor que
>= // Mayor o igual que
< // Menor que
<= // Menor o igual que

def num1 = 1;
def num2 = 2; 
println(num1 == num2); // False
println(num1 != num2); // True
println(num1 > num2);  // False
println(num1 >= num2); // False
println(num1 < num2);  // True
println(num1 <= num2); // True

Conditional Operators
En esta sección contamos con dos operadores para las condiciones estos son el operador AND y el operador OR, estos tiene un comportamiento denominado "short-circuiting" lo cual quiere decir que si en una expresión que utilizamos el operador AND y el primer termino es false ya se deja de evaluar el resto, y si usamos un operador OR si el primero termino es verdadero tampoco se evalúa el resto.

def username = "foo";
def password = "bar";

if ((username == "foo") and (password == "bar")) {
println("Test 1: username AND password are correct"); // Test 1: username AND password are correct
}

if ((username == "") and (password == "bar")) {
println("Test 2: username AND password is correct"); // No se ejecuta este código
}

if ((username == "foo") or (password == "bar")) {
println("Test 3: username OR password is correct"); // Test 3: username OR password is correct
}

if ((username == "") or (password == "bar")) {
println("Test 4: username OR password is correct"); // Test 4: username OR password is correct
}

Type Comparison Operator
Este operador es usado para comprobar si un object es instancia de una clase o una subclase en particular. El operador instanceof devuelve true si el objeto es una instancia de la clase especificada. Devuelve false si el objeto no es una instancia de la clase especificada, o si objeto es null.

def str1="Hello";
println(str1 instanceof String); // True

def num = 1031;
println(num instanceof Integer); // False

Bueno esto fue una rápida revisión sobre los operadores en JavaFX, ahora seguiremos viendo secuencias y luego binding y triggers entre funciones para poder irnos introduciendo en la parte grafica de este poderoso lenguaje de scripting.

Saludos hasta la próxima