En Dart, los operadores son símbolos que se utilizan para realizar operaciones en variables y valores. Los operadores en Dart se pueden clasificar en varias categorías, como operadores aritméticos, operadores de asignación, operadores de comparación, operadores lógicos, operadores de incremento/decremento y operadores de tipo. En esta sección, exploraremos cada uno de estos operadores con ejemplos prácticos.
Operadores Aritméticos
Los operadores aritméticos se utilizan para realizar operaciones matemáticas comunes.
| Operador | Descripción | Ejemplo |
|---|---|---|
+ |
Suma | a + b |
- |
Resta | a - b |
* |
Multiplicación | a * b |
/ |
División | a / b |
% |
Módulo (resto) | a % b |
~/ |
División entera | a ~/ b |
Ejemplo Práctico
void main() {
int a = 10;
int b = 3;
print('Suma: ${a + b}'); // Suma: 13
print('Resta: ${a - b}'); // Resta: 7
print('Multiplicación: ${a * b}'); // Multiplicación: 30
print('División: ${a / b}'); // División: 3.3333333333333335
print('Módulo: ${a % b}'); // Módulo: 1
print('División entera: ${a ~/ b}'); // División entera: 3
}Operadores de Asignación
Los operadores de asignación se utilizan para asignar valores a las variables.
| Operador | Descripción | Ejemplo |
|---|---|---|
= |
Asignación simple | a = b |
+= |
Asignación con suma | a += b |
-= |
Asignación con resta | a -= b |
*= |
Asignación con multiplicación | a *= b |
/= |
Asignación con división | a /= b |
%= |
Asignación con módulo | a %= b |
Ejemplo Práctico
void main() {
int a = 10;
int b = 3;
a += b; // a = a + b
print('a += b: $a'); // a += b: 13
a -= b; // a = a - b
print('a -= b: $a'); // a -= b: 10
a *= b; // a = a * b
print('a *= b: $a'); // a *= b: 30
a ~/= b; // a = a ~/ b
print('a ~/= b: $a'); // a ~/= b: 10
a %= b; // a = a % b
print('a %= b: $a'); // a %= b: 1
}Operadores de Comparación
Los operadores de comparación se utilizan para comparar dos valores y devuelven un valor booleano (true o false).
| Operador | Descripción | Ejemplo |
|---|---|---|
== |
Igual a | a == b |
!= |
No igual a | a != b |
> |
Mayor que | a > b |
< |
Menor que | a < b |
>= |
Mayor o igual que | a >= b |
<= |
Menor o igual que | a <= b |
Ejemplo Práctico
void main() {
int a = 10;
int b = 3;
print('a == b: ${a == b}'); // a == b: false
print('a != b: ${a != b}'); // a != b: true
print('a > b: ${a > b}'); // a > b: true
print('a < b: ${a < b}'); // a < b: false
print('a >= b: ${a >= b}'); // a >= b: true
print('a <= b: ${a <= b}'); // a <= b: false
}Operadores Lógicos
Los operadores lógicos se utilizan para combinar expresiones booleanas.
| Operador | Descripción | Ejemplo |
|---|---|---|
&& |
Y lógico (AND) | a && b |
| ` | ` | |
! |
No lógico (NOT) | !a |
Ejemplo Práctico
void main() {
bool a = true;
bool b = false;
print('a && b: ${a && b}'); // a && b: false
print('a || b: ${a || b}'); // a || b: true
print('!a: ${!a}'); // !a: false
}Operadores de Incremento/Decremento
Los operadores de incremento y decremento se utilizan para aumentar o disminuir el valor de una variable en uno.
| Operador | Descripción | Ejemplo |
|---|---|---|
++ |
Incremento | a++ o ++a |
-- |
Decremento | a-- o --a |
Ejemplo Práctico
void main() {
int a = 10;
print('a++: ${a++}'); // a++: 10 (post-incremento)
print('a: $a'); // a: 11
print('++a: ${++a}'); // ++a: 12 (pre-incremento)
print('a--: ${a--}'); // a--: 12 (post-decremento)
print('a: $a'); // a: 11
print('--a: ${--a}'); // --a: 10 (pre-decremento)
}Operadores de Tipo
Los operadores de tipo se utilizan para verificar el tipo de un objeto o para convertir un objeto a otro tipo.
| Operador | Descripción | Ejemplo |
|---|---|---|
is |
Verifica el tipo | a is int |
is! |
Verifica que no es el tipo | a is! int |
as |
Conversión de tipo | a as int |
Ejemplo Práctico
void main() {
var a = 10;
print('a is int: ${a is int}'); // a is int: true
print('a is! String: ${a is! String}'); // a is! String: true
dynamic b = 'Hello';
String c = b as String;
print('c: $c'); // c: Hello
}Ejercicios Prácticos
Ejercicio 1
Escribe un programa en Dart que realice las siguientes operaciones con dos números enteros x y y:
- Suma
- Resta
- Multiplicación
- División
- Módulo
Solución:
void main() {
int x = 15;
int y = 4;
print('Suma: ${x + y}'); // Suma: 19
print('Resta: ${x - y}'); // Resta: 11
print('Multiplicación: ${x * y}'); // Multiplicación: 60
print('División: ${x / y}'); // División: 3.75
print('Módulo: ${x % y}'); // Módulo: 3
}Ejercicio 2
Escribe un programa en Dart que verifique si un número n es mayor que 10 y menor que 20.
Solución:
void main() {
int n = 15;
if (n > 10 && n < 20) {
print('$n es mayor que 10 y menor que 20'); // 15 es mayor que 10 y menor que 20
} else {
print('$n no cumple la condición');
}
}Ejercicio 3
Escribe un programa en Dart que convierta un valor dinámico a un tipo específico y verifique su tipo.
Solución:
void main() {
dynamic value = 42;
if (value is int) {
print('El valor es un entero'); // El valor es un entero
} else {
print('El valor no es un entero');
}
String strValue = value.toString();
print('strValue: $strValue'); // strValue: 42
}Conclusión
En esta sección, hemos cubierto los operadores básicos en Dart, incluyendo operadores aritméticos, de asignación, de comparación, lógicos, de incremento/decremento y de tipo. Estos operadores son fundamentales para realizar operaciones en tus programas y son esenciales para cualquier programador que trabaje con Dart. Asegúrate de practicar con los ejemplos y ejercicios proporcionados para reforzar tu comprensión de estos conceptos. En la próxima sección, exploraremos las sentencias de control de flujo en Dart.
Curso de Programación en Dart
Módulo 1: Introducción a Dart
- Introducción a Dart
- Configuración del Entorno de Desarrollo
- Tu Primer Programa en Dart
- Sintaxis y Estructura Básica