tudo bem, vamos mergulhar em um dos recursos mais versáteis e essenciais do Go - Slices. Se você vem de outro idioma, pode pensar em fatias semelhantes às matrizes. E, sim, eles têm algumas semelhanças, mas as fatias trazem muito mais poder, flexibilidade e magia específica para Go para a mesa! ?

O que é uma fatia, afinal? ?

em Go, as fatias são um tipo que permite trabalhar com listas de elementos (como uma matriz), mas são dinâmicos, o que significa que podem crescer e encolher conforme necessário. Não há necessidade de especificar um comprimento fixo como você faria com uma matriz. Eles são apoiados por matrizes sob o capô, mas você obtém muito mais controle. Pense neles como um irmão mais frio e mais flexível das matrizes.

Então, uma fatia no Go é na verdade uma "janela" sobre uma matriz subjacente. Você pode alterar o tamanho desta janela cultivando ou encolhendo - e é tão suave quanto cortar um pedaço de bolo. ?

Criando uma fatia?
Criar uma fatia é bem direto:

// Using a literal
numbers := []int{1, 2, 3, 4, 5}

// Using the make function
sliceOfStrings := make([]string, 5) // a slice of 5 strings, each 

inicializado para uma string vazia
Com a marca, você está dizendo para criar uma fatia de um certo comprimento, mas apoiado por uma matriz que ele gerencia para você. Portanto, você não precisa se preocupar com os detalhes da alocação de memória. ?

Comprimento e capacidade?

dois conceitos cruciais em fatias são comprimentos e capacidade. O comprimento é o número de elementos atualmente na fatia, enquanto a capacidade é o número total de elementos que ele pode reter antes que precise redimensionar.

numbers := []int{1, 2, 3}
fmt.Println(len(numbers)) // 3
fmt.Println(cap(numbers)) // 3 (same as length here)

Quando você começar a anexar itens, irá dobrar a capacidade sempre que ele preencher, para que você não precise se preocupar em bater um teto.

numbers = append(numbers, 4)
fmt.Println(len(numbers)) // 4
fmt.Println(cap(numbers)) // probably 6 now, depending on Go’s growth 

padrão
Anexando as fatias: Go's Integrat Magic? ✨
Adicionar elementos a uma fatia é tão fácil quanto a torta com a função Apênd de Go. Você pode adicionar um ou mais elementos de uma só vez, e irá lidar com todas as coisas de redimensionamento e memória para você.

numbers := []int{1, 2, 3}
numbers = append(numbers, 4, 5, 6) // Adding multiple elements at once
fmt.Println(numbers) // [1 2 3 4 5 6]

Este recurso de resistência automática torna as fatias super úteis, especialmente se você não souber o tamanho da sua lista.

Corte uma fatia ??

cortar no go é na verdade onde as coisas ficam realmente divertidas. Você pode criar uma "sublice" de uma fatia existente sem copiar os elementos.

numbers := []int{10, 20, 30, 40, 50}
subSlice := numbers[1:4] // Just takes a "slice" of the original slice
fmt.Println(subSlice) // [20 30 40]

em números [1: 4], o primeiro índice (1) é inclusivo e o último índice (4) é exclusivo. Você acaba com os elementos nas posições 1, 2 e 3, mas não 4.

Este sublice ainda compartilha a mesma matriz subjacente com a fatia original, então as alterações em um afetarão a outra:

subSlice[0] = 25
fmt.Println(numbers) // [10 25 30 40 50]
fmt.Println(subSlice) // [25 30 40]

Para evitar alterações não intencionais, você pode usar a cópia para criar uma versão independente da fatia:

newSlice := make([]int, len(subSlice))
copy(newSlice, subSlice)

Mudança de capacidade com o Append?

Se você precisar de uma fatia maior que sua capacidade atual, o Append criará automaticamente uma nova e maior matriz em segundo plano e copiará tudo. Isso é incrivelmente eficiente e uma grande parte do que torna as fatias impressionantes. Quando o Append cria uma nova matriz, ele aloca o dobro da capacidade anterior - dando espaço para crescer!

Fatiando e eficiência de memória?

Aqui está um pouco em segredo: embora o fatiamento seja super poderoso, às vezes pode levar a vazamentos de memória se você não tomar cuidado. Como as fatias se referem à mesma matriz subjacente, a matriz pode permanecer na memória, mesmo que você esteja usando apenas uma pequena parte dela.

Por exemplo:

bigSlice := make([]int, 1_000_000) // A big slice with a lot of elements
smallSlice := bigSlice[:10]        // A tiny slice from it

// Now `smallSlice` only uses 10 elements, but the underlying array with
// 1,000,000 elements is still in memory! ?

Em casos como este, é melhor usar cópia para criar uma fatia genuinamente independente que contém apenas os dados necessários, liberando o restante da memória.

miniSlice := make([]int, len(smallSlice))
copy(miniSlice, smallSlice) // Now `miniSlice` is completely separate!

Fatias multidimensionais ??

precisa de mais de uma dimensão? Você também pode criar fatias multidimensionais! Isso pode ser útil para coisas como grades ou mesas. Basta declarar uma fatia de fatias:

matrix := [][]int{
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9},
}
fmt.Println(matrix) // [[1 2 3] [4 5 6] [7 8 9]]

Cada "linha" é uma fatia em si, para que você possa cultivá -los independentemente, se necessário.

matrix[0] = append(matrix[0], 10)
fmt.Println(matrix) // [[1 2 3 10] [4 5 6] [7 8 9]]

A fatia nula?

uma fatia nula é simplesmente uma fatia que ainda não foi inicializada. Tem comprimento e capacidade zero, mas ainda podem ser usados ​​com funções como o Append sem entrar em pânico.

var nilSlice []int // Declared, but not initialized
fmt.Println(len(nilSlice)) // 0
fmt.Println(cap(nilSlice)) // 0

Quando você anexa a uma fatia nula, vá apenas inicializa para você automaticamente. É um truque interessante ter a manga.

armadilhas e práticas recomendadas?
Observe a memória compartilhada: lembre -se, as fatias compartilham memória com a matriz original. Isso é ótimo para o desempenho, mas seja cauteloso ao cortar partes de uma grande matriz para evitar manter dados desnecessários na memória.

Cuidado com o redimensionamento: Quando você acrescenta, o GO pode precisar criar uma nova matriz subjacente se a capacidade atual estiver cheia. Isso pode ser mais eficiente do que fazer muitos pequenos redes, mas esteja ciente da sobrecarga se você estiver lidando com grandes conjuntos de dados.

Evite a otimização prematura: Go lida com muitas alocação de memória e redimensionamento automaticamente com fatias. Muitas vezes, tentar microgerenciar esses detalhes pode acabar tornando seu código mais confuso e menos eficiente. Confiança da Slice Mechanics para fazer a coisa certa na maioria dos casos.