# Baixe a versão mais recente em https://go.dev/dl/
wget https://go.dev/dl/go1.22.0.linux-amd64.tar.gz

# Remove instalação anterior (se houver) e descompacta
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.22.0.linux-amd64.tar.gz

# Adicione ao seu .bashrc ou .zshrc
export PATH=$PATH:/usr/local/go/bin

go version
# go version go1.22.0 linux/amd64

brew install go
go version

go version

go env

GOROOT=/usr/local/go        # onde Go está instalado
GOPATH=/home/user/go        # diretório de trabalho
GOOS=linux                  # sistema operacional alvo
GOARCH=amd64               # arquitetura alvo
GOMODCACHE=/home/user/go/pkg/mod  # cache de módulos

mkdir hello && cd hello
go mod init github.com/seunome/hello

// Todo programa Go executável começa com o package main.
// Sem isso, o compilador não sabe que esse é um ponto de entrada.
package main

// import traz pacotes externos ou da biblioteca padrão.
// "fmt" significa "formatted I/O" - é o pacote de formatação básica.
import "fmt"

// A função main() é o ponto de entrada do programa.
// Não recebe argumentos aqui (argumentos de linha de comando
// ficam em os.Args).
func main() {
    fmt.Println("Hello, World!")
}

go run main.go
# Hello, World!

go build -o hello main.go
./hello
# Hello, World!

# Compila para Windows, mesmo estando no Linux
GOOS=windows GOARCH=amd64 go build -o hello.exe main.go

# Compila para Linux ARM (Raspberry Pi)
GOOS=linux GOARCH=arm64 go build -o hello-arm main.go

# Compila para macOS
GOOS=darwin GOARCH=amd64 go build -o hello-mac main.go

package main

import "fmt"

func main() {
    // Forma longa: var nome tipo = valor
    // Use quando você quer ser explícito sobre o tipo,
    // especialmente em variáveis de package (fora de funções).
    var idade int = 30

    // Forma curta: inferência de tipo
    // Use dentro de funções para a maioria dos casos.
    // O compilador infere que "nome" é string.
    nome := "Alice"

    // Declaração sem valor inicial: zero value
    // Em Go, toda variável tem um valor padrão. Não existe "undefined".
    var ativo bool   // false
    var contador int // 0
    var texto string // ""

    fmt.Println(nome, idade, ativo, contador, texto)

    // Declaração múltipla com var
    var (
        x, y int = 10, 20
        z        = 30.5 // float64 inferido
    )
    fmt.Println(x, y, z)

    // Múltipla atribuição curta
    a, b := 1, 2
    fmt.Println(a, b)

    // Swap idiomático - sem variável temporária
    a, b = b, a
    fmt.Println(a, b) // 2, 1
}

// Inteiros com tamanho explícito
var i8 int8   // -128 a 127
var i16 int16 // -32768 a 32767
var i32 int32 // -2 bilhões a 2 bilhões
var i64 int64 // enorme

// int e uint: tamanho depende da arquitetura (32 ou 64 bits)
// Na prática, use sempre "int" para inteiros de propósito geral
var n int = 42

// Ponto flutuante
var f32 float32 // ~7 dígitos de precisão
var f64 float64 // ~15 dígitos de precisão - use esse por padrão

// Booleano
var ok bool = true

// String: imutável, sequência de bytes UTF-8
var s string = "Olá, mundo"

// byte = alias para uint8 (um byte)
// rune = alias para int32 (um codepoint Unicode)
var b byte = 'A'
var r rune = '🚀'

// Para saber o tamanho de um tipo:
import "unsafe"
fmt.Println(unsafe.Sizeof(int64(0))) // 8 bytes

x := 42        // int (não int8, não int32 - sempre int)
y := 3.14      // float64 (não float32)
z := "texto"   // string
w := true      // bool

// Cuidado: a inferência pode surpreender com constantes numéricas
a := 1         // int
b := 1.0       // float64
c := int32(1)  // int32 explícito

// Constante tipada
const Pi float64 = 3.14159265358979

// Constante não tipada - tem "precisão arbitrária"
// pode ser usada com qualquer tipo numérico compatível
const MaxItems = 1000

// iota: gerador de constantes inteiras sequenciais
// Muito usado para enumerações
type DiaDaSemana int

const (
    Domingo  DiaDaSemana = iota // 0
    Segunda                     // 1
    Terca                       // 2
    Quarta                      // 3
    Quinta                      // 4
    Sexta                       // 5
    Sabado                      // 6
)

// iota com expressões
const (
    _  = iota             // ignora o primeiro valor (0)
    KB = 1 << (10 * iota) // 1 << 10 = 1024
    MB                    // 1 << 20
    GB                    // 1 << 30
    TB                    // 1 << 40
)

var i int       // 0
var f float64   // 0.0
var b bool      // false
var s string    // ""
var p *int      // nil
var sl []int    // nil (slice nil, não slice vazio)
var m map[string]int // nil
var fn func()   // nil

type Servidor struct {
    Host string
    Port int
    TLS  bool
}

// Funciona perfeitamente - todos os campos têm zero values
var s Servidor
fmt.Println(s.Port) // 0
fmt.Println(s.TLS)  // false

var i int = 42
var f float64 = float64(i) // conversão explícita obrigatória
var u uint = uint(f)       // explícita novamente

// Isso NÃO compila:
// var f float64 = i  // erro: cannot use i (type int) as type float64

// String para/de bytes
s := "hello"
b := []byte(s)    // converte string para slice de bytes
s2 := string(b)   // converte slice de bytes para string

// rune (Unicode codepoint) para string
r := '🚀'
sr := string(r) // "🚀"

package main

import "fmt"

// Variável de pacote: visível em todo o pacote
var versao = "1.0.0"

func main() {
    x := 10 // escopo: função main

    if x > 5 {
        y := 20         // escopo: bloco if
        fmt.Println(y)  // ok
    }
    // fmt.Println(y) // erro: y não existe aqui

    // Variável declarada no if é visível apenas dentro dele
    // Mas há uma forma útil de declarar no próprio if:
    if resultado, err := algumaFuncao(); err != nil {
        // resultado e err existem apenas aqui
        fmt.Println("erro:", err)
    } else {
        // resultado ainda existe no bloco else
        fmt.Println("ok:", resultado)
    }
    // resultado e err não existem aqui
}

func algumaFuncao() (int, error) {
    return 42, nil
}

Memória do processo
┌────────────────────────────┐
│          Stack             │ ← rápido, tamanho limitado, automático
│  (cresce para baixo ↓)    │
├────────────────────────────┤
│                            │
│         (espaço)           │
│                            │
├────────────────────────────┤
│           Heap             │ ← mais lento, tamanho "ilimitado", gerenciado
│  (cresce para cima ↑)     │
└────────────────────────────┘

package main

import "fmt"

func main() {
    // x é um int na stack, com valor 42
    x := 42

    // p é um ponteiro para int - guarda o ENDEREÇO de x
    // & é o operador "address of"
    p := &x

    fmt.Println(x)  // 42  - o valor
    fmt.Println(p)  // 0xc000018058 - o endereço (vai variar)
    fmt.Println(*p) // 42  - dereferenciando: "o valor no endereço p"

    // Modificar através do ponteiro modifica o original
    *p = 100
    fmt.Println(x) // 100
}

// Esta função não modifica o original - recebe uma CÓPIA
func dobrarErrado(n int) {
    n = n * 2 // modifica apenas a cópia local
}

// Esta função modifica o original - recebe o ENDEREÇO
func dobrarCerto(n *int) {
    *n = *n * 2 // modifica o valor no endereço recebido
}

func main() {
    x := 10
    dobrarErrado(x)
    fmt.Println(x) // 10 - não mudou

    dobrarCerto(&x)
    fmt.Println(x) // 20 - mudou
}

// Exemplo 1: fica na stack
func semEscape() int {
    x := 42   // x fica na stack
    return x  // retorna o VALOR, não o ponteiro
}             // frame da função é descartado, x some

// Exemplo 2: escapa para o heap
func comEscape() *int {
    x := 42   // x PRECISA ir para o heap!
    return &x // retorna o ENDEREÇO de x
}             // a função retorna, mas alguém tem o endereço de x
              // Go não pode descartá-la - ela vai para o heap

go build -gcflags='-m' main.go

# Output típico:
# ./main.go:9:2: moved to heap: x

// Ruim: cria uma nova slice em cada chamada
func processarItens(ids []int) []Resultado {
    resultados := make([]Resultado, 0) // alocação
    for _, id := range ids {
        resultados = append(resultados, processar(id))
    }
    return resultados
}

// Melhor: pré-aloca com tamanho conhecido
func processarItens(ids []int) []Resultado {
    resultados := make([]Resultado, 0, len(ids)) // capacidade pré-alocada
    for _, id := range ids {
        resultados = append(resultados, processar(id))
    }
    return resultados
}

// Melhor ainda em hot paths: reutiliza com sync.Pool (ver seção de performance)

// if básico - sem parênteses (diferente de C/Java/JS)
if x > 10 {
    fmt.Println("grande")
}

// if-else
if x > 10 {
    fmt.Println("grande")
} else if x > 5 {
    fmt.Println("médio")
} else {
    fmt.Println("pequeno")
}

// Forma idiomática: declaração + condição no mesmo if
// Muito comum para verificar erros
if err := fazerAlgo(); err != nil {
    return fmt.Errorf("ao fazer algo: %w", err)
}

// A variável err existe apenas dentro do if
// Isso mantém o escopo limpo
if usuario, err := buscarUsuario(id); err != nil {
    return nil, err
} else {
    // usuario existe aqui também
    return usuario, nil
}

// switch com valor
switch status {
case "ativo":
    fmt.Println("usuário ativo")
case "inativo", "suspenso": // múltiplos valores numa case
    fmt.Println("usuário não pode acessar")
default:
    fmt.Println("status desconhecido")
}
// Sem break! Go não faz fallthrough por padrão.
// Se quiser fallthrough explícito, use a keyword `fallthrough`

// switch sem valor: funciona como if-else encadeado
switch {
case x < 0:
    fmt.Println("negativo")
case x == 0:
    fmt.Println("zero")
case x > 0:
    fmt.Println("positivo")
}

// type switch: extremamente útil com interfaces
func descrever(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("inteiro: %d\n", v)
    case string:
        fmt.Printf("string: %q\n", v)
    case bool:
        fmt.Printf("bool: %t\n", v)
    default:
        fmt.Printf("tipo desconhecido: %T\n", v)
    }
}

// Loop clássico estilo C
for i := 0; i < 10; i++ {
    fmt.Println(i)
}

// Loop "while" (apenas condição)
n := 1
for n < 1000 {
    n *= 2
}

// Loop infinito
for {
    // só sai com break ou return
    if condicao {
        break
    }
}

// range: itera sobre slices, arrays, maps, strings, channels
// Com slice/array: retorna índice e valor
numeros := []int{10, 20, 30}
for i, v := range numeros {
    fmt.Println(i, v) // 0 10, 1 20, 2 30
}

// Se não precisa do índice, use _
for _, v := range numeros {
    fmt.Println(v)
}

// Se não precisa do valor
for i := range numeros {
    fmt.Println(i)
}

// range em map: ordem NÃO é garantida
m := map[string]int{"a": 1, "b": 2}
for k, v := range m {
    fmt.Println(k, v) // ordem aleatória
}

// range em string: itera por rune (codepoint Unicode), não byte
// Importante para strings com caracteres multibyte
for i, r := range "olá" {
    fmt.Printf("%d: %c (%d)\n", i, r, r)
    // 0: o (111)
    // 1: l (108)
    // 2: á (225)  <- byte index 2, não 3, porque 'á' é 2 bytes
}

// ARMADILHA: o range faz CÓPIA do valor
type Pessoa struct{ Nome string }

pessoas := []Pessoa{{"Alice"}, {"Bob"}}
for _, p := range pessoas {
    p.Nome = "modificado" // modifica a CÓPIA, não o original!
}
fmt.Println(pessoas[0].Nome) // "Alice" - não mudou!

// CORRETO: use índice para acessar o original
for i := range pessoas {
    pessoas[i].Nome = "modificado" // modifica o original
}

// OU: use ponteiro na slice
pessoas2 := []*Pessoa{{"Alice"}, {"Bob"}}
for _, p := range pessoas2 {
    p.Nome = "modificado" // p é um ponteiro - modifica o original
}

func lerArquivo(caminho string) (string, error) {
    f, err := os.Open(caminho)
    if err != nil {
        return "", err
    }
    defer f.Close() // vai executar quando lerArquivo retornar
                    // independente de como retornar (normal ou com erro)

    // ... lê o arquivo ...
    return conteudo, nil
}

func exemploDefers() {
    defer fmt.Println("terceiro") // executado por último
    defer fmt.Println("segundo")
    defer fmt.Println("primeiro") // executado primeiro
    fmt.Println("durante")
}
// Output:
// durante
// primeiro
// segundo
// terceiro

// Armadilha: o valor de i é capturado no momento do defer
for i := 0; i < 3; i++ {
    defer fmt.Println(i) // imprime 2, 1, 0 - não o valor futuro
}

// Para capturar o valor futuro, use closure
for i := 0; i < 3; i++ {
    i := i // cria nova variável i local ao loop
    defer func() {
        fmt.Println(i) // captura a variável do closure
    }()
}

func transacao(db *sql.DB) (err error) {
    tx, err := db.Begin()
    if err != nil {
        return
    }
    defer func() {
        if err != nil {
            tx.Rollback() // faz rollback se houve erro
        } else {
            err = tx.Commit() // faz commit, e se commit falhar,
                              // o erro é propagado pelo named return
        }
    }()

    // ... executa operações ...
    return nil
}

// Função com múltiplos retornos
func dividir(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("divisão por zero")
    }
    return a / b, nil
}

func main() {
    resultado, err := dividir(10, 2)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(resultado) // 5

    // Use _ para descartar valores que não precisa_
_    resultado2, _ := dividir(10, 4)
    fmt.Println(resultado2) // 2.5
}

// Os valores de retorno têm nomes - são variáveis declaradas
func minMax(arr []int) (min, max int) {
    // min e max são inicializadas com zero value
    if len(arr) == 0 {
        return // "naked return" - retorna min e max com seus valores atuais
    }
    min, max = arr[0], arr[0]
    for _, v := range arr[1:] {
        if v < min {
            min = v
        }
        if v > max {
            max = v
        }
    }
    return // retorna min e max
}

// Gerador de IDs sequenciais
func novoGerador() func() int {
    id := 0 // esta variável é capturada pelo closure
    return func() int {
        id++ // modifica a variável capturada
        return id
    }
}

func main() {
    gerarID := novoGerador()
    fmt.Println(gerarID()) // 1
    fmt.Println(gerarID()) // 2
    fmt.Println(gerarID()) // 3

    // Outro gerador tem sua própria variável id independente
    outroGerador := novoGerador()
    fmt.Println(outroGerador()) // 1
}

// PROBLEMA: todas as goroutines capturam a MESMA variável i
funcs := make([]func(), 3)
for i := 0; i < 3; i++ {
    funcs[i] = func() {
        fmt.Println(i) // quando executar, i vale 3 (valor final do loop)
    }
}
for _, f := range funcs {
    f() // imprime 3, 3, 3
}

// SOLUÇÃO 1: crie uma cópia de i dentro do loop
for i := 0; i < 3; i++ {
    i := i // shadowing: nova variável i para cada iteração
    funcs[i] = func() {
        fmt.Println(i) // captura a variável LOCAL, não a do loop
    }
}

// SOLUÇÃO 2: passe como argumento
for i := 0; i < 3; i++ {
    funcs[i] = func(n int) func() {
        return func() { fmt.Println(n) }
    }(i) // chama imediatamente com o valor atual de i
}

// ... antes do tipo indica variádica
// args é uma slice dentro da função
func soma(args ...int) int {
    total := 0
    for _, v := range args {
        total += v
    }
    return total
}

func main() {
    fmt.Println(soma(1, 2, 3))       // 6
    fmt.Println(soma(1, 2, 3, 4, 5)) // 15

    // Expandir uma slice para argumentos variádicos
    numeros := []int{1, 2, 3, 4}
    fmt.Println(soma(numeros...)) // 10 - o ... expande a slice
}

// Tipo de função
type Transformador func(int) int

// Função que recebe função como argumento (higher-order function)
func aplicar(numeros []int, fn Transformador) []int {
    resultado := make([]int, len(numeros))
    for i, v := range numeros {
        resultado[i] = fn(v)
    }
    return resultado
}

func dobrar(n int) int { return n * 2 }
func quadrado(n int) int { return n * n }

func main() {
    numeros := []int{1, 2, 3, 4, 5}

    dobrados := aplicar(numeros, dobrar)
    fmt.Println(dobrados) // [2 4 6 8 10]

    quadrados := aplicar(numeros, quadrado)
    fmt.Println(quadrados) // [1 4 9 16 25]

    // Função anônima inline
    triplicados := aplicar(numeros, func(n int) int { return n * 3 })
    fmt.Println(triplicados) // [3 6 9 12 15]
}

// Definição de struct
type Usuario struct {
    ID    int
    Nome  string
    Email string
    Ativo bool
}

// Inicialização
u1 := Usuario{
    ID:    1,
    Nome:  "Alice",
    Email: "[email protected]",
    Ativo: true,
}

// Inicialização posicional (não recomendada - frágil a mudanças)
u2 := Usuario{1, "Bob", "[email protected]", false}

// Zero value de struct
var u3 Usuario // todos os campos com zero values

// Convenção Go: campos exportados começam com maiúscula
// campos não exportados começam com minúscula
type conta struct {
    ID    int    // exportado
    saldo float64 // não exportado (privado ao pacote)
}

type Retangulo struct {
    Largura float64
    Altura  float64
}

// Método com value receiver
// Recebe UMA CÓPIA do Retangulo
func (r Retangulo) Area() float64 {
    return r.Largura * r.Altura
}

// Método com pointer receiver
// Recebe o PONTEIRO para o Retangulo - pode modificar
func (r *Retangulo) Escalar(fator float64) {
    r.Largura *= fator
    r.Altura *= fator
}

func main() {
    ret := Retangulo{Largura: 10, Altura: 5}
    fmt.Println(ret.Area())    // 50

    ret.Escalar(2)
    fmt.Println(ret.Area())    // 200
}

// Convenção: seja consistente
// Se um método usa pointer receiver, todos devem usar
type Ponto struct{ X, Y float64 }

// INCONSISTENTE (não faça isso):
func (p Ponto) String() string { ... }    // value
func (p *Ponto) Mover(dx, dy float64) { ... } // pointer

// CONSISTENTE:
func (p *Ponto) String() string { ... }   // pointer
func (p *Ponto) Mover(dx, dy float64) { ... } // pointer

// Animal base
type Animal struct {
    Nome string
}

func (a Animal) Respirar() {
    fmt.Printf("%s está respirando\n", a.Nome)
}

// Cachorro embeds Animal
type Cachorro struct {
    Animal        // embedding - não é herança, é composição
    Raca   string
}

// Cachorro tem um método próprio
func (c Cachorro) Latir() {
    fmt.Printf("%s: Au au!\n", c.Nome) // acessa Nome do Animal embedded
}

func main() {
    c := Cachorro{
        Animal: Animal{Nome: "Rex"},
        Raca:   "Labrador",
    }

    c.Respirar() // método promovido do Animal
    c.Latir()    // método próprio do Cachorro
    c.Animal.Respirar() // acesso explícito também funciona
}

// Java
class Cachorro implements Animal { ... }

// Define a interface
type Barulhento interface {
    FazerBarulho() string
}

// Cachorro não declara que implementa Barulhento
// mas implementa o método FazerBarulho
type Cachorro struct{ Nome string }
func (c Cachorro) FazerBarulho() string { return "Au!" }

// Gato também, sem declarar nada
type Gato struct{ Nome string }
func (g Gato) FazerBarulho() string { return "Miau!" }

// Qualquer tipo com FazerBarulho() string satisfaz Barulhento
func fazerBarulhos(animais []Barulhento) {
    for _, a := range animais {
        fmt.Println(a.FazerBarulho())
    }
}

func main() {
    animais := []Barulhento{
        Cachorro{Nome: "Rex"},
        Gato{Nome: "Mimi"},
    }
    fazerBarulhos(animais) // Au!, Miau!
}

// A interface io.Writer da biblioteca padrão é apenas:
type Writer interface {
    Write(p []byte) (n int, err error)
}

// Qualquer coisa que implementa Write() satisfaz io.Writer:
// os.File satisfaz
// bytes.Buffer satisfaz
// net.Conn satisfaz
// http.ResponseWriter satisfaz
// Seus próprios tipos também podem satisfazer

// Ruim: interface gigante - poucos tipos satisfazem isso
type Repositorio interface {
    Criar(u Usuario) error
    Buscar(id int) (Usuario, error)
    Listar() ([]Usuario, error)
    Atualizar(u Usuario) error
    Deletar(id int) error
    BuscarPorEmail(email string) (Usuario, error)
    // ... mais 10 métodos
}

// Melhor: interfaces focadas
type Criador interface {
    Criar(u Usuario) error
}

type Buscador interface {
    Buscar(id int) (Usuario, error)
}

type RepositorioCompleto interface {
    Criador
    Buscador
    // ...
}
// A função que só precisa criar aceita Criador - mais testável, mais flexível

// interface{} aceita qualquer tipo - é o "any" do Go
// A partir do Go 1.18, "any" é um alias para interface{}
func imprimirQualquer(v interface{}) {
    fmt.Printf("tipo: %T, valor: %v\n", v, v)
}

// Ou com any (preferível no Go moderno)
func imprimirQualquer(v any) {
    fmt.Printf("tipo: %T, valor: %v\n", v, v)
}

imprimirQualquer(42)       // tipo: int, valor: 42
imprimirQualquer("hello")  // tipo: string, valor: hello
imprimirQualquer([]int{1}) // tipo: []int, valor: [1]

// Type assertion: extrai o valor concreto de uma interface
var i interface{} = "hello"

// Forma "segura" - retorna valor e ok
s, ok := i.(string)
if ok {
    fmt.Println(s) // "hello"
}

// Forma "unsafe" - panic se o tipo não bater
s2 := i.(string) // ok
n := i.(int)     // panic! i não é int

// Type switch: pattern mais idiomático para múltiplos tipos
func processar(v interface{}) string {
    switch val := v.(type) {
    case nil:
        return "nulo"
    case int:
        return fmt.Sprintf("inteiro: %d", val)
    case float64:
        return fmt.Sprintf("float: %.2f", val)
    case string:
        return fmt.Sprintf("string: %q", val)
    case []int:
        return fmt.Sprintf("slice de int com %d elementos", len(val))
    default:
        return fmt.Sprintf("tipo desconhecido: %T", val)
    }
}

// ARMADILHA CLÁSSICA
type MeuErro struct{ Msg string }
func (e *MeuErro) Error() string { return e.Msg }

func podeRetornarNil() error {
    var err *MeuErro = nil // ponteiro nil para MeuErro
    return err             // retorna como interface error
    // MAS: a interface retornada NÃO é nil!
    // Ela tem tipo (*MeuErro) com valor nil
}

func main() {
    err := podeRetornarNil()
    if err != nil {
        fmt.Println("erro!") // isso EXECUTA - err não é nil!
    }
}

func podeRetornarNil() error {
    // ...
    if semErro {
        return nil // retorna interface nil diretamente
    }
    return &MeuErro{"algo deu errado"}
}

var a [5]int          // array de 5 ints - zero value
b := [3]string{"a", "b", "c"}
c := [...]int{1, 2, 3, 4} // ... infere o tamanho (4)

fmt.Println(len(b)) // 3

// [3]string e [4]string são TIPOS DIFERENTES
// Não são compatíveis entre si

// Arrays são copiados quando atribuídos ou passados para funções
x := [3]int{1, 2, 3}
y := x   // cópia completa
y[0] = 99
fmt.Println(x[0]) // 1 - não mudou

Slice internamente:
┌──────────────────────┐
│ ptr → array subjacente│  ponteiro para o array
│ len = comprimento     │  quantos elementos são visíveis
│ cap = capacidade      │  quantos elementos o array tem no total
└──────────────────────┘

// Criando slices
s1 := []int{1, 2, 3}         // slice literal
s2 := make([]int, 5)          // len=5, cap=5, zeros
s3 := make([]int, 3, 10)      // len=3, cap=10

fmt.Println(len(s1), cap(s1)) // 3, 3
fmt.Println(len(s2), cap(s2)) // 5, 5
fmt.Println(len(s3), cap(s3)) // 3, 10

// Slicing: cria um novo slice que aponta para o mesmo array
a := []int{1, 2, 3, 4, 5}
b := a[1:3]  // b = [2, 3], len=2, cap=4 (do índice 1 ao fim do array)
b[0] = 99
fmt.Println(a) // [1, 99, 3, 4, 5] - MODIFICOU O ORIGINAL!