Como o intervalo Golang simplifica a iteração da estrutura de dados

A iteração é uma funcionalidade chave da maioria das linguagens de programação. Essencialmente, iteração significa repetir um bloco de código em uma ordem específica, geralmente até que ocorra um evento ou resultado específico. Você pode iterar vários tipos de estrutura de dados, como matrizes, fatias, strings, mapas e canais.

Normalmente, você itera com a ajuda de um loop, como um loop for. Junto com o loop for vem uma palavra-chave especial que você pode usar para simplificar a iteração por meio de estruturas de dados. Em Golang, essa palavra-chave é “intervalo”; ele fornece o índice e o valor de cada elemento da estrutura de dados durante a iteração.

Em outras palavras, quando você usa a palavra-chave range com um loop for, ela itera por todas as entradas da estrutura de dados e, para cada entrada, atribui valores de iteração às variáveis ​​de iteração correspondentes (desde que estejam presentes), então executa o bloco.

Mas qual é a diferença entre um loop for com e sem a palavra-chave range? Essencialmente, uma cláusula range em um loop for torna esses loops mais limpos e fáceis de ler. Isso pode ser especialmente importante quando você começa a usar o Go pela primeira vez, porque os loops for podem ficar um pouco complicados.

Vamos dar uma olhada em um exemplo de loop for que itera por uma fatia.

Lembra o que é uma fatia? Se não, eu te protejo. Uma fatia é semelhante a uma matriz, com a diferença de que uma fatia é dimensionada dinamicamente, para que possa aumentar e diminuir conforme necessário. A sintaxe de uma fatia é assim:

slice_name := ()datatype{values}

Aqui está um exemplo de como isso pode ser:

myslice := ()int{1,2,3}

Para esse propósito, existem duas funções que você deseja conhecer: len() e cap(). O len() função retorna o número de elementos na fatia e o cap() A função retorna o número pelo qual os elementos da fatia podem aumentar ou diminuir.

Chega de fatias — vamos voltar ao exemplo do loop for. Criaremos um loop for que percorre uma lista de distribuições Linux e as imprime. O código fica assim:

No código acima, inicializamos uma fatia chamada “distros” como uma lista de strings. Essas strings são “Ubuntu”, “Fedora”, “Pop!_OS”, “Linux Mint”, “elementaryOS” e “openSUSE”. Em nosso loop for, inicializamos a variável eu para 0, certifique-se de que eu é menor que o comprimento do distros matriz e incremento eu por 1 no final de cada iteração.

E se usarmos a palavra-chave range para este loop?

Primeiro, a sintaxe do loop for-range é assim:

for key, value := range collection {
    // body of the loop
}

Lembra do loop for acima? Usando a palavra-chave range, isso mudaria para:

for i, distros := range distros {
                fmt.Println(i, distros)
        }

A saída para ambos os blocos de código seria exatamente a mesma:

0Ubuntu
1Fedora
doisPop!_OS
3Linux Mint
4 sistema operacional elementar
5abertoSUSE

Como você pode ver, usar a palavra-chave range simplifica e limpa o código. A diferença é que o loop for-range possibilita acessar pares de valores-chave e até mesmo alterá-los.

Mas como? Deixe-me mostrar-lhe um exemplo. Vamos fingir que temos uma empresa com dois níveis de funcionários: júnior e sênior. O que queremos fazer é dar aos nossos funcionários seniores um bônus de US$ 10.000. Usaremos um loop for-range para fazer isso acontecer.

Vamos usar dois funcionários, Bob e Fred. Ambos ganham US$ 100 mil, mas como Fred é um funcionário sênior, ele recebe um bônus de US$ 10 mil. O primeiro bloco do nosso código é bastante simples:

package main

import "fmt"

type Account struct {
     Name string
     Type string
     Balance int
 }

Agora criamos uma função que definirá Bob como um funcionário júnior que ganha US$ 100.000 e Fred como um funcionário sênior que ganha o mesmo salário base. Essa parte do código se parece com isto:

func main() {
    acts := ()Account{
        {"Bob", "junior", 100_000},
        {"Fred", "senior", 100_000},
   }

• Nome: Bob ou Fred
• Tipo: júnior ou sênior
• Saldo: 100.000

Até agora tudo bem.

Agora criaremos um loop for-range que examina Type. Se alguma entrada for “sênior”, 10.000 serão adicionados ao Saldo.

for i := range acts {
     if acts(i).Type == "senior" {
         acts(i).Balance += 10_000
     }

Veja como funciona o bloco acima:

1. for i := range acts: Um loop que itera sobre os índices do nosso atos coleção.
2. if acts(i).Type == "senior": Verifica se o campo Type do elemento no índice eu dentro do atos coleção é igual a “sênior”.
3. acts(i).Balance += 10_000: Se a condição for verdadeira, o campo Balance do elemento é incrementado no índice eu por 10.000.

Por fim, imprimimos o atos coleções:

fmt.Println(acts)

O código inteiro fica assim:

<script src="https://gist.github.com/lovemycodesnippets/0033d44be4e41c4892d388f1acdb5c35.js"></script>

Se executarmos o procedimento acima, a saída será:

({Bob junior 100000} {Fred senior 110000})

Sucesso! Fred recebeu um bônus de 10 mil. Esperemos que Bob não descubra.

E esse é o básico do uso da palavra-chave range em Go. Para saber mais sobre cláusulas de intervalo, verifique a documentação oficial do Go.

A postagem Como o intervalo Golang simplifica a iteração da estrutura de dados apareceu pela primeira vez em The New Stack.