0:00:00.700,0:00:02.167
Vamos falar sobre loops.

0:00:02.167,0:00:04.394
Temos um loop while aqui.[br]E com algumas

0:00:04.394,0:00:06.304
linhas de código, posso escrever[br]esta mensagem

0:00:06.304,0:00:07.454
até o final da tela

0:00:07.454,0:00:09.404
Se eu for em frente e mudar[br]a mensagem assim,

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

0:00:10.234,0:00:11.696
todas elas mudam.

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

0:00:14.004,0:00:15.578
Bem, podemos rever[br]esse código

0:00:15.578,0:00:17.838
daqui a pouco. Mas primeiro vamos[br]voltar um pouco

0:00:17.838,0:00:20.014
e pensar como escreveríamos[br]este programa

0:00:20.014,0:00:22.939
usando apenas o que sabemos até [br]agora sem usar loops.

0:00:22.944,0:00:23.839
Para isso,

0:00:23.839,0:00:25.506
vamos escrever um monte de text()

0:00:25.506,0:00:26.933
várias vezes, certo?

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

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

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

0:00:32.512,0:00:33.554
várias vezes

0:00:33.554,0:00:34.662
para então,

0:00:34.662,0:00:36.530
chegarmos até o final

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

0:00:38.949,0:00:41.192
Porque o final é realmente muito longe.

0:00:41.192,0:00:43.722
E é ainda pior se você em seguida[br]apontar para mim

0:00:43.722,0:00:46.637
"hey, na verdade aqui não era 70.[br]Precisa estar mais perto,

0:00:46.637,0:00:47.545
"precisa ser, tipo, 60."

0:00:47.545,0:00:49.192
E agora afeta este aqui,

0:00:49.192,0:00:51.139
porque ele também precisa ser menor.

0:00:51.139,0:00:52.963
E assim por diante,

0:00:52.963,0:00:55.287
à medida que temos mais [br]chamadas de text().

0:00:55.287,0:00:58.239
E, de fato, desta forma vai demorar [br]para chegar ao final.

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

0:01:00.246,0:01:02.373
e felizmente temos loops para nos ajudar.

0:01:02.373,0:01:05.324
A partir de agora, sempre que você [br]ver um código repetitivo assim,

0:01:05.324,0:01:07.631
pense: "Eu pdoeria usar um loop?"

0:01:07.631,0:01:09.366
Um loop vai nos deixar repetir

0:01:09.366,0:01:13.224
este pedaço de código sempre, apenas[br]fazendo pequenas mudanças a cada vez.

0:01:13.224,0:01:16.015
Aqui está como reescreveríamos [br]esse código com um loop.

0:01:16.015,0:01:18.176
Para começar, é preciso digitar "while",

0:01:18.176,0:01:20.444
os parênteses, e as chaves.

0:01:20.614,0:01:22.142
Vamos receber essa mensagem,

0:01:22.142,0:01:23.601
mas só porque não [br]terminamos ainda.

0:01:23.601,0:01:25.990
Não se preocupe, ela vai [br]embora quando terminar.

0:01:26.030,0:01:27.766
Cada vez que você escrever um loop

0:01:27.766,0:01:28.894
você precisa responder

0:01:28.894,0:01:30.172
a três perguntas-chave.

0:01:30.952,0:01:32.550
E aqui estão elas:

0:01:32.840,0:01:35.041
Então, a primeira pergunta é:

0:01:35.041,0:01:37.170
"O que eu quero repetir?"

0:01:37.170,0:01:38.949
E tudo que vamos querer repetir

0:01:38.949,0:01:41.028
precisa ir em entre estas chaves.

0:01:41.468,0:01:44.169
Queremos repetir a chamada [br]de "text()" neste caso.

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

0:01:46.230,0:01:47.815
Mas é um pouco bobo, né?

0:01:47.815,0:01:49.760
Porque agora vamos apenas repetir

0:01:49.760,0:01:51.580
a mesma chamada de text() sempre

0:01:51.580,0:01:53.053
o que não está muito certo, né?

0:01:53.053,0:01:54.756
precisamos de algo que [br]esteja mudando.

0:01:54.756,0:01:56.328
Isso nos leva à segunda pergunta, que é:

0:01:56.328,0:01:58.000
"O que eu quero mudar de cada vez?"

0:01:58.000,0:01:59.781
Queremos mudar esta [br]posição "y", certo?

0:01:59.781,0:02:01.448
Queremos que "y" se torne 60

0:02:01.448,0:02:02.755
depois que se torne 80

0:02:02.755,0:02:05.053
Então, vamos criar uma variável

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

0:02:07.597,0:02:10.231
Vamos declarar uma variável aqui.

0:02:10.231,0:02:11.845
Vou iniciá-la em 40.

0:02:12.085,0:02:13.091
E agora, finalmente,

0:02:13.091,0:02:14.407
só precisamos mudar "y".

0:02:14.407,0:02:15.784
Podemos fazer isso aqui para baixo

0:02:15.784,0:02:17.571
podemos dizer "y é igual a y mais 20"

0:02:17.571,0:02:19.682
e "y" irá aumentar toda vez.

0:02:19.682,0:02:21.623
Na verdade, podemos usar nossa lição

0:02:21.623,0:02:23.402
de atalhos de incremento aqui.

0:02:23.402,0:02:24.998
Nós podemos apenas ir em frente

0:02:24.998,0:02:26.474
e usar o atalho.

0:02:26.644,0:02:28.424
Então, isso é fantástico.

0:02:28.424,0:02:30.931
E só precisamos fazer a pergutna três agora. [br]Que é:

0:02:30.931,0:02:32.735
"Por quanto tempo devemos [br]repetir isso?"

0:02:32.735,0:02:34.924
Queremos repetir isso várias vezes,

0:02:34.924,0:02:37.023
mas, não vamos repetir para [br]sempre, certo?

0:02:37.023,0:02:38.109
Se fizermos isso,

0:02:38.109,0:02:39.749
primeiro que é um tempo muito [br]longo para esperar,

0:02:39.749,0:02:41.529
e, segundo, que pode até [br]travar o seu browser.

0:02:41.529,0:02:42.983
Mas esperamos que não.

0:02:42.983,0:02:44.779
De verdade, só queremos fazer isso

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

0:02:46.975,0:02:50.531
O que significa que queremos seguir[br]enquanto "y"for menos que 400.

0:02:50.569,0:02:52.321
Portanto, colocamos isso aqui,

0:02:52.321,0:02:53.393
e está pronto!

0:02:53.393,0:02:55.348
Temos esta mensagem está sendo escrita

0:02:55.348,0:02:56.533
até o final da tela.

0:02:56.533,0:02:58.300
E você pode ver que isso é [br]bem mais simples

0:02:58.300,0:02:59.638
que nossa abordagem anterior,

0:02:59.638,0:03:01.727
que demorou pra escrevermos.

0:03:01.727,0:03:03.816
e nem chegamos à um quarto disso.

0:03:03.816,0:03:05.907
Assim, podemos nos livrar disso,

0:03:05.907,0:03:07.339
e aí temos o nosso programa.

0:03:07.809,0:03:10.707
Agora, vamos tentar entender [br]melhor o que está acontecendo.

0:03:10.707,0:03:12.465
Vou imprimir na tela

0:03:12.465,0:03:13.520
"y" de cada vez.

0:03:13.520,0:03:15.715
Eu vou dizer "y é agora" e, aqui embaixo,

0:03:15.715,0:03:18.157
vou colocar "y" no final da mensagem,

0:03:18.157,0:03:19.424
para que possamos vê-lo.

0:03:19.424,0:03:20.381
Então, no momento,

0:03:20.381,0:03:22.618
o valor está mudando a cada 20, certo?

0:03:22.618,0:03:23.997
E podemos mudar isso

0:03:23.997,0:03:25.810
apenas alterando essa variável aqui.

0:03:25.810,0:03:28.333
Ou você pode mudar para, tipo, 50.

0:03:28.693,0:03:30.988
E agora, agora estão mudando a cada 50.[br]

0:03:30.988,0:03:31.863
Da mesma forma,

0:03:31.863,0:03:33.788
você pode brincar com outros valores

0:03:33.788,0:03:35.114
para alterá-los.

0:03:35.114,0:03:36.918
E você pode ver como isso afeta

0:03:36.918,0:03:39.172
onde o programa para.

0:03:40.572,0:03:41.585
Assim, para entender isso,

0:03:43.612,0:03:45.134
você pode pensar nele como [br]uma condicional.

0:03:45.134,0:03:47.342
Nós temos nossa expressão booleana aqui

0:03:47.342,0:03:48.781
como você já aprendeu.

0:03:48.781,0:03:51.670
Então executamos o corpo da... declaração,

0:03:51.670,0:03:52.449
esta parte,

0:03:52.449,0:03:54.268
somente se a expressão é verdadeira.

0:03:54.268,0:03:56.418
E caso contrário, pulamos para o fim.

0:03:56.418,0:03:58.080
Mas o é interessante é que,

0:03:58.080,0:03:59.728
com um loop "while"

0:03:59.728,0:04:01.636
temos algo secreto acontecendo[br]na parte inferior.

0:04:01.636,0:04:04.304
que diz "volte para o início do loop".

0:04:05.224,0:04:07.202
E o que esta instrução secreta significa

0:04:07.202,0:04:10.512
é que em vez de sair e seguir em frente,

0:04:10.512,0:04:12.042
como com uma condicional,

0:04:12.042,0:04:14.039
cada vez que executamos o corpo do loop

0:04:14.039,0:04:15.520
nós vamos voltar e verificar

0:04:15.520,0:04:17.231
se a condição ainda é verdadeira.

0:04:17.231,0:04:18.043
E se for,

0:04:18.043,0:04:20.075
vamos apenas repetir mais uma vez.

0:04:20.075,0:04:22.832
E, assim como você deve ter adivinhado,[br]a segunda vez que repetimos

0:04:22.832,0:04:23.768
faremos a mesma coisa.

0:04:23.768,0:04:25.620
"Volte para o início,

0:04:25.620,0:04:28.162
'y' ainda é menor do que 279?"

0:04:28.582,0:04:30.435
E se for, vamos repetir mais uma vez

0:04:30.435,0:04:31.648
e continuar verificando.

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

0:04:33.924,0:04:34.730
E, finalmente,

0:04:34.730,0:04:36.017
saímos do loop,

0:04:36.017,0:04:38.504
e continuamos com nosso programa.

0:04:38.504,0:04:40.056
Excelente! Existem maneiras mais

0:04:40.056,0:04:41.401
interessantes de usar laços

0:04:41.401,0:04:42.548
que aprenderemos em breve.

0:04:42.548,0:04:45.593
Mas por enquanto, você está pronto[br]pra um ótimo começo.

0:04:45.593,0:04:46.874
Legendado por [Pablo Vieira][br]Revisado por [Cainã Perri]