Operadores aritméticos y expresiones en Go

Un operador permite realizar una operación (de ahí su nombre) sobre uno o varios valores (operandos), que pueden ser datos directos, variables o constantes.

Operadores aritméticos

Los operadores artiméticos en Go son:

+  Suma
-  Resta
*  Multiplicación
/  División
%  Resto (de la división)

Estos operadores permiten realizar operaciones aritméticas con valores numéricos.

Expresiones

Una expresión se refiere a la transcripción de una o varias operaciones mediante código, utilizando para ello operadores, variables, constantes, valores, etc.

Para que un operador aritmético pueda desempeñar su función, es necesario expresar la operación de la siguiente manera:

operando1 operador operando2

Los operandos son los valores que intervienen en la operación. Pueden ser valores directos, variables o constantes.

Ejemplo simple

El siguiente ejemplo muestra el uso de los operadores aritméticos y de las expresiones, las cuales realizarán el calculo determinado por el operador, y el resultado se asignará a una variable.

package main

import "fmt"

func main() {
   var op1, op2 int = 6, 4
   var suma int = op1 + op2
   var resta int = op1 - op2
   var multiplicacion int = op1 * op2
   var division int = op1 / op2
   var resto int = op1 % op2

   fmt.Printf("%v + %v = %v\n", op1, op2, suma)
   fmt.Printf("%v - %v = %v\n", op1, op2, resta)
   fmt.Printf("%v * %v = %v\n", op1, op2, multiplicacion)
   fmt.Printf("%v / %v = %v\n", op1, op2, division)
   fmt.Printf("%v resto %v = %v\n", op1, op2, resto)
}

El resultado será el siguiente:

$ go operadores-aritmeticos.go
6 + 4 = 10
6 - 4 = 2
6 * 4 = 24
6 / 4 = 1
6 resto 4 = 2

Precedencia de los operadores

Cuando escribimos expresiones más complejas, donde se desarrollan varias operaciones, el orden de precedencia será siempre de izquierda a derecha.

fmt.Println("4 + 3 - 1 = ", 4+3-1)

En este caso, primero se sumarán 4 y 3 (7), y después se restará 1, dando como resultado el valor 6.

Sin embargo, según el operador, la precedencia cambia. Por ejemplo, el siguiente ejemplo:

fmt.Println("4 + 2 * 6 - 8 / 2 + 4 % 2 = ", 4+2*6-8/2+4%2)

daría como resultado 12

En esta expresión tan larga, primero se calcularían las expresiones con el operador de mayor peso, y después, con los resultados, se calcularían las expresiones de menor peso, siempre de izquierda a derecha.

Los operadores de mayor peso son la multiplicación, la división y el resto. Los operadores de menor peso serían la suma y la resta.

Por tanto, en el ejemplo anterior se calcularían primero, de izquierda a derecha, las operaciones de mayor peso. Una vez calculadas, de izquierda a derecha, se calcularían las operaciones de menor peso.

4 + [2 * 6] - [8 / 2] + [4 % 2]
4 + 12 - 4 + 0
12

Nota: Se han enmarcado entre corchetes las operaciones de mayor peso para identificar claramente cómo se realizan los cálculos

La precedencia de los paréntesis

Los paréntesis permiten cambiar la precedencia de los operadores, obteniendo el mayor peso en la precedencia. Por tanto, primero se calculan los paréntesis, después la multiplicación, división o resto, y, por último, la suma o la resta.

fmt.Println("(4 + 2) * (6 - 8) / 2 + 4 = ", (4+2)*(6-8)/2+4)

El resultado de la expresión anterior será -2. El orden de las operaciones es el siguiente:

(4 + 2) * (6 - 8) / 2 + 4
(6) * (-2) / 2 + 4
-12 / 2 + 4
-6 + 4
-2

El paréntesis no tiene por qué englobar sólo una operación. Puede tener las operaciones que sean necesarias, e incluso englobar entre paréntesis operaciones dentro de otra operación englobada por paréntesis. Aquí el orden de precedencia serían desde los paréntesis más profundos hasta los más externos. Veamos un ejemplo:

fmt.Println("(4 + 2) * ((6 - 8 / 2) + 4) = ", (4+2)*((6-8/2)+4))

El orden de las operaciones es el siguiente:

(4 + 2) * ((6 - 8 / 2) + 4)
(4 + 2) * ((6 - [8 / 2]) + 4)
(4 + 2) * ((6 - 4) + 4)
(4 + 2) * (2 + 4)
(6) * (6)
36

Enlaces de interés

• The Go Programming Language Specification - Operators: https://golang.org/ref/spec#Operators