Operaciones aritméticas en Go

¿Qué es y para qué sirve?

Imagina que eres cajero en una tienda. Llegan clientes y necesitas calcular rápido el cambio: cuánto cuesta el producto, cuánto dinero dio el cliente, cuánto hay que devolver. O, por ejemplo, horneas pastelitos según una receta que dice "toma 2 huevos y 3 tazas de harina", pero necesitas hornear 4 veces más — tendrás que multiplicar. Todo esto son operaciones aritméticas: suma, resta, multiplicación y división.

En programación (y en el lenguaje Go) funcionan exactamente igual que en matemáticas o en la vida real. La computadora es como ese cajero, pero muy rápido. Sabe sumar, restar, multiplicar y dividir números en fracciones de segundo. No se puede prescindir de esto: si quieres hacer un juego, necesitas contar puntos; si quieres escribir una calculadora, necesitas sumar; si quieres procesar datos, otra vez aritmética. Esta es la base con la que comienza cualquier código.

Sintaxis y ejemplos de código

En Go, la aritmética se ve muy similar a las matemáticas normales. Estos son los signos básicos:

• + — suma
• - — resta
• * — multiplicación (asterisco, no una cruz)
• / — división (barra inclinada)
• % — resto de la división (por ejemplo, 7 % 3 = 1, porque 7 se divide entre 3 solo una vez, y sobra 1)

Mira los ejemplos. El código se escribe dentro de la función main.

package main

import "fmt"

func main() {
    // Ejemplo 1: Suma — cómo calcular cuántas manzanas tienes en total
    applesMasha := 5   // Masha tiene 5 manzanas
    applesPetya := 3   // Petya tiene 3 manzanas
    totalApples := applesMasha + applesPetya // sumamos
    fmt.Println("Total de manzanas:", totalApples) // imprimirá: Total de manzanas: 8
}

package main

import "fmt"

func main() {
    // Ejemplo 2: Resta — cuánto dinero quedará si compras una pizza
    money := 1000          // tienes 1000 rublos
    pizzaPrice := 450      // la pizza cuesta 450
    change := money - pizzaPrice // restamos
    fmt.Println("Cambio:", change) // imprimirá: Cambio: 550
}

package main

import "fmt"

func main() {
    // Ejemplo 3: Multiplicación — cuántas galletas hay en 4 paquetes
    cookiesPerPack := 8   // en un paquete hay 8 galletas
    packs := 4            // tienes 4 paquetes
    totalCookies := cookiesPerPack * packs // multiplicamos
    fmt.Println("Total de galletas:", totalCookies) // imprimirá: Total de galletas: 32
}

package main

import "fmt"

func main() {
    // Ejemplo 4: División — cómo dividir una pizza entre amigos
    pizzaSlices := 8      // la pizza está cortada en 8 trozos
    friends := 4          // 4 amigos
    slicesPerFriend := pizzaSlices / friends // dividimos
    fmt.Println("Trozos para cada uno:", slicesPerFriend) // imprimirá: Trozos para cada uno: 2
}

package main

import "fmt"

func main() {
    // Ejemplo 5: Resto de la división — cuántos trozos sobrarán si los amigos son 3
    pizzaSlices := 8
    friends := 3
    slicesPerFriend := pizzaSlices / friends // trozos enteros para cada uno: 2
    leftover := pizzaSlices % friends        // resto: 8 % 3 = 2
    fmt.Println("Para cada uno:", slicesPerFriend, "sobrarán:", leftover)
    // imprimirá: Para cada uno: 2 sobrarán: 2
}

Ten en cuenta: en Go, si divides un número entero entre otro entero, el resultado será entero (la parte fraccionaria se descarta). Por ejemplo, 7 / 2 dará 3, no 3.5. Para números fraccionarios necesitas usar el tipo float64 (pero eso ya es un poco más complicado).

Comparación con Python

Si ya has probado Python, notarás que la aritmética es muy similar. Pero hay un par de diferencias.

En Python, la división / siempre da un resultado fraccionario (por ejemplo, 7 / 2 = 3.5). Y para obtener la parte entera, necesitas escribir // (dos barras inclinadas). En Go es al revés: la división normal / para números enteros da la parte entera, y para fraccionarios da la parte fraccionaria. El resto de la división en ambos lenguajes es %.

Así es como se verían los mismos ejemplos en Python:

# Python
apples_masha = 5
apples_petya = 3
total_apples = apples_masha + apples_petya
print("Total de manzanas:", total_apples)  # 8

money = 1000
pizza_price = 450
change = money - pizza_price
print("Cambio:", change)  # 550

cookies_per_pack = 8
packs = 4
total_cookies = cookies_per_pack * packs
print("Total de galletas:", total_cookies)  # 32

pizza_slices = 8
friends = 4
slices_per_friend = pizza_slices / friends  # en Python será 2.0 (fraccionario)
print("Trozos para cada uno:", slices_per_friend)  # 2.0

# Resto
leftover = pizza_slices % friends
print("Sobrarán:", leftover)  # 0

La principal diferencia: en Python no necesitas indicar explícitamente el tipo de la variable (simplemente escribes a = 5), mientras que en Go sí es necesario (o usar la notación corta :=, como en los ejemplos). Pero las operaciones en sí son las mismas.

Errores típicos de principiantes

• Olvidar el tipo de dato. Si escribes var a int = 10 / 3, obtendrás 3, no 3.333. Los principiantes suelen esperar un resultado fraccionario. Recuerda: los números enteros se dividen de forma entera.
• Dividir entre cero. En matemáticas no se puede dividir entre cero, y en Go tampoco. Si intentas 10 / 0, el programa fallará con un error (panic). Siempre verifica que el divisor no sea cero.
• Confundir el resto. El operador % solo funciona con números enteros. No se puede escribir 5.5 % 2 — dará error. El resto es lo que queda después de la división entera.
• Orden de las operaciones. Como en matemáticas: primero multiplicación y división, luego suma y resta. Si quieres cambiar el orden, usa paréntesis: (2 + 3) * 4 dará 20, mientras que 2 + 3 * 4 dará 14.
• Olvidar el desbordamiento. Si el número es demasiado grande para tu