Go Academy · Aula

Slices: listas dinâmicas

make, append, copy, len e cap

Slices: listas dinâmicas é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

O que é uma fatia

Uma fatia é uma visão de tamanho dinâmico sobre um vetor subjacente. Ela tem três componentes: um ponteiro para o vetor, um comprimento e uma capacidade.

Fatias são tipos de referência — várias fatias podem compartilhar o mesmo vetor subjacente
A maior parte do trabalho semelhante ao de listas em Go usa fatias, não vetores

Literais de fatia e make

Crie fatias com um literal ou make:

package main
import "fmt"

func main() {
    nums := []int{1, 2, 3, 4, 5}      // literal
    strs := make([]string, 3)          // len=3, cap=3, zero values
    buf  := make([]byte, 0, 64)        // len=0, cap=64
    fmt.Println(nums, strs, len(buf), cap(buf))
}

len e cap

len retorna a quantidade de elementos atualmente na fatia. cap retorna a capacidade do vetor subjacente a partir do ponteiro inicial da fatia.

package main
import "fmt"

func main() {
    s := make([]int, 3, 8)
    fmt.Println(len(s)) // 3
    fmt.Println(cap(s)) // 8
}

append: aumentando uma fatia

append adiciona elementos a uma fatia, alocando um novo vetor subjacente quando a capacidade é excedida:

package main
import "fmt"

func main() {
    s := []int{1, 2, 3}
    s = append(s, 4, 5)
    s = append(s, []int{6, 7, 8}...)
    fmt.Println(s) // [1 2 3 4 5 6 7 8]
}

Criando uma subfatia

Use a sintaxe [low:high] para criar uma subfatia (que compartilha o vetor subjacente):

package main
import "fmt"

func main() {
    a := []int{0, 1, 2, 3, 4, 5}
    b := a[1:4]   // [1 2 3]
    c := a[:3]    // [0 1 2]
    d := a[3:]    // [3 4 5]
    fmt.Println(b, c, d)
}

copy: fatias independentes

copy copia elementos entre fatias e retorna a quantidade copiada. O destino e a origem não compartilham memória:

package main
import "fmt"

func main() {
    src := []int{1, 2, 3}
    dst := make([]int, len(src))
    n := copy(dst, src)
    dst[0] = 99
    fmt.Println(src, dst, n) // [1 2 3] [99 2 3] 3
}

Fatia nil versus fatia vazia

Uma fatia nil não tem vetor subjacente. Uma fatia vazia tem um vetor subjacente, mas comprimento 0. Ambas têm len == 0:

package main
import "fmt"

func main() {
    var nilSlice []int
    emptySlice  := []int{}
    fmt.Println(nilSlice  == nil) // true
    fmt.Println(emptySlice == nil) // false
    fmt.Println(len(nilSlice), len(emptySlice)) // 0 0
    nilSlice = append(nilSlice, 1) // safe!
}

Excluindo um elemento

Go não tem uma função integrada delete para fatias. A abordagem idiomática usa append:

package main
import "fmt"

func main() {
    s := []int{1, 2, 3, 4, 5}
    i := 2 // delete index 2
    s = append(s[:i], s[i+1:]...)
    fmt.Println(s) // [1 2 4 5]
}

Inserindo um elemento

Insira na posição i combinando append e uma operação de fatiamento:

package main
import "fmt"

func main() {
    s := []int{1, 2, 4, 5}
    i := 2
    s = append(s[:i+1], s[i:]...)
    s[i] = 3
    fmt.Println(s) // [1 2 3 4 5]
}

Armadilha das fatias: vetor subjacente compartilhado

Subfatias compartilham o vetor subjacente — modificar uma afeta a outra até que ocorra uma realocação:

package main
import "fmt"

func main() {
    a := []int{1, 2, 3, 4}
    b := a[:2]   // shares backing array
    b[0] = 99
    fmt.Println(a) // [99 2 3 4] — a is changed!
}

Verificação rápida

O que append retorna?

Recapitulação: fatias

Principais aprendizados:

Fatias = ponteiro + len + cap; elas envolvem vetores
Use make para pré-alocar capacidade
Sempre atribua o resultado de append
copy cria fatias independentes
Esteja atento a vetores subjacentes compartilhados em subfatias

Exercício prático

Crie uma fatia de 5 inteiros com make, acrescente mais três valores, depois copie-a para uma nova fatia e modifique a cópia sem afetar a original. Imprima ambas.

Perguntas Frequentes

A aula “Slices: listas dinâmicas” é grátis?

Sim — o texto completo de “Slices: listas dinâmicas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Slices: listas dinâmicas”?

make, append, copy, len e cap Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Slices: listas dinâmicas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy