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.
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!
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.
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! 🎉