Aula 21
Estrutura de Repetição Enquanto (While Loop) na Linguagem Go (Aula de Golang)
Summary
Aula de Golang: Estrutura de Repetição "While Loop"
Introdução
Na aula de hoje, aprenderemos sobre como implementar estruturas de repetição em Golang, especificamente usando o loop while
, que na linguagem Go é realizado através do loop for
.
Estrutura do Loop
Criando o Arquivo
Criamos um novo arquivo chamado while_loop.go
, com a função main
e importamos o pacote fmt
para imprimir na saída padrão.
Exemplo Prático
Vamos supor que queremos somar as potências de dois até um certo número. O objetivo é calcular a soma de 2, 4, 8, 16, 32, e assim por diante, até atingirmos um limite.
Implementação
-
Declaração da Variável:
- Em primeiro lugar, declaramos uma variável chamada
soma
do tipo inteiro e a inicializamos com0
.
- Em primeiro lugar, declaramos uma variável chamada
-
Uso do Loop
for
:- O loop
for
será usado em vez dowhile
. Para isso, definimos a condição de que a soma deve ser menor que600
.
- O loop
-
Corpo do Loop:
- Dentro do corpo do loop, adicionamos
soma
a si mesma. Isso cria a sequência desejada: 2, 4, 8, etc.
- Dentro do corpo do loop, adicionamos
Exemplo de Códigos:
package main
import "fmt"
func main() {
var soma int = 2
for soma < 600 {
soma = soma + soma // Dobra o valor de soma
}
fmt.Println(soma) // Espera-se imprimir 1024
}
- Execução:
- Após implementar, rodamos o programa e verificamos que o resultado é
1024
, como esperado.
- Após implementar, rodamos o programa e verificamos que o resultado é
Simplificação do Loop
Em Go, podemos simplificar ainda mais a estrutura do loop, omitindo partes da sintaxe:
for soma < 600 {
soma = soma + soma
}
Cuidado com Loops Infinitos
- Demonstração do loop infinito se a condição for removida:
for { soma = soma + soma }
- Este código deve ser usado com cuidado, pois resultará em uma repetição infinita, que pode travar o programa.
Finalizando
- Ao executar o loop infinito, você precisará usar
Ctrl+C
para interromper a execução. - É essencial tomar cuidado com condições em loops para evitar overflows e repetições indesejadas.
Conclusão
Nesta aula, aprendemos que:
- O loop
while
em Go é implementado comfor
. - É importante controlar as condições de repetição para evitar loops infinitos.
- A soma das potências de dois demonstrou funcionalidade prática e útil dos loops.
Até a próxima aula!
Video Transcript
Olá pessoal, estamos de volta com mais uma aula de Golang.
Nesta aula vamos aprender como fazer a repetição, a estrutura de repetição enquanto,
no engoi chamado a while loop.
Então, como é que faz isso no go?
Na verdade, no go a gente vai fazer o enquanto usando for,
tá usando para.
Então você vai usar a mesma palavra-chave, na verdade.
Porque while enquanto é na verdade um caso especial do loop for,
se você tiver loop for dá para fazer todos os outros.
Então vamos aqui começar, já tem um novo arquivo, while loop.go, tá.
Tem uma função main aqui, tem um pacote dentro do pacote main,
importante não é a FMT que eu vou imprimir o negócio no console.
Então vamos lá.
Vamos supor que a gente tenha fazer o mesmo negócio que a gente fez anteriormente,
no caso vamos armazenar a soma de os números, tá.
Nesse caso eu quero somar o número,
eu quero calcular assim as potências de dois assim,
dois a soma de dois mais quatro mais oito mais dezesseis mais trinta e dois sem por diante, tá.
Então a gente queramos fazer,
queramos somar dois mais quatro mais oito mais dezesseis até um certo número, tá.
Então isso significa que na verdade o dois a primeira potência,
dois a quadrado, dois a cubo assim por diante, tá.
Como é que a gente vai fazer isso usando um loop de enquanto?
Dez a quarta, tá.
Então vamos fazer assim, ó.
Então vamos fazer a primeira variável para armazenar a soma,
vamos chamar var, vamos dar som inteiro, tá bom.
Soma int, um variável de nome soma, tipo int, vamos definir zero.
Aí vamos dar o for, tá.
Agora o for, normalmente tem três partes,
primeiro inicialização, segunda condição, terceiro passo, incrementação.
Então a gente vai aumentar, não vai precisar digitar inicialização
e não vai precisar digitar o passo.
Então a gente vai somar, né, adicionar,
ou desculpa, a soma deve começar para dois,
ah não para zero, porque a gente vai começar do dois, quatro.
Então eu quero somar a soma com a soma, tá.
Por exemplo, a soma é dois, então se eu pegar a soma e adicionar a soma com a soma,
vai ser o quê, quatro.
Agora a soma é quatro, se eu pegar a soma e adicionar a soma com a soma,
vai ser quatro mais quatro, oito, e assim por diante,
então vai dar nesses valores, por isso que vou iniciar o valor de dois.
Agora como esse cara já está iniciado,
eu não preciso ter nenhum aqui, se quiser não precisa ter nenhuma inicialização no for loop,
então você pode escrever nada, só escreve o ponto em vivo, tá.
Aí passa para a condição, quero que você some esses caras
até uma certa condição for falsa, né.
Então eu vou até que a soma seja, ah vamos ver,
enquanto a soma for menor aqui, por exemplo, seis centos,
nós vamos continuar somando.
Nesse caso ele ia fazer o quê, vamos ver.
Se você notar que a soma vai ter aqui valor aqui,
vai até, acho que vai até, eu sei que dois a dez é mil e vinte e quatro,
dois a pouso de nove é quinhentos e doze.
Então se a soma tivesse quinhentos e doze, como ele ia fazer a checar,
e iria dar verdadeiro, iria somar de novo, iria dar mil e vinte e quatro, eu acho, né.
Acho que esse vai ser o valor que a gente vai pegar no final, vamos ver já já.
Então depois da condição você vai dar o quê, a incrementação, mas nesse caso eu não preciso.
Então você pode deixar esse cara em branco, tá.
Aí só abrir o corpo do loop, aí vou dizer soma igual a soma mais soma, tá.
Então inicialmente vai ser dois mais dois, que é quatro, né, vai ser quatro.
Aí depois, né, o soma tá quatro, é quatro é menor que seiscentos, sim.
Então ele vai executar de novo, quatro mais quatro é oito.
Oito menor que seiscentos, sim, executa o corpo da repetição de novo,
oito mais oito é de dezesseis, e assim por diante, né, trinta e dois, sessenta e quatro,
cento e vinte e oito, doiscentos e quarenta e seis, quinhentos e doze, opa, vamos parar aqui, vamos ver.
Quinhentos e doze menor que seiscentos, verdadeiro, executa de novo, soma é soma mais soma,
quinhentos e doze, mais quinhentos e doze, que vai dar mil e vinte e quatro.
Agora mil e vinte e quatro, menor que seiscentos, falso, o que isso é falso, parou de repetir
e continua para o próximo link, não tem nada, na verdade, o programa termina.
Então vamos dar um FMI de frente a LN com o valor da soma, que a gente espera que seja mil e vinte e quatro.
Vamos lá ver no terminal e vou fazer gol run, o while loop ponto gol, então está aqui mil e vinte e quatro.
Ah, não tem que haver de linha porque eu não adicionei o print LN, LN, personal LN de novo, está pronto.
Está bom, então esse é o for loop, fazendo o while, na verdade, o enquanto, usando a construção de for,
então é um caso especial. Agora vou te dar uns detalhes aqui, quando você tem esse caso especial no gol,
você pode tirar essas caras aqui, olha só, você pode tirar esse ponto e vírgula,
daqui o ponto e vírgula do lado direito e só deixa for com a condição somente, e ele vai se tornar o loop de while, tá?
Vamos testar novamente para ver se não teve nenhum problema.
Mil e vinte e quatro, como a gente já esperava. Então é isso, o while, na verdade, é um for na golang,
sem a inicialização e sem o pass.
Está bom, se você quiser simplificar aqui esse clara aqui, é só dizer,
pegue o sinal de while, ponho antes do igual e remover o variável daqui, e ele vai adicionar soma a soma
e armazenar o novo valor na própria variável soma.
Vamos ver se não deu problema, testar novamente.
Está bom?
Então é isso, pessoal. Agora, só para terminar mesmo, o que acontece se você retirar essa condição daqui?
Eu quero te mostrar isso, mas temos que ter muito cuidado e vai dar um loop infinito,
repetição infinita, deixa eu putar o print dentro do loop,
Então, me cuidado, não faça isso se você não souber, porque tem que saber matar o programa porque ele não vai parar.
Então, eu vou tirar essa soma aqui, vou tirar a condição e vou deixar só o for, vamos ver no que dá.
Ele vai adicionar soma e dar o print infinitamente, é o chamado loop infinito, repetição infinita aqui, sem a condição.
Então, deu sinal de interromper no meu caso control C, para poder matar o programa no Linux e Mac terminal.
O que aconteceu?
Mais soma, algo aconteceu que só deu zero, porque só deu zero.
Vamos ver aqui, soma 2, soma mais soma.
Será que o valor deu overflow?
Eu estou rolando.
Acho que deu overflow, vamos ver aqui, pera aí, foi muito rápido.
Deixa eu fazer um break stop para você ver aqui, se a soma for maior que 5 mil, vou dar o break stop para quebrar esse loop.
Não precisa saber isso, agora.
Acho que o negócio foi muito rápido, por isso que deu.
Então, é porque o que aconteceu foi que essa soma foi muito rápido, foi até o valor máximo de 1 inteiro e revertiu para 0, acho, deu overflow.
Acho que foi isso que aconteceu.
Então, você nota que é o primeiro, deu 4, 8, 16, 22, 24 e por diante, então ele faz um negócio sem parar.
Salvar, mas como ele alcançou o valor máximo, é só dar 0, sem parar agora.
Então, vai interromper com o control C.
Então, esse loop infinito é a mesma coisa que você vai adicionar for true aqui, mesma coisa.
Então, você faz.
Então, é a mesma coisa lá, 0, 0, 0, porque foi muito rápido.
Tá bom?
Então, por essa aula é só e até a próxima.
Até a próxima.
Nenhum comentário ainda (loading...)
Nenhum comentário ainda (loading...)
Gostou da aula? 😆👍
Apoie nosso trabalho com uma doação: