WEBVTT

00:00:00.700 --> 00:00:02.167
Vamos falar sobre loops.

00:00:02.167 --> 00:00:04.394
Temos um loop while aqui.
E com algumas

00:00:04.394 --> 00:00:06.304
linhas de código, posso escrever
esta mensagem

00:00:06.304 --> 00:00:07.454
até o final da tela

00:00:07.454 --> 00:00:09.404
Se eu for em frente e mudar
a mensagem assim,

00:00:09.404 --> 00:00:10.234
para melhorá-la,

00:00:10.234 --> 00:00:11.696
todas elas mudam.

00:00:11.926 --> 00:00:14.004
Então, como isso está funcionando?

00:00:14.004 --> 00:00:15.578
Bem, podemos rever
esse código

00:00:15.578 --> 00:00:17.838
daqui a pouco. Mas primeiro vamos
voltar um pouco

00:00:17.838 --> 00:00:20.014
e pensar como escreveríamos
este programa

00:00:20.014 --> 00:00:22.939
usando apenas o que sabemos até 
agora sem usar loops.

00:00:22.944 --> 00:00:23.839
Para isso,

00:00:23.839 --> 00:00:25.506
vamos escrever um monte de text()

00:00:25.506 --> 00:00:26.933
várias vezes, certo?

00:00:26.933 --> 00:00:28.857
Vamos escrever "text()", "message"...

00:00:28.857 --> 00:00:30.600
vou colocá-lo em primeiro lugar,

00:00:30.600 --> 00:00:32.512
e agora é só uma questão de repetir isso

00:00:32.512 --> 00:00:33.554
várias vezes

00:00:33.554 --> 00:00:34.662
para então,

00:00:34.662 --> 00:00:36.530
chegarmos até o final

00:00:36.530 --> 00:00:38.949
E isso vai dar trabalho, certo?

00:00:38.949 --> 00:00:41.192
Porque o final é realmente muito longe.

00:00:41.192 --> 00:00:43.722
E é ainda pior se você em seguida
apontar para mim

00:00:43.722 --> 00:00:46.637
"hey, na verdade aqui não era 70.
Precisa estar mais perto,

00:00:46.637 --> 00:00:47.545
"precisa ser, tipo, 60."

00:00:47.545 --> 00:00:49.192
E agora afeta este aqui,

00:00:49.192 --> 00:00:51.139
porque ele também precisa ser menor.

00:00:51.139 --> 00:00:52.963
E assim por diante,

00:00:52.963 --> 00:00:55.287
à medida que temos mais 
chamadas de text().

00:00:55.287 --> 00:00:58.239
E, de fato, desta forma vai demorar 
para chegar ao final.

00:00:58.239 --> 00:01:00.246
Então, isso é mesmo massante,

00:01:00.246 --> 00:01:02.373
e felizmente temos loops para nos ajudar.

00:01:02.373 --> 00:01:05.324
A partir de agora, sempre que você 
ver um código repetitivo assim,

00:01:05.324 --> 00:01:07.631
pense: "Eu pdoeria usar um loop?"

00:01:07.631 --> 00:01:09.366
Um loop vai nos deixar repetir

00:01:09.366 --> 00:01:13.224
este pedaço de código sempre, apenas
fazendo pequenas mudanças a cada vez.

00:01:13.224 --> 00:01:16.015
Aqui está como reescreveríamos 
esse código com um loop.

00:01:16.015 --> 00:01:18.176
Para começar, é preciso digitar "while",

00:01:18.176 --> 00:01:20.444
os parênteses, e as chaves.

00:01:20.614 --> 00:01:22.142
Vamos receber essa mensagem,

00:01:22.142 --> 00:01:23.601
mas só porque não 
terminamos ainda.

00:01:23.601 --> 00:01:25.990
Não se preocupe, ela vai 
embora quando terminar.

00:01:26.030 --> 00:01:27.766
Cada vez que você escrever um loop

00:01:27.766 --> 00:01:28.894
você precisa responder

00:01:28.894 --> 00:01:30.172
a três perguntas-chave.

00:01:30.952 --> 00:01:32.550
E aqui estão elas:

00:01:32.840 --> 00:01:35.041
Então, a primeira pergunta é:

00:01:35.041 --> 00:01:37.170
"O que eu quero repetir?"

00:01:37.170 --> 00:01:38.949
E tudo que vamos querer repetir

00:01:38.949 --> 00:01:41.028
precisa ir em entre estas chaves.

00:01:41.468 --> 00:01:44.169
Queremos repetir a chamada 
de "text()" neste caso.

00:01:44.169 --> 00:01:45.910
Então vá em frente e coloque-o aqui.

00:01:46.230 --> 00:01:47.815
Mas é um pouco bobo, né?

00:01:47.815 --> 00:01:49.760
Porque agora vamos apenas repetir

00:01:49.760 --> 00:01:51.580
a mesma chamada de text() sempre

00:01:51.580 --> 00:01:53.053
o que não está muito certo, né?

00:01:53.053 --> 00:01:54.756
precisamos de algo que 
esteja mudando.

00:01:54.756 --> 00:01:56.328
Isso nos leva à segunda pergunta, que é:

00:01:56.328 --> 00:01:58.000
"O que eu quero mudar de cada vez?"

00:01:58.000 --> 00:01:59.781
Queremos mudar esta 
posição "y", certo?

00:01:59.781 --> 00:02:01.448
Queremos que "y" se torne 60

00:02:01.448 --> 00:02:02.755
depois que se torne 80

00:02:02.755 --> 00:02:05.053
Então, vamos criar uma variável

00:02:05.053 --> 00:02:07.597
chamada "y", porque é a posição y.

00:02:07.597 --> 00:02:10.231
Vamos declarar uma variável aqui.

00:02:10.231 --> 00:02:11.845
Vou iniciá-la em 40.

00:02:12.085 --> 00:02:13.091
E agora, finalmente,

00:02:13.091 --> 00:02:14.407
só precisamos mudar "y".

00:02:14.407 --> 00:02:15.784
Podemos fazer isso aqui para baixo

00:02:15.784 --> 00:02:17.571
podemos dizer "y é igual a y mais 20"

00:02:17.571 --> 00:02:19.682
e "y" irá aumentar toda vez.

00:02:19.682 --> 00:02:21.623
Na verdade, podemos usar nossa lição

00:02:21.623 --> 00:02:23.402
de atalhos de incremento aqui.

00:02:23.402 --> 00:02:24.998
Nós podemos apenas ir em frente

00:02:24.998 --> 00:02:26.474
e usar o atalho.

00:02:26.644 --> 00:02:28.424
Então, isso é fantástico.

00:02:28.424 --> 00:02:30.931
E só precisamos fazer a pergutna três agora. 
Que é:

00:02:30.931 --> 00:02:32.735
"Por quanto tempo devemos 
repetir isso?"

00:02:32.735 --> 00:02:34.924
Queremos repetir isso várias vezes,

00:02:34.924 --> 00:02:37.023
mas, não vamos repetir para 
sempre, certo?

00:02:37.023 --> 00:02:38.109
Se fizermos isso,

00:02:38.109 --> 00:02:39.749
primeiro que é um tempo muito 
longo para esperar,

00:02:39.749 --> 00:02:41.529
e, segundo, que pode até 
travar o seu browser.

00:02:41.529 --> 00:02:42.983
Mas esperamos que não.

00:02:42.983 --> 00:02:44.779
De verdade, só queremos fazer isso

00:02:44.779 --> 00:02:46.975
até chegarmos no final da página, certo?

00:02:46.975 --> 00:02:50.531
O que significa que queremos seguir
enquanto "y"for menos que 400.

00:02:50.569 --> 00:02:52.321
Portanto, colocamos isso aqui,

00:02:52.321 --> 00:02:53.393
e está pronto!

00:02:53.393 --> 00:02:55.348
Temos esta mensagem está sendo escrita

00:02:55.348 --> 00:02:56.533
até o final da tela.

00:02:56.533 --> 00:02:58.300
E você pode ver que isso é 
bem mais simples

00:02:58.300 --> 00:02:59.638
que nossa abordagem anterior,

00:02:59.638 --> 00:03:01.727
que demorou pra escrevermos.

00:03:01.727 --> 00:03:03.816
e nem chegamos à um quarto disso.

00:03:03.816 --> 00:03:05.907
Assim, podemos nos livrar disso,

00:03:05.907 --> 00:03:07.339
e aí temos o nosso programa.

00:03:07.809 --> 00:03:10.707
Agora, vamos tentar entender 
melhor o que está acontecendo.

00:03:10.707 --> 00:03:12.465
Vou imprimir na tela

00:03:12.465 --> 00:03:13.520
"y" de cada vez.

00:03:13.520 --> 00:03:15.715
Eu vou dizer "y é agora" e, aqui embaixo,

00:03:15.715 --> 00:03:18.157
vou colocar "y" no final da mensagem,

00:03:18.157 --> 00:03:19.424
para que possamos vê-lo.

00:03:19.424 --> 00:03:20.381
Então, no momento,

00:03:20.381 --> 00:03:22.618
o valor está mudando a cada 20, certo?

00:03:22.618 --> 00:03:23.997
E podemos mudar isso

00:03:23.997 --> 00:03:25.810
apenas alterando essa variável aqui.

00:03:25.810 --> 00:03:28.333
Ou você pode mudar para, tipo, 50.

00:03:28.693 --> 00:03:30.988
E agora, agora estão mudando a cada 50.


00:03:30.988 --> 00:03:31.863
Da mesma forma,

00:03:31.863 --> 00:03:33.788
você pode brincar com outros valores

00:03:33.788 --> 00:03:35.114
para alterá-los.

00:03:35.114 --> 00:03:36.918
E você pode ver como isso afeta

00:03:36.918 --> 00:03:39.172
onde o programa para.

00:03:40.572 --> 00:03:41.585
Assim, para entender isso,

00:03:43.612 --> 00:03:45.134
você pode pensar nele como 
uma condicional.

00:03:45.134 --> 00:03:47.342
Nós temos nossa expressão booleana aqui

00:03:47.342 --> 00:03:48.781
como você já aprendeu.

00:03:48.781 --> 00:03:51.670
Então executamos o corpo da... declaração,

00:03:51.670 --> 00:03:52.449
esta parte,

00:03:52.449 --> 00:03:54.268
somente se a expressão é verdadeira.

00:03:54.268 --> 00:03:56.418
E caso contrário, pulamos para o fim.

00:03:56.418 --> 00:03:58.080
Mas o é interessante é que,

00:03:58.080 --> 00:03:59.728
com um loop "while"

00:03:59.728 --> 00:04:01.636
temos algo secreto acontecendo
na parte inferior.

00:04:01.636 --> 00:04:04.304
que diz "volte para o início do loop".

00:04:05.224 --> 00:04:07.202
E o que esta instrução secreta significa

00:04:07.202 --> 00:04:10.512
é que em vez de sair e seguir em frente,

00:04:10.512 --> 00:04:12.042
como com uma condicional,

00:04:12.042 --> 00:04:14.039
cada vez que executamos o corpo do loop

00:04:14.039 --> 00:04:15.520
nós vamos voltar e verificar

00:04:15.520 --> 00:04:17.231
se a condição ainda é verdadeira.

00:04:17.231 --> 00:04:18.043
E se for,

00:04:18.043 --> 00:04:20.075
vamos apenas repetir mais uma vez.

00:04:20.075 --> 00:04:22.832
E, assim como você deve ter adivinhado,
a segunda vez que repetimos

00:04:22.832 --> 00:04:23.768
faremos a mesma coisa.

00:04:23.768 --> 00:04:25.620
"Volte para o início,

00:04:25.620 --> 00:04:28.162
'y' ainda é menor do que 279?"

00:04:28.582 --> 00:04:30.435
E se for, vamos repetir mais uma vez

00:04:30.435 --> 00:04:31.648
e continuar verificando.

00:04:31.648 --> 00:04:33.924
E se não for, voltamos para o início aqui.

00:04:33.924 --> 00:04:34.730
E, finalmente,

00:04:34.730 --> 00:04:36.017
saímos do loop,

00:04:36.017 --> 00:04:38.504
e continuamos com nosso programa.

00:04:38.504 --> 00:04:40.056
Excelente! Existem maneiras mais

00:04:40.056 --> 00:04:41.401
interessantes de usar laços

00:04:41.401 --> 00:04:42.548
que aprenderemos em breve.

00:04:42.548 --> 00:04:45.593
Mas por enquanto, você está pronto
pra um ótimo começo.

00:04:45.593 --> 00:04:46.874
Legendado por [Pablo Vieira]
Revisado por [Cainã Perri]