Golang For Loop Tutorial [With Examples]

Aprenda tudo sobre Golang for loops codificando vários exemplos úteis.

Recentemente, linguagens de programação como Rust, Golang e TypeScript se tornaram super populares entre os desenvolvedores. Se você está interessado em desenvolvimento back-end e DevOps, considere aprender que Golang é uma excelente opção!

Se você é um iniciante aprendendo os fundamentos de uma linguagem de programação, as construções de loop são um dos primeiros conceitos que você deve entender.

Golang fornece apenas a construção de loop for. E aprenderemos sobre loops for e também como emular outros loops usando o loop for.

Vamos começar!

últimas postagens

Sintaxe de Golang For Loop

Em Golang, você pode criar um loop usando a seguinte sintaxe:

for initialization; condition; update {
    // do something
}

Aqui,

inicialização denota a inicialização da variável de loop.
condition é a condição de loop que determina a execução do corpo do loop. Contanto que a condição do loop seja avaliada como verdadeira, as instruções no corpo do loop são executadas. E quando a condição se torna falsa, o controle sai do loop.
update denota a atualização da variável de loop – geralmente um incremento ou um decremento.

💡 Observe como isso é semelhante ao loop C for apenas sem os parênteses.

Aqui está o fluxo de controle em Golang for loops:

Hora de codificar alguns exemplos!⏰ Para codificar junto, você pode usar uma instalação local do Golang ou executar os exemplos no Go Playground.

Exemplos de Golang For Loop

Vamos usar a sintaxe que acabamos de aprender para escrever nosso primeiro loop for. Aqui está um loop for simples que imprime os números de 1 a 5 em etapas de um.

package main

import "fmt"

func main() {
	fmt.Println("For loop:")
	num := 5
	for i := 1; i <= num; i++ {
		fmt.Println(i)
	}
}

Inicializamos a variável de loop i como 1, definimos a condição como i <= 5 e incrementamos a variável de loop em um após cada iteração. E aqui está a saída:

//Output
For loop:
1
2
3
4
5

Vamos escrever outro loop for. Este loop começa em 5 e conta até 1; ele continua até que a variável de loop seja maior ou igual a 1. Portanto, decrementamos a variável de loop em um após cada iteração.

package main

import "fmt"

func main() {
	fmt.Println("For loop:")
	num := 5
	for i := num; i >= 1; i-- {
		fmt.Println(i)
	}
}

E obtemos a saída esperada:

//Output
For loop:
5
4
3
2
1

Qual é o escopo da variável de loop?

O escopo da variável de loop é limitado ao bloco de loop for e não é acessível fora do loop.

Os aplicativos estão realmente gravando a tela do seu iPhone?

Para verificar isso, vamos tentar acessar o valor da variável de loop i fora do loop:

package main

import "fmt"

func main() {
	fmt.Println("For loop:")
	num := 5
	for i := 1; i <= num; i++ {
		fmt.Println(i)
	}
	fmt.Println(i)

}

Como esperado, encontramos um erro que afirma que i é um indefinido (e seu escopo é restrito ao loop for):

// Output
./prog.go:11:14: undefined: i

For Loop Infinito em Golang

Podemos ter infinitos loops em Go? Sim, com certeza podemos!

Se você observar o fluxo de controle do loop for:

O corpo do loop continuará a ser executado enquanto a condição for avaliada como verdadeira.
Quando a condição se torna falsa, o controle sai do loop.
Portanto, se a condição nunca se tornar falsa (ou for sempre verdadeira), teremos um loop infinito.

Mas você também pode usar o loop for sem inicialização, condição e atualização – sem incorrer em erros de sintaxe. Portanto, se você puder fazer o loop rodar infinitamente, mesmo usando uma construção de loop for como esta:

package main

import "fmt"

func main() {
	for {
	   fmt.Println("running...")
	}
}

//Output
running...
running...
running...
running...
running...
//and it goes on forever!

Neste exemplo, definimos a variável num como 5. E a condição do loop é num >= 5. Portanto, o loop é executado desde que num seja maior ou igual a zero.

package main

import "fmt"

func main() {
	num := 5
	for num > 0 {
		fmt.Println(num)
	}
}

Como o valor de num nunca muda, a condição sempre é avaliada como verdadeira e o loop é executado para sempre!

//Output
5
5
5
5
5
5
//and it goes on forever!

Todo Golang tem apenas a construção de loop for, podemos tentar emular os loops while e do-while usando loops for. Então vamos aprender como fazer!

Crie um concurso de brindes usando essas 14 ferramentas

Emulando While Loop usando For Loop

O loop while geralmente assume a seguinte forma:

// initialize looping var
while (condition){
    // do something
    // update looping var
}

Se você se lembra, no primeiro loop for infinito escrevemos: usamos o seguinte loop for – sem inicialização, condição e atualização.

for {
// the simplest infinite loop
}

Assim, podemos modificar o loop for para conter apenas a condição (na seguinte forma) para emular o loop while:

//initialize looping var
for condition {
 // do something
 // update looping var
}

Aqui está o loop while equivalente ao primeiro loop for que escrevemos:

package main

import "fmt"

func main() {
	fmt.Println("Emulating while loop")
	num := 5
	for num > 0 {
		fmt.Println(num)
		num--
	}
}

//Output
Emulating while loop
5
4
3
2
1

Emulando loop Do-While usando For Loop

Se você codificou em uma linguagem como C, sabe que a construção do loop do-while tem a seguinte forma:

// initialize looping var
do {
//something
// update looping var
} while(condition);

A principal diferença entre loop while e do while é que o loop while verifica a condição ao entrar no loop. O loop do-while, por outro lado, verifica a condição ao sair do loop.

Portanto, em um loop while, se a condição for avaliada como falsa, o corpo do loop nunca será executado. No entanto, em um loop do-while, o corpo do loop é executado mesmo se a condição for avaliada como falsa.

Usando essas informações, podemos emular o comportamento de um loop do-while:

Escreva um loop for infinito
Use uma instrução condicional if com a condição correta para sair do loop

Digamos que você queira escrever um loop do-while onde a condição para executar o corpo do loop é num < 0. Portanto, você pode escrever um loop for e sair do loop se num >= 0.

package main

import "fmt"

func main() {
	fmt.Println("Emulating do-while loop")
	num := 5
	for {
		fmt.Println("loop runs...")
		if num >= 0 {
			break
		}
	}
}

💡 Observe que executar o loop if num < 0 e sair do loop if num >= 0 são condições equivalentes.

Embora a condição num > 0 seja inicialmente falsa (num é 5), o corpo do loop é executado uma vez, emulando um loop do-while.

//Output
Emulating do-while loop
loop runs...

Percorrendo Arrays Usando For Loop

Ao percorrer arrays em Golang usando um loop for e um intervalo, você pode acessar os índices e os elementos. Isso funciona de maneira semelhante à função enumerate em Python.

5 maneiras de liberar memória/RAM em um Mac

Aqui, criamos numArray, um array de inteiros. E percorra-o usando um loop for:

package main

import "fmt"

func main() {
	fmt.Println("Looping through an array")
	numArray := []int{3, 7, 0, 10, 8, 9}
	for idx, num := range numArray {
		fmt.Println("At index", idx, ": ", num)
	}
}

Como visto, podemos acessar o índice e o elemento em cada índice simultaneamente:

//Output
Looping through an array
At index 0 :  3
At index 1 :  7
At index 2 :  0
At index 3 :  10
At index 4 :  8
At index 5 :  9

Usando adiar em Golang For Loop

Em Golang, você pode usar a palavra-chave defer para adiar chamadas de função.

Embora usado em aplicativos como limpeza de recursos e tratamento de erros, pode ser útil entender como usar defer dentro de um loop for. Vamos ver o que acontece quando usamos defer dentro do loop for para adiar as chamadas para a função Println().

package main

import "fmt"

func main() {
	fmt.Println("For loop:")
	num := 5
	for i := 1; i <= num; i++ {
		defer fmt.Println(i)
	}
}

💬 Quando uma chamada de função é adiada, a chamada de função é colocada na pilha e executada na ordem LIFO. Essa execução ocorre somente após o retorno da função que envolve a instrução defer.

Portanto, fmt.Println(5) é executado primeiro e fmt.Println(1) é executado por último:

//Output
For loop:
5
4
3
2
1

Conclusão

Aqui está um resumo do que você aprendeu neste tutorial:

Em Golang, você pode criar loops for com a sintaxe: for initialization; doença; atualização { //corpo do loop}.
O fluxo de controle do loop for é bem simples. A variável de loop é inicializada uma vez, a condição de procura determina se deve ou não executar o corpo do loop e a atualização refere-se à atualização da variável de loop após cada iteração.
O escopo da variável de loop é limitado ao corpo do loop e não é acessível fora do loop.
Embora Golang forneça apenas a construção de loop for, você pode emular os comportamentos de loop while e do-while usando loops for.
Algumas outras aplicações do loop for incluem loop através de arrays e adiamento de chamadas de função dentro do corpo do loop for.

Em seguida, aprenda como usar loops for em Python. Boa aprendizagem! 🎉