Operadores aritméticos binarios básicos
Se usan para operaciones entre dos valores numéricos, existen 7 tipos en total, incluyendo las cuatro operaciones básicas, división entera, resto y el operador unario negativo.
| Operador | Descripción de su función |
|---|---|
+ | Suma |
- | Resta |
-expresión | Menos unario (invierte el signo del número) |
* | Multiplicación |
/ | División normal, el resultado siempre es tipo double (punto flotante) |
~/ | División entera, elimina la parte decimal y devuelve int |
% | Módulo (obtiene el resto de la división entera) |
La división tiene una particularidad respecto a otros lenguajes: el operador / siempre devuelve un número decimal. Si necesitas un entero debes usar ~/, un punto fundamental para lectores con experiencia previa en programación.
Ejemplo de código:
void main() {
// Comprobación de suma, resta, multiplicación, división, división entera y módulo
print(2 + 3 == 5);
print(2 - 3 == -1);
print(2 * 3 == 6);
print(5 / 2 == 2.5); // División normal devuelve double decimal
print(5 ~/ 2 == 2); // División entera solo conserva la parte entera int
print(5 % 2 == 1); // % obtiene únicamente el resto de la división entera
// Ejemplo de concatenación de cadena con cociente y resto
print('5/2 = ${5 ~/ 2} r ${5 % 2}' == '5/2 = 2 r 1');
}Lenguaje del código: Dart (dart)Imagen del resultado de ejecución
Operadores incremento / decremento
Dart admite dos versiones prefija y postfija para el incremento ++ y el decremento --. La diferencia clave es: si modificamos primero la variable o tomamos primero su valor original.
| Operador | Lógica de ejecución | Valor devuelto por la expresión |
|---|---|---|
++var | Sumar 1 a la variable primero, luego usar el nuevo valor en la operación | Nuevo valor tras el incremento |
var++ | Usar primero el valor original de la variable para la operación, luego sumar 1 a la variable al finalizar | Valor original antes del incremento |
--var | Restar 1 a la variable primero, luego usar el nuevo valor en la operación | Nuevo valor tras el decremento |
var-- | Usar primero el valor original de la variable para la operación, luego restar 1 a la variable al finalizar | Valor original antes del decremento |
void main() {
int a;
int b;
// 1. Incremento prefijo ++a: modificar primero, luego asignar
a = 0;
b = ++a;
print(a == b); // a=1, b=1 → true
// 2. Incremento postfijo a++: asignar valor original primero, luego modificar
a = 0;
b = a++;
print(a != b); // a=1, b=0 → true
// 3. Decremento prefijo --a: modificar primero, luego asignar
a = 0;
b = --a;
print(a == b); // a=-1, b=-1 → true
// 4. Decremento postfijo a--: asignar valor original primero, luego modificar
a = 0;
b = a--;
print(a != b); // a=-1, b=0 → true
}
Lenguaje del código: PHP (php)Todos los resultados de impresión del ejemplo son true.
Importante: colocar ++ o — en posición prefija o postfija cambia el comportamiento en expresiones complejas.
Si se usan solos, ejemplo:
int a = 1;
++a;
int b = 1;
b++;
print(a);
print(b);Lenguaje del código: PHP (php)El código anterior imprime 2 en ambos casos.
D:\dartdemo\firstdart>dart run
Building package executable...
Built firstdart:firstdart.
2
2
Lenguaje del código: CSS (css)Lo mismo ocurre con –, la variable siempre terminará aumentada o disminuida en uno.
Pero si ++ o — forman parte de una expresión matemática, ejemplo:
void main() {
int a = 5;
// Postfijo: usar primero el valor 5 para el cálculo, luego a pasa a 6
int res1 = a++ * 2;
print(res1); // 10
print(a); // 6
int b= 5;
// Prefijo: cambiar primero b a 6, luego calcular
int res2 = ++b * 2;
print(res2); // 12
print(b); // 6
}Lenguaje del código: PHP (php)A y b terminan valiendo 6 en ambos casos, pero res1 y res2 tienen valores distintos solo por la posición del operador ++.
Explicación del postfijo a++: primero se ejecuta a*2=10 con a=5, ese valor se guarda en res1 y después a aumenta a 6.
En el prefijo ++b: primero se suma 1 a b para que valga 6, luego se calcula 6*2=12 que se asigna a res2.
La línea int res1 = a++ * 2; se desglosa así:
int res1 = a * 2;
a = a +1;La línea int res2 = ++b * 2; se desglosa así:
b = b+1;
int res2 = b * 2;
Frase mnemotécnica para recordarlo:
Prefijo modifica primero, postfijo usa primero;
El prefijo devuelve el valor nuevo, el postfijo el original.
Resumen
Prefijo ++a / --a: modificar primero la variable, luego usar el valor modificado para operaciones o asignaciones
Postfijo a++ / a--: usar primero el valor original de la variable para operaciones o asignaciones, y una vez terminada la operación modificar la variable
Puedes probar los siguientes ejemplos:
void main() {
int a = 0;
int b = ++a;
// Paso 1: a = a + 1 → a=1
// Paso 2: asignar el nuevo valor a (1) a b
print(a); // 1
print(b); // 1
}void main() {
int a = 0;
int b = a++;
// Paso 1: asignar el valor original de a (0) a b
// Paso 2: ejecutar a = a + 1 → a=1
print(a); // 1
print(b); // 0
}void main() {
int a = 0;
int b = --a;
// Paso 1: a = a - 1 → a=-1
// Paso 2: asignar el nuevo valor a (-1) a b
print(a); // -1
print(b); // -1
}void main() {
int a = 0;
int b = a--;
// Paso 1: asignar el valor original de a (0) a b
// Paso 2: ejecutar a = a - 1 → a=-1
print(a); // -1
print(b); // 0
}Estos son los ejemplos más simples de incremento y decremento prefijo y postfijo. Compila y ejecútalos tú mismo para notar la diferencia.