Conteúdo

Laços de repetição

Laços de repetição, bastante conhecidos como loops (do inglês: laços, ciclos), são estruturas que fazem com que um bloco de código seja executado repetidamente até que uma condição seja atendida.

Por exemplo, se meu cabelo tem shampoo, eu preciso executar a instrução “enxaguar cabelo” até que a condição de parada “quantidade de shampoo no cabelo é 0” seja atendida. A sintaxe dessa frase em Go ficaria parecida com o seguinte:

for cabelo com shampoo; quantidade de shampoo no cabelo é 0; mais uma vez {
    enxaguar cabelo
}

A instrução for

Em Go, os laços de repetição seguem a abordagem de outras linguagens inspiradas em C. Porém, Go vai além no quesito simplicidade. Todas as palavras reservadas que são comuns nas outras linguagens de programação, como while, for, foreach, são sumarizadas em Go simplesmente no comando for.

O for de Go é bastante empoderado! Ele assume algumas variações que correspondem ao comportamento de outras palavras reservadas das outras linguagens. A seguir são apresentadas as variações do for:

Abordagem com contador

Essa instrução funciona como o for da maioria das linguagens.

<mais em breve>

Sintaxe:

for <atribuição inicial>; <expressão condicional>; <incrementos/atribuições> {
    // Ações a serem executadas repetidamente até que
    // a condição seja atendida
}

Exemplo de uso:

package main

import (
	"fmt"
)

func main() {
	for i := 0; i < 10; i++ {
		fmt.Print(i)
	}
}

Abordagem de repetição condicional (como o while das linguagens)

<preencher>

Sintaxe:

for <expressão condicional> {
    // Ações a serem executadas repetidamente até que
    // a condição seja atendida
}

Exemplo de uso:

package main

import (
	"fmt"
)

func main() {
	var seiGo bool = false

	for seiGo == false {
		fmt.Println("Estudo mais um pouco!")
		seiGo = true
	}
	fmt.Println("Agora eu domino o mundo!")
}

Ainda nessa abordagem temos o laço infinito! O while true ou o for(;;) de outras linguagens, em Go ele fica assim:

for {
	// Ao infinito! E além! Ou até a paciência acabar e você fechar o programa...
}

Exemplo no código:

package main

import (
	"fmt"
)

func main() {
	v := 0
	for {
		fmt.Println(v)
		v++
	}
}

Abordagem de iteração em algo composto (com range)

Esse uso é similar ao foreach ou for ... in … de algumas linguagens. O laço continuará a se repetir até percorrer todos os elementos do que vier após a palavra reservada range. “Percorrer os elementos” costuma ser chamado de iterar, e em Go você pode iterar em arrays, slices, strings, maps ou lendo de um channel.

Sintaxe:

for <índice ou chave>, <valor da iteração> := range <tipo iterável> {
    // Instruções a serem executadas em todas as voltas do laço
}

ou

for <índice ou chave> := range <tipo iterável> {
    // Instruções a serem executadas em todas as voltas do laço
}

Exemplos

Exemplo com slice de string:

package main

import (
	"fmt"
)

func main() {
	var meuSliceParaFor = []string{"for com contador", "for condicional", "for em algo", "E acabou a forezada!"}

	for indice, valor := range meuSliceParaFor {
		fmt.Printf("%d - %s\n", indice, valor)
	}

	for indice := range meuSliceParaFor {
		fmt.Printf("%d", indice)
	}
}

Exemplo com map:

package main

import (
	"fmt"
)

func main() {
	var meuMapParaFor = map[string]string{
		"for com contador":     "for i = 0; i < limite; i++",
		"for condicional":      "for algoSerVerdadeiro",
		"for iterando em algo": "for i, valor := range algo",
	}

	for chave, valor := range meuMapParaFor {
		fmt.Printf("%s => %s\n", chave, valor)
	}

	for chave := range meuMapParaFor {
		fmt.Println(chave)
	}
}