Golang Slice

Este artigo mergulhará profundamente no trabalho com fatias na linguagem de programação Go.

Todos estamos familiarizados com as matrizes, em Go ou em outras linguagens de programação. Uma matriz é uma coleção de elementos de um tipo de dados relacionado (dependendo). Em Go, uma matriz só pode segurar elementos de um tipo semelhante. As matrizes têm um comprimento fixo e não podem crescer ou encolher quando o tamanho é definido.

Uma fatia é uma visão de tamanho dinamicamente dos elementos de uma matriz. Uma fatia é muito flexível, permitindo que você redimensione. No entanto, o redimensionamento deve permanecer sob a capacidade da matriz subjacente.

Declarando uma fatia

Podemos declarar uma fatia usando uma sintaxe simples, como mostrado abaixo:

var slice_name [] dados _type

Na sintaxe acima, começamos especificando o slice_name seguido de um par de colchetes e o tipo de dados para a fatia.

Você notará que a declaração de fatia é muito semelhante à de uma matriz. No entanto, não especificamos um tamanho para uma fatia.

Criar fatia - Método 1

Existem dois métodos para criar uma fatia em Go. O primeiro é usar o formato literal. Isso é intimamente semelhante ao mostrado na sintaxe acima.

Por exemplo, o código abaixo cria uma fatia chamada my_slice:

Pacote principal
importar "fmt"
funcmain ()
var my_slice = [] int 1, 2, 3, 4, 5, 6
fmt.Println (my_slice)

O exemplo acima cria uma fatia do tipo int com valores padrão. Se você não deseja usar o método VAR de declaração variável, poderá usar a sintaxe abaixo:

my_slice: = [] int 1,2,3,4,5,6

O método acima é conhecido como literal de fatia.

Criar fatia - Método 2

O segundo método para criar uma fatia em Go é usar a função make.

A sintaxe é como:

func make ([] t, len, cap) [] t

A função leva um tipo de dados, comprimento e capacidade neste caso. A função alocará uma matriz com o tamanho especificado pelo parâmetro de capacidade. A função retorna uma referência de fatia.

Para vê -lo na prática, veja abaixo:

slice_var: = make ([] int, 10)
fmt.Println (slice_var)

Este exemplo declara uma fatia do tamanho 10 e do tipo int. A saída resultante é uma fatia de 0 valores.

[0 0 0 0 0 0 0 0]

Você pode atribuir os valores à fatia usando a notação de índice.

Para atribuir um valor no índice 1, podemos fazer:

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

O código acima deve retornar:

[10 0 0 0 0 0 0 0]

Observe que o elemento no índice 0 é atualizado para refletir o novo valor.

Propriedades da fatia

Existem duas propriedades importantes de uma fatia com a qual você deve estar familiarizado. O comprimento e a capacidade.

A duração da fatia refere -se ao número total de elementos mantidos pela fatia, enquanto a capacidade refere -se ao número de elementos definidos pela matriz subjacente. Isso é contado desde o primeiro elemento da fatia.

Para obter o comprimento e a capacidade de uma fatia, você pode usar os métodos Len () e Cap (), respectivamente.

Um exemplo é como demonstrado abaixo:

Pacote principal
importar "fmt"
funcmain ()
varmy_slice = [] int 1, 2, 3, 4, 5, 6
fmt.Println ("comprimento:", len (my_slice))
fmt.Println ("Capacidade:", Cap (my_slice))

O código de exemplo acima deve retornar o comprimento e a capacidade da fatia como:

Ength: 6
Capacidade: 6

Vá fatiando de índice

Você sabia que podemos formar uma fatia a partir de fatias existentes?

Podemos conseguir isso especificando um índice limitado com um limite baixo e alto. Por exemplo, para criar uma nova fatia com elementos do índice 1 a 5:

new_slice: = my_slice [1: 5]
fmt.Println (new_slice)
A fatia resultante se torna:
[2 3 4 5]

Iteração de fatia

Podemos iterar sobre uma matriz usando o clássico para um loop.

Por exemplo:

Pacote principal
importar "fmt"
funcmain ()
varmy_slice = [] string "python", "javascript", "go", "rust", "dart"
fori, item: = rangemy_slice
fmt.Println (i, item)

No exemplo acima, usamos uma declaração de loop e alcance para iterar sobre o índice e o item da fatia. A saída resultante:

0 python
1 JavaScript
2 vá
3 ferrugem
4 dardo

Se você não deseja usar a instrução RANGE para loop sobre a fatia, poderá usar o comprimento da fatia como:

para i: = 0; eu < len(my_slice); i++
fmt.Println (my_slice [i])

O exemplo acima retornará uma saída semelhante a usar o Range Construct.

Vá copiar elemento

O método de cópia permite copiar elementos de uma fatia para outra. Considere o exemplo abaixo:

funccopy_slice ()
slice_1: = [] int 1, 2, 3, 4, 5
slice_2: = [] int 6, 7, 8, 9, 10
new_slice: = copy (slice_1, slice_2)
fmt.Printf ("%d Elements copiados", new_slice)

A função retornará o número total de elementos copiados.

Fatia multidimensional

Você também pode criar uma fatia multidimensional. Basicamente significa uma fatia de fatias. Um exemplo é como mostrado:

funcmulti_slice ()
Multi_slice: = [] [] int
1, 2,
3, 4,
5, 6,
7, 8,

fmt.Println (multi_slice)

O exemplo acima deve imprimir uma fatia multidimensional como:

[[1 2] [3 4] [5 6] [7 8]]

Para acessar elementos em uma matriz multidimensional, você pode usar índices como:

fmt.Println (multi_slice [0] [0])

A sintaxe acima retorna o primeiro elemento na primeira fatia.

Conclusão

Este guia ajuda você com o básico de trabalhar com fatias em Go. Embora não possamos esgotar fatias no escopo deste tutorial, ele deve começar.