Tabla de Contenido
Operadores
Los operadores en Dart son como la mayoría que usan los demás lenguajes, a continuación, una tabla con operadores que Dart es compatible. La tabla muestra el orden de importancia de arriba a abajo de los operadores.
Al utilizar operadores se terminan creando expresiones, como por ejemplo:
i++
i + j
i - j
i * j
i / j
i % j
i == j
i >= j
i <= j
k ? i : j
Precedencia de operadores
En la tabla de la imagen, hay ciertos operadores con mayor precedencia que otros, por ejemplo el * tiene prioridad sobre ==.
// Los paréntesis mejoran la lectura de las expresiones
if ((n * i == 10) || (d * i == 20))
// es igual al anterior pero sin paréntesis
if (n * i == 10 || d * i == 20)
Operadores aritméticos
Dart tiene compatibilidad con los operadores aritméticos más conocidos:
// + (sumar)
// - (restar)
// * (multiplicar)
// / (dividir)
// % (módulo)
int sum = 3 + 4;
assert(sum == 7);
int subs = 3 - 4;
assert(subs == -1);
int mult = 3 * 4;
assert(mult == 12);
double div = 10 / 4;
assert(div == 2.5);
var mod = 10 % 4;
assert(mod == 2);
Dart también utiliza los operadores para incrementar o decrementar en 1.int i = 0;
int j = 0;
i++;
++j;
i--;
--j;
Igualdad y operadores relacionales
Veremos los operadores de igualdad y relacionales más usados.
// == (igual)
// != (diferente)
// > (mayor que)
// < (menor que)
// >= (mayor igual que)
// <= (menor igual que)
assert(5 == 5);
assert(5 != 4);
assert(5 > 2);
assert(3 < 5);
assert(5 >= 5);
assert(4 <= 5);
Hay casos en los que se puede necesitar validar si dos objetos son exactamente iguales, para estos casos Dart recomienda que usemos la función identical().
bool valid = identical(objectA, objectB);
Operadores de comprobación de tipos
Los operadores as, is e is! son útiles para comprobar tipos en tiempo de ejecución.
// el operador as se utiliza para asignar
// a un objeto a un tipo determinado solo si son del mismo tipo
(dog as Animal).color = 'black';
// el operador is se utiliza para validar si un objeto
// es de determinado tipo
if (teacher is Person) {
teacher.name = 'Keanu';
}
Operadores de asignación
Existen varios operadores y estos son los que usa Dart:
// Operadores
// = *= %= >>>= ^=
// += /= <<= &= |=
// -= ~/= >>=
var a = 'value'; // asignación
var b;
var c = b ??= 'value'; // solo se mostrará 'value' si b es null.
var e = 2;
var f = 1;
var d = e += f; // utilizando el operador +=, es como decir e = e + f;
Operadores lógicos
Los operadores lógicos sirven para validar expresiones.
// !expression — Validador de diferente
// || — Operador para validaciones OR
// && — Operador para validaciones AND
if ((a == b || a == c) && !valid) {
// sentencias
}
Operadores bitwise y shift
Puedes manipular los bits individuales de los números en Dart. Por lo general, se utilizan estos operadores bitwise y shift con números enteros.
// Operador AND bitwise (&)
int num1 = 5;
int num2 = 3;
int resAnd = num1 & num2;
// Operador OR bitwise (|)
int resOr = num1 | num2;
// Operador XOR bitwise (^)
int resXor = num1 ^ num2;
// Operador NOT bitwise (~)
int resNot = ~num1;
// Operador Shift (<<)
int desLeft = num1 << 1;
// Operador Shift (>>>)
int desNotSign = num1 >> 1;
Expresiones condicionales
Dart nos brinda dos operadores para reemplazar el if-else, uno de ellos es el operador ternario (condition ? expr1 : expr2 ).
// condition ? expr1 : expr2
// si condition es diferente de nulo, retorna expr1 sino expr2.
bool isDark = true;
var color = isDark ? 'black' : 'white';
// expr1 ?? expr2
// si expr2 es diferente de nulo, devuelve expr1 sino expr2.
int? defaultValue = null;
int value = 10;
int resultado = defaultValue ?? value;
Notación en cascada (Cascade notation)
La Notación en cascada en Dart es una característica que permite realizar una serie de operaciones en el mismo objeto sin tener que repetir su nombre. Utiliza el operador .. para encadenar llamadas a métodos o propiedades en un solo objeto.
En lugar de escribir varias líneas de código para acceder al mismo objeto y realizar varias operaciones, la Notación en cascada permite realizar esas operaciones de manera más concisa y legible.
class Person {
String name = "";
int age = 0;
void printAge() {
print('$name tiene $age años de edad.');
}
}
void main() {
// Sin notación de cascada
Person person1 = Person();
person1.name = 'Juan';
person1.age = 30;
person1.printAge();
// Con notación de cascada
Person person2 = Person()
..name = 'Pepito'
..age = 33
..printAge();
}
Para más información de operadores, podemos revisar la documentación de clases .
Conclusión
Vimos varios de los operadores, tal vez los más usados comúnmente del lenguaje Dart, hay muchos que son de utilidad para ciertas ocasiones.
¡Gracias por leer!
