La precedencia de operadores en Go es el conjunto de reglas jerárquicas que determinan el orden de evaluación de las expresiones cuando existen múltiples operadores binarios. Esta jerarquía garantiza que el compilador resuelva las operaciones de forma unívoca, siguiendo una estructura de cinco niveles de prioridad de arriba hacia abajo, donde los operadores de un nivel superior se evalúan antes que los de niveles inferiores.
Go simplifica drásticamente este comportamiento en comparación con lenguajes como C++ o Java, que presentan tablas de precedencia mucho más extensas y complejas. Al reducir el número de niveles, el diseño del lenguaje busca minimizar la ambigüedad sintáctica y facilitar el análisis estático del código. Esta estructura obliga al desarrollador a ser más consciente de la agrupación de operaciones, promoviendo el uso de paréntesis como mecanismo de claridad semántica por encima de la memorización de reglas oscuras.
Jerarquía de evaluación y asociatividad
En Go, los operadores con la misma precedencia se evalúan de izquierda a derecha (asociatividad por la izquierda). La tabla se divide en cinco niveles distintos: el nivel 5 incluye operadores de multiplicación, división, residuo y desplazamientos de bits (*, /, %, <<, >>, &, &^); el nivel 4 corresponde a la suma, resta, OR inclusivo y OR exclusivo (+, -, |, ^); el nivel 3 abarca los operadores de comparación (==, !=, <, <=, >, >=); el nivel 2 es exclusivo para el AND lógico (&&); y el nivel 1 se reserva para el OR lógico (||).
Es fundamental notar que los operadores unarios, como el de dirección (&), desreferencia (*), negación lógica (!) o el operador de bitwise NOT (^), tienen una precedencia implícita superior a cualquier operador binario. El uso de paréntesis permite alterar este orden natural, forzando al lexer y al analizador sintáctico a evaluar subexpresiones específicas antes de integrarlas en la operación principal.
package main
import "fmt"
func main() {
// Nivel 5 vs Nivel 4
// La multiplicación precede a la suma
res1 := 5 + 2 * 10
fmt.Println(res1) // → 25
// Uso de paréntesis para alterar precedencia
res2 := (5 + 2) * 10
fmt.Println(res2) // → 70
// Comparación y lógica bitwise
// El desplazamiento << tiene nivel 5, la suma nivel 4
val := 1 << 2 + 1
fmt.Println(val) // → 8 (equivale a 1 << 3)
// Lógica booleana: && precede a ||
check := true || false && false
fmt.Println(check) // → true (equivale a true || (false && false))
}
El comportamiento de la expresión 1 << 2 + 1 suele resultar contraintuitivo para desarrolladores provenientes de lenguajes donde la suma tiene mayor jerarquía que los desplazamientos de bits. En Go, debido a que el desplazamiento está en el nivel superior (Nivel 5), se agrupa con sus operandos inmediatos antes de procesar la suma (Nivel 4), a menos que se utilicen paréntesis para clarificar la intención.
El operador Clear Bit y la jerarquía de bits
Un aspecto técnico relevante es el operador &^ (bit clear), que comparte el nivel máximo de precedencia. Este operador realiza un AND de x con el complemento de y, permitiendo limpiar bits específicos de forma atómica en una sola expresión.
Interacción entre comparaciones y operadores lógicos
Un error común surge al mezclar operadores de comparación con operadores lógicos sin paréntesis. Dado que los operadores de comparación (==, !=, etc.) residen en el Nivel 3 y los lógicos en Niveles 2 y 1, las comparaciones siempre se resolverán antes que la lógica de control.
Sin embargo, el edge case ocurre cuando se intentan realizar operaciones de bitwise dentro de una evaluación booleana. Debido a que & (AND a nivel de bits) tiene una precedencia de Nivel 5, una expresión como if mask & flags == expected fallará en la compilación o se evaluará de forma inesperada porque el compilador intentará evaluar (mask & flags) == expected. Aunque en este caso el orden natural ayuda, la falta de paréntesis en expresiones complejas que involucran máscaras de bits y comparaciones de igualdad suele derivar en bugs sutiles de lógica que solo se detectan en tiempo de ejecución.
- Módulo: Léxico y Sintaxis Fundamental
- Artículo número: #11