Operadores de Dart

Dart admite todos los operadores que aparecen en la tabla siguiente, la tabla está ordenada por prioridad de mayor a menor

Categoría descriptiva	Operadores	Asociatividad
Operadores unarios postfijos	expr++ expr-- () [] ?[] . ?. !	Sin asociatividad
Operadores unarios prefijos	- expr ! expr ~ expr ++ expr -- expr await expr	Sin asociatividad
Multiplicación y división	* / % ~/	Asociativo por la izquierda
Suma y resta	+ -	Asociativo por la izquierda
Desplazamiento de bits	<< >> >>>	Asociativo por la izquierda
AND bit a bit	&	Asociativo por la izquierda
XOR bit a bit	^	Asociativo por la izquierda
OR bit a bit	|	Asociativo por la izquierda
Relacional y comprobación de tipos	>= > <= < as is is!	Sin asociatividad
Comparación de igualdad	== !=	Sin asociatividad
AND lógico	&&	Asociativo por la izquierda
OR lógico	||	Asociativo por la izquierda
Operador de fusión null	??	Asociativo por la izquierda
Operador ternario condicional	expr1 ? expr2 : expr3	Asociativo por la derecha
Operadores en cascada	.. ?..	Asociativo por la izquierda
Operadores de asignación	= *= /= += -= &= ^= etc.	Asociativo por la derecha
Operador spread (ver nota)	... ...?	Sin asociatividad

Usando los operadores anteriores junto con los operandos, se pueden construir expresiones de cálculo

Ejemplos simples:

a++
a + b
a = b
a == b
c ? a : b
a is T

A continuación un ejemplo completo ejecutable:

void main() {
  // 1. Expresión de incremento postfijo a++
  int a = 10;
  print("1. Incremento postfijo a++");
  print("Antes del incremento a = $a");
  int temp = a++; // Primero lee el valor, luego incrementa
  print("temp (valor obtenido) = $temp");
  print("Después del incremento a = $a\n");

  // 2. Expresión de suma a + b
  int b = 20;
  int suma = a + b;
  print("2. Suma a + b");
  print("$a + $b = $suma\n");

  // 3. Expresión de asignación a = b
  a = b;
  print("3. Asignación a = b");
  print("Después de asignar a = $a\n");

  // 4. Expresión de comparación de igualdad a == b
  bool esIgual = a == b;
  print("4. Comparación de igualdad a == b");
  print("Resultado de a == b: $esIgual\n");

  // 5. Expresión ternaria condicional c ? a : b
  int c = 5;
  String resultado = c > 0 ? "c es un número positivo" : "c es negativo o cero";
  print("5. Operador ternario c ? a : b");
  print("Comprobación c>0: $resultado\n");

  // 6. Expresión de comprobación de tipo a is T
  dynamic valorPrueba = 100;
  print("6. Comprobación de tipo a is T");
  print("valorPrueba es int: ${valorPrueba is int}");
  print("valorPrueba es String: ${valorPrueba is String}");
}
Lenguaje del código: Dart (dart)

Copia el código anterior y ejecútalo con el comando: dart run

Reglas fundamentales de prioridad de operadores

1. Lógica del orden de prioridad

La tabla de operadores tiene prioridad decreciente de arriba hacia abajo: los operadores de las filas superiores tienen mayor prioridad y se ejecutan primero.

Ejemplo: el símbolo > significa «tiene mayor prioridad», no una comparación de magnitudes.

Orden de ejecución: módulo % ＞ comparación de igualdad == ＞ AND lógico &&

Desglose de ejecución de la expresión n % i == 0 && d % i == 0:

1. Primero se calculan n % i, d % i (% tiene la prioridad más alta)
2. Luego se realizan las dos comparaciones ==
3. Al final se ejecuta el AND lógico central &&

2 Función de los paréntesis

Los paréntesis ((n % i == 0) && (d % i == 0)) solo mejoran la legibilidad del código, no modifican el orden original de ejecución;

La versión sin paréntesis n % i == 0 && d % i == 0 se ejecuta según la prioridad nativa, ambos fragmentos tienen lógica y resultados totalmente equivalentes;

Anotación complementaria: solo cuando se necesita romper la prioridad por defecto, los paréntesis cambian el orden de ejecución.

void main() {
  int n = 10;
  int d = 20;
  int i = 2;

  // Forma 1: con paréntesis, mayor legibilidad
  if ((n % i == 0) && (d % i == 0)) {
    print("Forma 1: es divisible exactamente");
  }

  // Forma 2: sin paréntesis, se rige por la prioridad nativa, resultado idéntico
  if (n % i == 0 && d % i == 0) {
    print("Forma 2: es divisible exactamente");
  }
}

Resultado de ejecución:

Forma 1: es divisible exactamente
Forma 2: es divisible exactamente