Operadores
## Objetivos de Aprendizaje
- Comprender operadores aritmeticos
- Dominar operadores de comparacion y logicos
- Aprender operadores bit a bit
- Usar notacion en cascada
- Trabajar con operadores de prueba de tipos
## Operadores Aritmeticos
```dart
void main() {
int a = 10;
int b = 3;
print(a + b); // 13 - suma
print(a - b); // 7 - resta
print(a * b); // 30 - multiplicacion
print(a / b); // 3.333... - division (double)
print(a ~/ b); // 3 - division entera
print(a % b); // 1 - modulo (resto)
}
```
### Incremento y Decremento
```dart
void main() {
int x = 5;
print(x++); // 5 (post-incremento, luego x se convierte en 6)
print(x); // 6
print(++x); // 7 (pre-incremento, x se convierte en 7 primero)
print(x--); // 7 (post-decremento)
print(x); // 6
}
```
## Operadores de Comparacion
```dart
void main() {
print(5 == 5); // true - igual
print(5 != 3); // true - no igual
print(5 > 3); // true - mayor que
print(5 < 3); // false - menor que
print(5 >= 5); // true - mayor o igual
print(5 <= 3); // false - menor o igual
}
```
## Operadores Logicos
```dart
void main() {
bool a = true;
bool b = false;
print(a && b); // false - AND
print(a || b); // true - OR
print(!a); // false - NOT
}
```
### Evaluacion de Cortocircuito
```dart
void main() {
// AND - se detiene si el primero es falso
false && print('nunca se ejecuta');
// OR - se detiene si el primero es verdadero
true || print('nunca se ejecuta');
}
```
## Operadores de Asignacion
```dart
void main() {
int x = 10;
x += 5; // x = 15
x -= 3; // x = 12
x *= 2; // x = 24
x ~/= 4; // x = 6
x %= 5; // x = 1
print(x);
}
```
## Operadores Bit a Bit
```dart
void main() {
int a = 5; // binario: 101
int b = 3; // binario: 011
print(a & b); // 1 - AND
print(a | b); // 7 - OR
print(a ^ b); // 6 - XOR
print(~a); // -6 - NOT
print(a << 1); // 10 - desplazamiento a la izquierda
print(a >> 1); // 2 - desplazamiento a la derecha
}
```
## Operadores de Prueba de Tipos
```dart
void main() {
dynamic value = 'Hello';
print(value is String); // true
print(value is int); // false
print(value is! String); // false
}
```
### Operador as (Conversion de Tipo)
```dart
void main() {
dynamic value = 'Hello';
// Usando 'as' para promocion de tipo
String str = value as String;
print(str.length); // 5
// Precaucion: lanzara excepcion si el tipo no es correcto
// int num = value as int; // Error en tiempo de ejecucion
}
```
## Operadores Nulos
```dart
void main() {
String? name;
print(name ?? 'Unknown'); // Unknown (si es null, usa 'Unknown')
print(name?.length); // null (navegacion segura)
// print(name!.length); // Error: null (desenvoltura forzada)
}
```
## Notacion en Cascada
### Problema Sin Cascada
```dart
void main() {
var paint = Paint();
paint.color = Colors.black;
paint.strokeWidth = 5.0;
paint.style = PaintingStyle.stroke;
}
```
### Con Cascada
```dart
void main() {
var paint = Paint()
..color = Colors.black
..strokeWidth = 5.0
..style = PaintingStyle.stroke;
}
```
### Cascada Nula
```dart
void main() {
Paint? paint;
// Solo hace cascada si no es null
paint
?..color = Colors.black
..strokeWidth = 5.0;
}
```
## Operador de Propagacion
### Propagacion en Listas
```dart
void main() {
var list1 = [1, 2, 3];
var list2 = [0, ...list1, 4]; // [0, 1, 2, 3, 4]
// Propagacion nula
List? nullableList;
var list3 = [0, ...?nullableList, 4]; // [0, 4]
}
```
### Propagacion en Mapas
```dart
void main() {
var map1 = {'a': 1, 'b': 2};
var map2 = {'c': 3, ...map1}; // {'c': 3, 'a': 1, 'b': 2}
}
```
## Expresion Condicional
### Operador Ternario
```dart
void main() {
int age = 20;
String status = age >= 18 ? 'Adult' : 'Minor';
print(status); // Adult
}
```
### Operador If-null
```dart
void main() {
String? name;
String displayName = name ?? 'Guest';
print(displayName); // Guest
}
```
## Otros Operadores
### Acceso a Miembros
```dart
void main() {
var list = [1, 2, 3];
print(list.length); // 3
print(list.first); // 1
print(list.isEmpty); // false
}
```
### Llamada de Funcion
```dart
void greet(String name) => print('Hello, $name!');
void main() {
greet('Alice'); // Hello, Alice!
}
```
### Operador Coma
```dart
void main() {
// La coma separa expresiones, devuelve el ultimo valor
var result = (print('one'), print('two'), print('three'));
// Imprime: one, two, three
}
```
## Precedencia de Operadores
| Precedencia | Operadores |
|------------|-----------|
| Mas alta | `()` `[]` `.` `?.` |
| | `-` `!` `~` `++` `--` |
| | `*` `/` `%` `~/` |
| | `+` `-` |
| | `<<` `>>` `>>>` |
| | `&` |
| | `^` |
| | `\|` |
| | `>=` `>` `<=` `<` `as` `is` `is!` |
| | `??` |
| | `&&` |
| | `\|\|` |
| Mas baja | `? :` `=` `+=` `-=` etc. |
## Resumen
- Aritmeticos: `+`, `-`, `*`, `/`, `~/`, `%`
- Comparacion: `==`, `!=`, `>`, `<`, `>=`, `<=`
- Logicos: `&&`, `||`, `!`
- Cascada `..` encadena llamadas de metodos en el mismo objeto
- Nulos: `?.`, `??`, `?..`
- Propagacion: `...`, `...?` para colecciones
- Ternario: `condition ? expr1 : expr2`
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →