Quer um array Golang mais flexível? Experimente uma fatia

Go Arrays na linguagem de programação Go são usados ​​para armazenar vários valores de variáveis ​​do mesmo tipo. Com Arrays, você pode declarar todas as variáveis ​​do mesmo tipo, sem precisar declará-las individualmente.

O que isso significa?

Vamos declarar algumas variáveis ​​em go.

var num1 int = 1
var num2 int = 2
var num3 int = 3
var num4 int = 4
var num5 int = 5

Acima, declaramos cinco números inteiros (para num1, num2, num3, num4 e num5) individualmente. Com um array, podemos declará-los em uma única instrução.

Em vez de usar quatro instruções diferentes, você poderia combiná-las todas no mesmo array. Um array é configurado assim:

var array_name = (length)datatype{values}

Um pouco de explicação:

• var — indica que o que se segue é uma variável.
• array_name — o nome que damos ao array.
• (comprimento) — quantas entradas serão permitidas no array.
• datatype — o tipo de dados (como int ou string).
• valores — os valores atribuídos ao array.

Seguindo nosso exemplo acima, poderíamos escrever o array assim:

var nums = (5)int{1, 2, 3, 4, 5}

Usar arrays não é apenas mais limpo, é mais eficiente e fácil de trabalhar.

Vamos considerar nosso array acima. Definimos o comprimento como cinco, o que significa que só pode haver cinco elementos no total (no nosso caso é 1, 2, 3, 4, 5). Mas e se definissemos apenas 1, 2, 3 e 4 assim:

var nums = (5)int{1, 2, 3, 4}

Vamos adicionar esse código e imprimir nosso array:

package main
import ("fmt")

func main() {
  var nums = (5)int{1,2,3,4}

  fmt.Println(nums)
}

Se executarmos o procedimento acima, a saída seria:

1,2,3,4,0

De onde veio esse 0? Como codificamos o comprimento como cinco, Go adiciona 0 para atender à necessidade do array.

Com Slices, o comprimento pode aumentar e diminuir conforme necessário. Essas fatias podem ser criadas usando o padrão slice_name ()tipo de dados{valores} formato, de uma matriz ou usando o fazer() função.

Vejamos cada método.

O método slice_name()datatype{}

Primeiro, temos o padrão slice_name ()tipo de dados{} método de criação de uma fatia. Seguindo nosso exemplo acima, essa fatia seria:

numslice := ()int{1,2,3,4,5}

Lembrar := in Go é usado para declarações curtas de variáveis ​​(permitindo até mesmo declarar e inicializar variáveis ​​sem declarar explicitamente o tipo de variável).

Com a fatia acima, basicamente informamos Go o comprimento da fatia pelo número de ints que adicionamos ao array. O acima seria semelhante a:

var nums = (5){1,2,3,4,5}

A beleza desse método é que você não precisa definir o comprimento porque ele será definido implicitamente pelo número de objetos no array.

Se você quiser retornar o comprimento e a capacidade de uma fatia, existem duas funções:

• len() – retorna o número de elementos na fatia.
• cap() – retorna o número de elementos para os quais uma fatia pode aumentar ou diminuir.

Aqui está um exemplo dessas duas funções em ação:

package main
import ("fmt")

func main() {
  var nums = (5)int{1,2,3,4,5}
  myslice := ()int{10,11,12,13}
  fmt.Println(nums)
  fmt.Println(myslice)
  fmt.Println(len(myslice))
  fmt.Println(cap(myslice))
}

O que fizemos acima foi definir duas fatias e depois imprimir os elementos dentro de cada uma, bem como o comprimento e a capacidade da segunda fatia. A saída acima seria:

(1 2 3 4 5)
(10 11 12 13)
4
4

O método de matriz

O próximo método é criar uma fatia de um array. Para isso, devemos definir nosso array e então definir os pontos inicial e final de nossa fatia. Isso pode ser muito útil quando temos um array de elementos e queremos criar uma fatia a partir de uma parte desses elementos.

Por exemplo, temos a seguinte matriz:

nums := (10)int{1,2,3,4,5,6,7,8,9,10}

E se precisarmos apenas separar 4,5 e 7 dessa matriz? Para fazer isso, criamos uma fatia do array assim:

myslice := nums(3:6)

Lembre-se, na programação, a contagem começa em 0, então se você contar da esquerda até o terceiro espaço (0,1,2,3) você obtém 4 e até o 6º espaço, você obtém 6… então 4,5,6 .

A função make()

Finalmente, temos a função make(). Digamos que queremos criar uma fatia com comprimento de cinco e capacidade de 10 (o que significa que a fatia conterá cinco elementos, mas pode atingir no máximo 10). Para fazer isso, usaríamos uma linha como esta:

myslice := make(()int, 5, 10)

Ou você pode criar uma fatia sem capacidade definida como esta:

myslice := make(()int, 5)

Vamos ser criativos e imprimir alguns números da nossa fatia. Imprimiremos nossa fatia e depois imprimiremos o comprimento e a capacidade. Para fazer isso, temos que usar alguns verbos (%v e%d para representar valores inteiros e depois adicionar uma quebra de linha.

Nosso novo código fica assim:

package main
import ("fmt")

func main() {
  myslice1 := make(()int, 5, 10)
  fmt.Printf("My Slice = %vn", myslice1)
  fmt.Printf(" The length = %dn", len(myslice1))
  fmt.Printf("The capacity = %dn", cap(myslice1))

A saída do código acima ficaria assim:

Minha fatia = (0 0 0 0 0)
O comprimento = 5
A capacidade = 10

E essa é a essência das fatias Go. Você pode usar fatias para dimensionamento dinâmico de arrays, o que traz conveniência e eficiência incalculáveis ​​ao programador moderno. Saiba mais sobre os trechos da linguagem Go na documentação oficial do Go.

O post Está com fome de um array Golang mais flexível? Experimente uma fatia apareceu pela primeira vez em The New Stack.