0:00:00.700,0:00:07.260
Hablemos de ciclos. Aquí tengo un ciclo "while" con unas pocas líneas de código, puedo escribir este mensaje hasta el fondo de la pantalla.

0:00:07.260,0:00:10.335
Si cambio el mensaje como lo hago aquí, ya sabes, para mejorarlo,

0:00:10.335,0:00:11.926
todo esto cambia.

0:00:11.926,0:00:15.833
Así que ¿cómo funciona esto? Bueno, podemos revisar este código en un momento.

0:00:15.833,0:00:19.422
Pero primero vamos a regresarnos un poco y pensar cómo escribiríamos este programa

0:00:19.422,0:00:22.471
usando sólo lo que sabemos hasta ahora sin utilizar los ciclos.

0:00:22.471,0:00:26.751
Así que para hacer eso, en realidad vamos a escribir mucho texto una y otra vez ¿cierto?

0:00:26.751,0:00:32.590
Vamos a decir, "text(message..." y voy ponerlo en primer lugar, y ahora sólo es cuestión de repetir esto

0:00:32.590,0:00:36.336
suficientes veces hasta que lleguemos hasta abajo.

0:00:36.336,0:00:38.949
Y eso nos va a costar mucho trabajo, ¿cierto?

0:00:38.949,0:00:42.753
Porque la parte de abajo está muy lejos. Y esto se vuelve peor si tú

0:00:42.753,0:00:46.758
me señalas que esta posición no debe ser 70, en realidad debe estar más cerca

0:00:46.758,0:00:50.709
debe ser 60. Y ahora esto afecta a este porque también debe ser más pequeño

0:00:50.709,0:00:55.036
y también afecta todos los demás textos que tengamos.

0:00:55.036,0:00:58.261
Y de hecho, esto nos va a tomar más tiempo hasta llegar abajo.

0:00:58.261,0:01:02.176
Así que es realmente una pena, pero afortunadamente tenemos ciclos que nos ayudan.

0:01:02.176,0:01:06.210
A partir de ahora, cada vez que veas un código repetitivo como éste, tu primer pensamiento debe ser:

0:01:06.210,0:01:10.087
¿Podría usar un ciclo? Un ciclo nos permitirá repetir esta porción de código una y otra y

0:01:10.087,0:01:13.671
otra vez, haciendo sólo pequeños cambios cada vez.

0:01:13.671,0:01:17.868
Así que aquí tenemos la manera de reescribir este código con un ciclo. Para iniciar necesitamos escribir: "while",

0:01:17.868,0:01:22.089
los paréntesis, y las llaves. Vamos a usar este mensaje, pero...

0:01:22.089,0:01:26.301
esto es porque no hemos terminado todavía. No te preocupes, se irá cuando terminemos.

0:01:26.301,0:01:30.810
Así que cada vez que escribas un ciclo necesitas responder tres preguntas clave.

0:01:30.825,0:01:32.940
Y aquí están...

0:01:32.940,0:01:37.371
Entonces la primera pregunta es: [br]¿Qué es lo que quiero repetir?

0:01:37.371,0:01:41.466
Y lo que sea que quiera repetir debe ir entre las llaves.

0:01:41.466,0:01:46.198
Así que en este caso queremos repetir la función "text", entonces vamos a ponerla aquí.

0:01:46.198,0:01:49.571
Pero es un poco absurdo ¿no? Porque vamos a repetir simplemente

0:01:49.571,0:01:54.197
la misma llamada a la función "text" una y otra vez, lo cual no tienen ninguna razón, necesitamos que algo cambie.

0:01:54.197,0:01:57.710
Esto nos lleva a la segunda pregunta:[br]¿Qué es lo que quiero cambiar cada vez?

0:01:57.710,0:02:01.423
Entonces lo que queremos cambiar es la posición de "y", ¿cierto? Queremos que sea 60 y luego queremos

0:02:01.423,0:02:05.503
que sea 80. Así que haremos una variable para eso.

0:02:05.503,0:02:09.476
La llamaremos "y" porque es la posición de "y". Así que vamos a declarar la variable

0:02:09.476,0:02:13.376
aquí arriba. Y la voy a inicializar en 40. Y ahora finalmente, lo que necesitamos hacer es

0:02:13.376,0:02:17.205
cambiar "y". Podemos hacer eso aquí abajo, y decimos "y" es igual a "y" más 20,

0:02:17.205,0:02:21.088
y "y" será más grande cada vez. Y de hecho, podemos usar

0:02:21.088,0:02:24.745
aquí nuestras lecciones sobre cómo escribir incrementos. Continuamos

0:02:24.745,0:02:29.092
y usamos un atajo para el incremento. Esto es fantástico, ahora

0:02:29.092,0:02:32.705
necesitamos hacer la tercera pregunta: ¿Hasta cuándo debemos repetir esto?

0:02:32.705,0:02:36.531
Bueno, queremos hacer esto una y otra y otra vez, pero en realidad no queremos que sea para siempre, ¿cierto?

0:02:36.531,0:02:41.252
Si lo hacemos para siempre, en primer lugar es tener que esperar mucho tiempo, y en segundo lugar esto podría bloquear tu navegador.

0:02:41.252,0:02:44.471
Pero afortunadamente no es así. En realidad sólo

0:02:44.471,0:02:48.371
lo queremos hacer hasta llegar a la parte inferior de la pantalla, ¿cierto? Lo que significa que lo queremos hacer

0:02:48.371,0:02:52.469
siempre y cuando "y" sea menor que 400. Entonces ponemos eso aquí, y

0:02:52.469,0:02:56.426
¡Terminamos! tenemos este mensaje escrito hasta abajo de la pantalla.

0:02:56.426,0:02:59.920
Y puedes ver que esta forma de hacerlo es más simple que nuestro intento anterior, que

0:02:59.920,0:03:04.175
nos tomó casi lo mismo escribirlo, pero no teníamos ni la cuarta parte terminada.

0:03:04.175,0:03:08.090
Así que nos podemos deshacer de eso, y aquí tenemos nuestro programa.

0:03:08.090,0:03:11.711
Ahora vamos a tratar de entender mejor qué es lo que está pasando. Para hacerlo, voy a

0:03:11.711,0:03:15.634
imprimir cada vez. Voy a decir "y is now" ("y" es ahora) y aquí abajo

0:03:15.634,0:03:19.410
voy a poner "y" en la parte final del mensaje para que podamos verlo.

0:03:19.410,0:03:23.343
Entonces en este momento el valor está cambiando en 20 cada vez, y podemos cambiar

0:03:23.343,0:03:27.257
esto solamente cambiando esta variable aquí. Pueden hacer que cambie, en 50

0:03:27.257,0:03:31.426
cada vez. Y ahora está cambiando 50 cada vez. Del mismo modo,

0:03:31.426,0:03:35.578
puedes continuar y jugar con estos otros valores y cambiarlos.

0:03:35.578,0:03:39.201
Y puedes ver cómo afecta eso, ya sabes, cuándo el programa debe terminar.

0:03:39.201,0:03:44.007
Así que para entender esto, puedes pensar en esto como una especie

0:03:44.007,0:03:47.342
de sentencia "if". Aquí tenemos nuestra expresión booleana

0:03:47.342,0:03:52.009
justo como lo aprendimos. Y luego, hacemos que esto sea el cuerpo de la sentencia

0:03:52.009,0:03:55.469
sólo si la expresión booleana es verdadera, de otra manera saltamos al final.

0:03:55.469,0:03:59.093
Pero lo que es interesante es que en el ciclo "while" tenemos en realidad

0:03:59.093,0:04:03.864
una cosa secreta el final que dice "regresa al principio del ciclo".

0:04:03.864,0:04:07.202
Y lo que esta instrucción secreta significa es que

0:04:07.202,0:04:11.071
en lugar de seguir adelante, como cuando usamos la sentencia "if",

0:04:11.071,0:04:15.032
cada vez que se ejecuta el cuerpo del ciclo regresamos al principio y revisamos

0:04:15.032,0:04:19.204
si la condición sigue siendo verdadera. Y si es verdadera seguimos adelante para repetir

0:04:19.204,0:04:23.238
el ciclo una vez más. Y cómo ya te habrás imaginado, la segunda vez que repetimos, vamos a hacer la misma cosa...

0:04:23.238,0:04:27.086
vamos a comprobar, ya sabes, vamos a ir al inicio y revisar ¿"y" sigue siendo menor que

0:04:27.086,0:04:31.565
279? Y si es así, repetiremos una vez más y seguiremos revisando.

0:04:31.565,0:04:34.591
Y si no lo es, regresamos al inicio aquí, y finalmente,

0:04:34.591,0:04:38.478
salimos del ciclo y seguimos adelante con nuestro programa.

0:04:38.478,0:04:42.703
Grandioso, hay muchas maneras interesantes de usar los ciclos, y vamos a aprender sobre eso pronto, pero

0:04:42.703,0:04:45.913
por ahora, tuvimos un comienzo excelente.