Como fazer cálculos matemáticos com operadores em Go

Introdução

Os números são comuns na programação. Eles são usados para representar coisas como: dimensões de tela, localizações geográficas, dinheiro e pontos, a quantidade de tempo que passa em um vídeo, posições de avatares de jogos, cores através da atribuição de códigos numéricos e assim por diante.

O desempenho eficaz das operações matemáticas na programação é uma habilidade importante a se desenvolver, tendo em vista a frequência com a qual você vai trabalhar com números. Embora a compreensão de alto grau da matemática possa ajudar você a ser um melhor programador, tal compreensão não é um pré-requisito. Se você não tiver experiência em matemática, tente pensar nela como uma ferramenta para realizar o que quiser alcançar e também como uma maneira de melhorar seu pensamento lógico.

Trabalharemos com dois tipos de dados mais usados em Go - os números inteiros e os floats:

• Os inteiros, como o próprio nome diz, são número inteiros que podem ser positivos, negativos, ou 0 (…, -1, 0, 1, …).
• Os floats são números reais que contêm casas decimais, como 9.0, ou -2.25.

Este tutorial irá rever os operadores que podemos usar com os tipos de dados no Go.

Operadores

Um operador é um símbolo ou função que indica uma operação. Por exemplo, na matemática o sinal de mais ou + é o operador que indica a adição.

Na linguagem Go, vamos ver alguns operadores familiares que são trazidos da matemática. No entanto, outros operadores que usaremos são específicos para a programação de computadores.

Aqui está uma tabela de referência rápida de operadores relacionados à matemática em Go. Neste tutorial, vamos falar sobre todas as operações a seguir.

Também vamos abordar os operadores de atribuição de compostos, incluindo o += e *=, que combinam operadores matemáticos com o operador =.

Adição e subtração

Em Go, os operadores de adição e subtração são executados assim como fazem na matemática. De fato, você pode usar a linguagem de programação Go como uma calculadora.

Vamos examinar alguns exemplos, começando com os inteiros:

fmt.Println(1 + 5)

Output
6

Em vez de enviar os inteiros diretamente para a instrução fmt.Println, podemos inicializar variáveis para representar os valores inteiros usando a sintaxe como segue:

a := 88
b := 103

fmt.Println(a + b)

Output
191

Como os inteiros podem ser números positivos e negativos (e também 0), podemos adicionar um número negativo a um número positivo:

c := -36
d := 25

fmt.Println(c + d)

Output
-11

A adição irá comportar-se de maneira parecida com os floats:

e := 5.5
f := 2.5

fmt.Println(e + f)

Output
8

Como adicionamos dois floats juntos, o Go retornou um valor float com uma casa decimal. No entanto, como a casa decimal é zero neste caso, a fmt.Println retirou a formatação decimal. Para formatar a saída corretamente, podemos usar fmt.Printf e o verbo %2f, que irá formatar para duas casas decimais, desta forma:

fmt.Printf("%.2f", e + f)

Output
8.00

A sintaxe da subtração é a mesma que a da adição, exceto que mudamos o operador do sinal de mais (+) para o sinal de menos (-):

g := 75.67
h := 32.0

fmt.Println(g - h)

Output
43.67

Em Go, podemos usar somente os operadores nos mesmos tipos de dados. Não podemos somar um int e um float64:

i := 7
j := 7.0
fmt.Println(i + j)

Output
i + j (mismatched types int and float64)

Tentar usar os operadores em tipos de dados diferentes resultará em um erro de compilação.

Operações aritmética unárias

Uma expressão matemática unária consiste de apenas um componente ou elemento. Na linguagem Go, podemos usar os sinais mais e menos, como um único elemento com um valor para: retornar a identidade do valor (+), ou alterar o sinal do valor (-).

Embora não seja comumente usado, o sinal mais indica a identidade do valor. Podemos usar o sinal de mais com valores positivos:

i := 3.3
fmt.Println(+i)

Output
3.3

Ao usarmos o sinal de mais com um valor negativo, ele também retornará a identidade daquele valor e, neste caso, seria um valor negativo:

j := -19
fmt.Println(+j)

Output
-19

Com um valor negativo, o sinal de mais retorna o mesmo valor negativo.

No entanto, o sinal de menos muda o sinal de um valor. Então, quando enviarmos um valor positivo, vamos descobrir que o sinal de menos antes do valor retornará um valor negativo:

k := 3.3
fmt.Println(-k)

Output
-3.3

De forma alternativa, quando usamos o operador unário de sinal menos com um valor negativo, será retornado um valor positivo:

j := -19
fmt.Println(-j)

Output
19

As operações aritméticas unárias, indicadas pelo sinal de mais e de menos retornarão a identidade do valor no caso de +i ou o sinal oposto do valor como em -i.

Multiplicação e divisão

Como na adição e na subtração, a multiplicação e a divisão ficarão muito semelhantes à forma como elas funcionam na matemática. O sinal que usaremos para a multiplicação no Go é * e o sinal que usaremos para a divisão é a /.

Aqui está um exemplo de como fazer uma multiplicação em Go com dois valores float:

k := 100.2
l := 10.2

fmt.Println(k * l)

Output
1022.04

Em Go, a divisão tem características diferentes, dependendo do tipo numérico que estivermos dividindo.

Se estivermos dividindo números inteiros, o operador / do Go executará a divisão com arredondamento para baixo, onde para o quociente x, o número retornado será o maior número inteiro menor que ou igual a** x**.

Se você executar o exemplo a seguir, fazendo a divisão 80 / 6, receberá 13 como o resultado e o tipo de dados será um int:

package main

import (
	"fmt"
)

func main() {
	m := 80
	n := 6

	fmt.Println(m / n)
}

Output
13

Se o resultado desejado for um float, você precisa converter explicitamente os valores antes da divisão.

Você pode fazer isso envolvendo seus valores com o seu tipo float desejado de float32() ou float64():

package main

import (
	"fmt"
)

func main() {
	s := 80
	t := 6
	r := float64(s) / float64(t)
	fmt.Println(r)
}

Output
13.333333333333334

Módulo

O operador % é o módulo que, após a divisão, retorna o resto em vez do quociente. Isso é útil para a descoberta de números que sejam múltiplos do mesmo número.

Vamos examinar um exemplo do módulo:

o := 85
p := 15

fmt.Println(o % p)

Output
10

Desdobrando isso tudo, temos que 85 dividido por 15 retorna o quociente 5 com um resto de 10. Nosso programa retorna o valor 10 aqui, uma vez que o operador módulo retorna o resto de uma expressão de divisão.

Para fazer cálculos de módulos com tipos de dados float64, você usará a função Mod do pacote math:

package main

import (
	"fmt"
	"math"
)

func main() {
	q := 36.0
	r := 8.0

	s := math.Mod(q, r)

	fmt.Println(s)
}

Output
4

Precedência de operador

Na linguagem Go, assim como na matemática, precisamos ter em mente que os operadores serão avaliados por ordem de precedência e não da esquerda para a direita ou da direta para a esquerda.

Se examinarmos a seguinte expressão matemática:

u = 10 + 10 * 5

Podemos lê-la da esquerda para a direita, mas a multiplicação será feita primeiro; assim, se tivéssemos que imprimir u, receberíamos o seguinte valor:

Output
60

Isso acontece porque 10 * 5 é igual a 50 e, em seguida, adicionamos 10 para retornar 60 como o resultado final.

Se, em vez disso, quiséssemos somar o valor de 10 a 10 e depois multiplicássemos aquela soma por 5, usaríamos parênteses em Go, assim como faríamos na matemática:

u := (10 + 10) * 5
fmt.Println(u)

Output
100

Uma maneira de lembrar a ordem da operação é através do acrônimo PEMDAS:

Você pode estar familiarizado com outro acrônimo para a ordem das operações, como o BEDMAS ou BODMAS. Qualquer que seja o acrônimo que funcione melhor para você, procure tê-lo em mente ao realizar operações matemáticas em Go para que os resultados que você espera sejam retornados.

Operadores de atribuição

O operador de atribuição mais comum é aquele que você já usou: o sinal igual =. O operador de atribuição = atribui o valor à direita para uma variável à esquerda. Por exemplo, o v = 23 atribui o valor do inteiro 23 à variável v.

Ao programar, é comum usar operadores de atribuição compostos que realizam uma operação no valor de uma variável e, depois, atribuem o novo valor resultante para aquela variável. Esses operadores compostos combinam um operador aritmético com o operador =. Portanto, para a adição vamos combinar + com = para obter o operador composto +=. Vejamos como fica:

w := 5
w += 1
fmt.Println(w)

Output
6

Primeiro, definimos a variável w igual ao 5 e, depois, usamos o operador de atribuição composto += para somar o número da direita ao valor da variável à esquerda; em seguida, atribuímos o resultado para w.

Os operadores de atribuição compostos são usados frequentemente no caso de loops for, que você usará quando quiser repetir um processo várias vezes:

package main

import "fmt"

func main() {

	values := []int{0, 1, 2, 3, 4, 5, 6}

	for _, x := range values {

		w := x

		w *= 2

		fmt.Println(w)
	}

}

Output
0
2
4
6
8
10
12

Ao usar um loop for para iterar na fatia chamada valores, você pôde automatizar o processo do operador *=, o qual multiplicou a variável w pelo número 2 e, então, atribuiu o resultado de volta para a variável w.

Go tem um operador de atribuição composto para cada um dos operadores aritméticos discutidos neste tutorial.

Para adicionar e, então, atribuir o valor:

y += 1

Para subtrair e, então, atribuir o valor:

y -= 1

Para multiplicar e, então, atribuir o valor:

y *= 2

Para dividir e, então, atribuir o valor:

y /= 3

Para retornar o resto e, então, atribuir o valor:

y %= 3

Os operadores de atribuição compostos podem ser úteis quando as coisas precisam ser aumentadas ou diminuídas, de maneira incremental, ou quando você precisar automatizar certos processos em seu programa.

Conclusão

Este tutorial tratou de muitos dos operadores que você usará com os tipos de dados numéricos inteiros e float. Você pode aprender mais sobre os diferentes tipos de dados em Entendendo tipos de dados em Go e em Como converter tipos de dados.