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

• Série Go: Uma abordagem sobre a Linguagem de Programação Golang
• Série Go: Variáveis, Concatenação, Constantes e Tipos de Dados

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:

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

Marcos Oliveira

Desenvolvedor de software

https://github.com/terroo