Série Go: Arrays, Operadores e Condições

Nesse artigo vamos dar prosseguimento a nossa Série Go, os tópicos anteriores são:

Nesse artigo vamos ver: Arrays, Operadores e Condições.

Arrays

Arrays em Go são estruturas de dados que armazenam uma sequência fixa de elementos do mesmo tipo. São úteis quando se conhece de antemão a quantidade exata de elementos que serão manipulados.

Declaração

var a [5]int

Cria um array de 5 inteiros, inicializados com zero.

Também é possível inicializar diretamente:

b := [3]string{"Go", "é", "rápido"}

Ou deixar o compilador inferir o tamanho:

c := [...]float64{3.14, 2.71, 1.41}

Acesso e Modificação

a[0] = 10
fmt.Println(a[0])

Iteração

for i, v := range b {
    fmt.Println(i, v)
}

Propriedades

Tamanho fixo: o tamanho faz parte do tipo. [3]int e [4]int são tipos diferentes.
Valor por cópia: ao atribuir um array a outro, ele é copiado:

x := [2]int{1, 2}
y := x
y[0] = 9
fmt.Println(x) // [1 2]

Arrays Multidimensionais

var matriz [2][3]int
matriz[0][1] = 42

Limitações

Tamanho fixo torna arrays pouco flexíveis.
Usualmente substituídos por slices, que são mais dinâmicos.

Operadores

Go oferece um conjunto direto de operadores para manipulação de valores. Eles são divididos em categorias: aritméticos, relacionais, lógicos, bit a bit, de atribuição e especiais. São usados para realizar operações matemáticas comuns:

Operador	Nome	Descrição	Exemplo
`+`	Adição	Soma dois valores	x + y
`-`	Subtração	Subtrai um valor de outro	`x - y`
`*`	Multiplicação	Multiplica dois valores	`x * y`
`/`	Divisão	Divide um valor por outro	`x / y`
`%`	Módulo	Retorna o resto da divisão	`x % y`
`++`	Incremento	Aumenta o valor de uma variável em 1	`++x`
`--`	Decremento	Diminui o valor de uma variável em 1	`--x`

Há também os:

Operadores de Comparação: ==, !=, >, <, >=, <=;
Operadores de Atribuição: =, +=, -=, *=, /=, %=, &=, |=, ^=, >>= e <<=;
Operadores Lógicos: &&, || e !;
Operadores Bit a Bit(Bitwise): &, |, ^, << e >> .

Exemplo de uma expressão matemática com Golang:

package main

import "fmt"

func main(){
  fmt.Println( 2 + 6 / 4 + 3 * 3 - (4 -1) ) // 9
}

go run operadores.go

Condições

Go usa estruturas de controle simples para decisões condicionais. As principais são if, if-else, else if e switch.

1. `if`

if condição {
    // bloco executado se condição for verdadeira
}

Exemplo:

x := 10
if x > 5 {
    fmt.Println("Maior que 5")
}

2. `if` com declaração curta

Permite inicializar variáveis dentro do if.

if y := calcula(); y > 10 {
    fmt.Println("Resultado > 10")
}

y só existe dentro do bloco.

3. `if-else`

if condição {
    // verdadeiro
} else {
    // falso
}

4. `else if`

Permite múltiplas verificações sequenciais:

if x < 0 {
    fmt.Println("Negativo")
} else if x == 0 {
    fmt.Println("Zero")
} else {
    fmt.Println("Positivo")
}

5. `switch`

Usado para múltiplas comparações, mais limpo que vários if-else.

switch valor {
case 1:
    fmt.Println("Um")
case 2:
    fmt.Println("Dois")
default:
    fmt.Println("Outro")
}

Não precisa de break.
Pode usar switch true para expressões booleanas:

switch {
case x < 0:
    fmt.Println("Negativo")
case x == 0:
    fmt.Println("Zero")
default:
    fmt.Println("Positivo")
}

6. `fallthrough`

Força a execução do próximo case, mesmo que a condição não seja satisfeita:

switch x := 1; x {
case 1:
    fmt.Println("Um")
    fallthrough
case 2:
    fmt.Println("Dois também")
}

Por hoje é só até o próximo tópico!

go series-go