Aprenda Conceitos Básicos de Operadores & Expressões

Na programação em Go, os operadores são símbolos ou combinações de símbolos que realizam várias operações em valores ou variáveis.

Uma expressão é uma combinação de valores e operadores que produz um valor avaliado. Por exemplo, 7 + 9 é uma expressão que resulta em 16, e 7 * 9 é uma expressão que resulta em 63, já que o operador * representa a multiplicação.

Neste capítulo, exploraremos os operadores aritméticos. A maioria dos demais operadores será discutida nas seções subsequentes, conforme relevante.

Operador	Função
`+`	Adição
`-`	Subtração
`*`	Multiplicação
`/`	Divisão
`%`	Resto(Mod)
`++`	Incremento
`--`	Decremento

Estudar o seguinte código e seus respectivos resultados pode ser um exercício valioso para a compreensão de código. Todos os operadores aritméticos são elucidados dentro do código usando comentários, juntamente com o respectivo resultado.

index.go


              123456789101112131415161718192021222324252627282930313233343536
            
package main
import "fmt"
 
func main() {
 
	// Addition
	fmt.Println("Addition (7 + 9):", 7+9) // Outputs 16
 
	// Subtraction
	fmt.Println("Subtraction (7 - 9):", 7-9) // Outputs -2
 
	// Multiplication
	fmt.Println("Multiplication (7 * 9):", 7*9) // Outputs 63
 
	// Division
	fmt.Println("Division (10 / 2):", 10/2) // Outputs 5
	fmt.Println("Division (7 / 9):", 7/9)   // Outputs 0, reason will be explained in the next section
 
	// Remainder (Modulus)
	fmt.Println("Mod (10 % 2)", 10%2) // Outputs 0
	fmt.Println("Mod (10 % 3)", 10%3) // Outputs 1
	fmt.Println("Mod (10 % 4)", 10%4) // Outputs 2
 
	var myVar = 1
	fmt.Println("Value:", myVar) // Outputs 1
 
	// Increment Operator (++)
	// Increases a variable's value by 1
	myVar++
	fmt.Println("Value (after ++):", myVar) // Outputs 2
 
	// Decrement Operator (--)
	// Decreases a variable's value by 1
	myVar--
	fmt.Println("Value (after --)", myVar) // Outputs 1
}

Por padrão, em Go, as expressões são avaliadas utilizando a regra BODMAS (também conhecida como PEMDAS). Segundo esta regra, uma expressão é avaliada na seguinte ordem:

Parênteses

Expoentes

Divisão

Multiplicação

Adição

Subtração

Considere a expressão 1 + 3 * 4 / 2. A ordem de avaliação e o resultado são os seguintes:

1 + 3 * 4 / 2 → 1 + 3 * 2 → 1 + 6 → 7

Portanto, fmt.Println(1 + 3 * 4 / 2) produz a saída 7.

Podemos usar parênteses para alterar a ordem das operações e, consequentemente, o resultado:

(1 + 3) * 4 / 2 → 4 * 4 / 2 → 4 * 2 → 8

Parênteses também podem ser aninhados para um controle mais preciso das operações:

((1 - 3) + 4) / 2 → (-2 + 4) / 2 → 2 / 2 → 1

No caso acima, a subtração foi realizada primeiro, seguida pela adição, e então a divisão.

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 1. Capítulo 7

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

Suggested prompts:

Can you provide example code demonstrating these operators in Go?

Can you explain how increment and decrement operators work in Go?

Are there any differences in operator precedence between Go and other languages?

Deslize para mostrar o menu