Hola y bienvenidos.
Vamos a ver la ejecución paso a paso de nuestro ciclo.
Están listos?
Vamos.
Bien antes de empezar la ejecución, paso a paso vamos a mandar a imprimir un mensaje simplemente para
indicar que ya estamos fuera del ciclo while.
Para que sepamos en qué momento se ha terminado la ejecución de este ciclo.
Y si ejecutamos, podemos observar al final que ya estamos fuera del ciclo while.
Ahora sí vamos a realizar la ejecución paso a paso.
Agregamos un punto de ruptura simplemente dando clic en esta sección en la línea seis.
Posteriormente presionamos el botón de debug y comienza la ejecución paso a paso.
Esto simplemente para que podamos ver a detalle cómo se repite nuestro ciclo while.
Bien, vamos a poner tanto la consola que va a tener la impresión de la salida, pero también las variables
que se están creando en memoria.
Recordemos que esta ventana no es parte del IDE, sino que es una animación que nosotros estamos agregando
al video para que esto sea más didáctico.
Así que en la línea seis se definen nuestras variables y si ejecutamos esta línea seis, entonces en
memoria se crean estas variables.
La variable de contador de tipo entero con el valor inicial de uno y posteriormente la variable de repeticiones
con el valor inicial de cinco.
Aunque esta variable bien podría ser una constante ya que su valor ya no cambia.
Bien, pero vamos a continuar.
Vamos a empezar con nuestro ciclo while.
Esta es la primera vez que se va a revisar si este ciclo se va a ejecutar o no aquí.
Lo interesante es que si esta condición de inicio es falsa, entonces no se va a ejecutar ni siquiera
una sola vez este bloque de código.
Así que la ejecución de este bloque de código está condicionado.
Si esta condición es falsa, entonces no se ejecuta ni siquiera una sola vez y nos vamos a la línea
15.
Es decir, que nos va a imprimir el mensaje.
Ya estamos fuera del ciclo while.
Ahora, cuando sucede esto, por ejemplo, cuando la variable de contador ya tiene el valor de seis.
Pero de momento si seleccionamos este código y nos posicionamos, podemos observar que nos muestra que
el resultado de la expresión es igual a uno, ya que la variable de contador vale uno y la variable
de repeticiones cinco.
Así que vamos a comprobar, vamos a entrar.
Y debido a que esta condición era verdadera, entonces empezamos la ejecución de todo este bloque de
código del ciclo while.
Bien, vamos a continuar.
Podemos observar que ya se manda a imprimir el valor del número uno y posteriormente en esta línea de
código se va a incrementar la variable de contador.
Vamos a ejecutar y entonces en memoria lo que sucede es que la variable de contador se incrementa en
uno y ahora tiene el valor de dos.
Y ahora también en la línea 12 se va a crear esta variable.
Esta variable se crea al momento de ejecutar este bloque de código del ciclo while.
Por ello es que antes no la veíamos en memoria.
Únicamente se va a crear si es que este bloque de código se ejecuta y se dice entonces que esta variable
es local al ciclo while.
En cambio estas variables de contador y repeticiones son locales, pero al método main ya estaban creadas
antes de ejecutar nuestro ciclo.
Y entonces estas variables son locales al método main.
Esto quiere decir que cuando se termina la ejecución de nuestro método main, estas variables también
se destruyen y esta variable al ser local al ciclo while.
Una vez que termina de ejecutarse este ciclo while, entonces también se destruye esta variable de condición.
Todo esto lo vamos a ir viendo poco a poco, pero básicamente es para que nos empecemos a relacionar
con este tipo de conceptos.
Son variables locales al método en que hemos definido estas variables y también a este concepto se le
conoce como el alcance de esta variable, es decir, cuánto va a durar en memoria esta variable.
Así que estas variables van a existir mientras nuestro método main se siga ejecutando y esta variable
de condición va a existir mientras se siga ejecutando este ciclo while y en cuanto termine de ejecutarse
este ciclo también se destruye esta variable.
Esto lo vamos a ver a continuación.
Bien, entonces vamos a continuar.
Vamos a ejecutar la línea 12 y entonces la condición arroja el siguiente valor vamos a mandarlo a imprimir.
Podemos observar que ahora la variable de condición tiene el valor de uno, es decir, el valor de verdadero.
Debido a lo siguiente la variable de contador se incrementó de 1 a 2, como ya sabemos, y entonces
se revisa la condición si dos es menor o igual que cinco.
En este caso es verdadero.
Por lo tanto, este es el valor que se asigna a la variable de condición.
Esto quiere decir que la siguiente vez que se ejecute nuestro ciclo while, entonces va a continuar
debido a que la condición es verdadera y entonces podemos observar que la ejecución paso a paso de manera
automática movió la línea de ejecución.
Ahora regresamos a la línea ocho y se va a volver a ejecutar este bloque de código.
Debido a que la condición que vamos a evaluar es verdadera, pero esto apenas lo vamos a comprobar.
Así que si seleccionamos esta expresión en este momento, entonces nos indica que la variable de contador
vale dos según lo que mandamos a imprimir y la variable de repetición es cinco.
Por lo tanto, esa expresión regresa verdadero y vamos a volver a ejecutar este bloque de código.
Así que vamos a presionar de nueva cuenta este botón de este hover y volvemos a entrar a nuestro bloque
del ciclo while.
Vamos a mandar a imprimir la variable de contador y vamos a incrementar esta variable.
Esto quiere decir que esta variable de contador se va a incrementar en uno.
Sin embargo, aquí algo interesante que sucede es que podemos observar que la variable de condición
se volvió a crear.
Esto quiere decir que.
Una vez que terminó el ciclo while, esa variable de condición se destruyó.
Y una vez que volvemos a entrar a la ejecución de este ciclo, esta variable de condición se vuelve
a crear.
Ahora, si no queremos que esta variable se esté creando cada vez que ejecutamos este ciclo, entonces
esta variable la podríamos definir fuera de este ciclo while.
Por ejemplo, en esta misma línea donde estamos definiendo estas variables iniciales.
Pero de momento así lo hemos agregado precisamente para que viéramos este concepto.
Esta variable se crea y se destruye debido a que este bloque de código inicia y termina.
Así que cada vez que inicia este ciclo while, entonces en esta línea se crea esta variable y al llegar
a esta línea 14 se destruye.
Y así cada vez que ejecutamos este ciclo, entonces esta variable se está creando y cuando termina se
está destruyendo.
Bien, entonces, como hemos comentado, la variable de contador ahora vale tres y entonces si revisamos
la condición, vamos a volver a ejecutar.
Se manda a imprimir.
Vamos a mandar a imprimir el resultado de la expresión, el resultado de evaluar la expresi��n si tres
es menor o igual que cinco.
Recordemos que esta variable ya se ha incrementado, entonces en este caso todavía regresa verdadero.
Por lo tanto, al momento en que vamos a revisar ahora de nueva cuenta esa expresión, ya sabemos de
antemano que el resultado va a ser verdadero y entonces vamos a ejecutar de nueva cuenta este ciclo.
Aun así, si lo queremos comprobar, seleccionamos este bloque de código, esta expresión, y podemos
comprobar que el valor que regresa la evaluación de esta expresión es el valor de verdadero, el valor
de uno.
Y podemos observar que de nueva cuenta regresamos a la línea ocho.
La ejecución paso a paso.
Regresamos al bloque ocho.
Vamos a ejecutar de nueva cuenta y podemos observar que debido a que esta condición sigue siendo verdadera,
volvemos a ejecutar nuestro bloque de código.
Ahora estamos de nueva cuenta en la línea nueve.
Vamos a continuar.
Se imprime el valor de número igual a tres.
Bien, vamos a ir un poco más rápido debido a que ya sabemos en qué consiste.
Así que posteriormente se incrementa la variable de contador.
Así que en memoria ya tenemos lo siguiente la variable de contador ya vale cuatro.
Y entonces si mandamos a imprimir de nueva cuenta a nuestra expresión, ahora revisamos la expresión
si cuatro es menor que cinco.
En este caso todavía es verdadero.
Por lo tanto, vamos a volver a ejecutar nuestro bloque de código del ciclo while.
Vamos a comprobarlo.
Presionamos de nueva cuenta en este hover, volvemos a entrar y se manda a imprimir la variable de número.
Ahora en la línea diez se incrementa nuestra variable de contador y también se revisa la variable de
condición.
Podemos observar que la variable de contador ya se incrementó en uno.
Ahora ya vale cinco y la condición también sigue siendo todavía verdadera.
Vamos a mandarlo a imprimir y podemos observar que la condición corresponde con este valor.
Se pregunta si cinco es menor o igual que cinco.
Cinco no es menor que cinco, pero si es igual, por lo tanto todavía regresa verdadero.
Así que esta condición es verdadera.
Volvemos a ejecutar.
Se manda a imprimir el valor de cinco.
Se incrementa la variable de contador y mandamos a imprimir la expresión.
Entonces en memoria sucede lo siguiente se incrementa la variable de contador.
La variable de contador ya vale seis.
Y entonces, al momento de evaluar en su expresión la variable de condición ya tiene el valor de cero.
Tal como lo tenemos también en nuestra impresión.
Así que en este momento se revisa la expresión si seis es menor o igual que cinco.
En este caso ya es falsa la expresión.
Por lo tanto regresa a cero.
Y entonces la siguiente vez que se vuelva a evaluar nuestra condición, esta condición ya sabemos que
va a tener el valor de falso.
Por lo tanto, ya no se va a volver a ejecutar este bloque de código y nos vamos a ir directamente a
la línea 15 para mandar a imprimir, que ya estamos fuera del ciclo while.
Vamos a comprobarlo.
Si presionamos el botón de este hover en este momento ya estamos fuera del ciclo while.
Por lo tanto, en memoria se destruye la variable de condición.
Ya terminó nuestro ciclo while, se destruye esa variable y solamente queda en memoria la variable de
contador con el valor de seis y la variable de repeticiones.
Este valor nunca cambió.
Por lo tanto, el valor de esta variable puede ser una constante.
Bien.
Pero de momento así lo hemos definido.
Y por último volvemos a ejecutar.
Podemos llevar el mensaje.
Ya estamos fuera del ciclo usual.
Y básicamente con esto ya llegamos al final de la ejecución de nuestro programa.
Bien, vamos a ejecutarlo y termina también la ejecución de nuestro programa y por lo tanto se van a
destruir también de memoria las variables de contador y la variable de repeticiones.
Así que al momento de terminar de ejecutar nuestro método main, también estas variables se van a destruir
de memoria.
Por último, quitamos el punto de ruptura y con esto terminamos la ejecución paso a paso de nuestro
ejercicio.
Les pedimos que también lo hagan en su equipo, ya que es muy importante que se familiaricen con este
concepto de ejecución paso a paso.
Esto les va a permitir resolver muchos problemas al momento de realizar sus programas.
Bien, pongan en práctica lo que hemos visto y nos vemos en la siguiente lección.
Saludos.