1
00:00:00,770 --> 00:00:01,690
Hola y bienvenidos.

2
00:00:01,700 --> 00:00:03,740
Vamos a ver la ejecución paso a paso de nuestro ciclo.

3
00:00:04,220 --> 00:00:05,030
Están listos?

4
00:00:05,060 --> 00:00:05,540
Vamos.

5
00:00:06,630 --> 00:00:11,550
Bien antes de empezar la ejecución, paso a paso vamos a mandar a imprimir un mensaje simplemente para

6
00:00:11,550 --> 00:00:14,460
indicar que ya estamos fuera del ciclo while.

7
00:00:14,610 --> 00:00:18,150
Para que sepamos en qué momento se ha terminado la ejecución de este ciclo.

8
00:00:18,390 --> 00:00:22,350
Y si ejecutamos, podemos observar al final que ya estamos fuera del ciclo while.

9
00:00:22,860 --> 00:00:24,960
Ahora sí vamos a realizar la ejecución paso a paso.

10
00:00:25,230 --> 00:00:29,790
Agregamos un punto de ruptura simplemente dando clic en esta sección en la línea seis.

11
00:00:30,120 --> 00:00:34,740
Posteriormente presionamos el botón de debug y comienza la ejecución paso a paso.

12
00:00:35,010 --> 00:00:39,510
Esto simplemente para que podamos ver a detalle cómo se repite nuestro ciclo while.

13
00:00:39,810 --> 00:00:44,700
Bien, vamos a poner tanto la consola que va a tener la impresión de la salida, pero también las variables

14
00:00:44,700 --> 00:00:46,020
que se están creando en memoria.

15
00:00:46,350 --> 00:00:51,570
Recordemos que esta ventana no es parte del IDE, sino que es una animación que nosotros estamos agregando

16
00:00:51,570 --> 00:00:53,580
al video para que esto sea más didáctico.

17
00:00:53,970 --> 00:00:59,850
Así que en la línea seis se definen nuestras variables y si ejecutamos esta línea seis, entonces en

18
00:00:59,850 --> 00:01:01,800
memoria se crean estas variables.

19
00:01:01,810 --> 00:01:07,530
La variable de contador de tipo entero con el valor inicial de uno y posteriormente la variable de repeticiones

20
00:01:07,530 --> 00:01:09,390
con el valor inicial de cinco.

21
00:01:09,600 --> 00:01:13,500
Aunque esta variable bien podría ser una constante ya que su valor ya no cambia.

22
00:01:13,710 --> 00:01:15,240
Bien, pero vamos a continuar.

23
00:01:15,450 --> 00:01:17,010
Vamos a empezar con nuestro ciclo while.

24
00:01:17,280 --> 00:01:21,660
Esta es la primera vez que se va a revisar si este ciclo se va a ejecutar o no aquí.

25
00:01:21,660 --> 00:01:27,360
Lo interesante es que si esta condición de inicio es falsa, entonces no se va a ejecutar ni siquiera

26
00:01:27,360 --> 00:01:29,460
una sola vez este bloque de código.

27
00:01:29,730 --> 00:01:33,210
Así que la ejecución de este bloque de código está condicionado.

28
00:01:33,390 --> 00:01:39,270
Si esta condición es falsa, entonces no se ejecuta ni siquiera una sola vez y nos vamos a la línea

29
00:01:39,270 --> 00:01:39,690
15.

30
00:01:39,990 --> 00:01:41,900
Es decir, que nos va a imprimir el mensaje.

31
00:01:41,910 --> 00:01:43,740
Ya estamos fuera del ciclo while.

32
00:01:44,070 --> 00:01:48,690
Ahora, cuando sucede esto, por ejemplo, cuando la variable de contador ya tiene el valor de seis.

33
00:01:49,230 --> 00:01:55,230
Pero de momento si seleccionamos este código y nos posicionamos, podemos observar que nos muestra que

34
00:01:55,230 --> 00:02:00,060
el resultado de la expresión es igual a uno, ya que la variable de contador vale uno y la variable

35
00:02:00,060 --> 00:02:01,320
de repeticiones cinco.

36
00:02:01,980 --> 00:02:04,290
Así que vamos a comprobar, vamos a entrar.

37
00:02:04,290 --> 00:02:08,880
Y debido a que esta condición era verdadera, entonces empezamos la ejecución de todo este bloque de

38
00:02:08,880 --> 00:02:10,380
código del ciclo while.

39
00:02:10,500 --> 00:02:11,700
Bien, vamos a continuar.

40
00:02:11,730 --> 00:02:16,830
Podemos observar que ya se manda a imprimir el valor del número uno y posteriormente en esta línea de

41
00:02:16,830 --> 00:02:19,710
código se va a incrementar la variable de contador.

42
00:02:19,830 --> 00:02:25,710
Vamos a ejecutar y entonces en memoria lo que sucede es que la variable de contador se incrementa en

43
00:02:25,710 --> 00:02:27,900
uno y ahora tiene el valor de dos.

44
00:02:28,110 --> 00:02:31,020
Y ahora también en la línea 12 se va a crear esta variable.

45
00:02:31,230 --> 00:02:35,070
Esta variable se crea al momento de ejecutar este bloque de código del ciclo while.

46
00:02:35,250 --> 00:02:37,500
Por ello es que antes no la veíamos en memoria.

47
00:02:37,650 --> 00:02:43,140
Únicamente se va a crear si es que este bloque de código se ejecuta y se dice entonces que esta variable

48
00:02:43,140 --> 00:02:45,090
es local al ciclo while.

49
00:02:45,300 --> 00:02:51,390
En cambio estas variables de contador y repeticiones son locales, pero al método main ya estaban creadas

50
00:02:51,390 --> 00:02:52,980
antes de ejecutar nuestro ciclo.

51
00:02:53,490 --> 00:02:56,610
Y entonces estas variables son locales al método main.

52
00:02:56,760 --> 00:03:00,540
Esto quiere decir que cuando se termina la ejecución de nuestro método main, estas variables también

53
00:03:00,540 --> 00:03:03,870
se destruyen y esta variable al ser local al ciclo while.

54
00:03:04,080 --> 00:03:09,720
Una vez que termina de ejecutarse este ciclo while, entonces también se destruye esta variable de condición.

55
00:03:09,880 --> 00:03:14,130
Todo esto lo vamos a ir viendo poco a poco, pero básicamente es para que nos empecemos a relacionar

56
00:03:14,130 --> 00:03:15,480
con este tipo de conceptos.

57
00:03:15,480 --> 00:03:21,030
Son variables locales al método en que hemos definido estas variables y también a este concepto se le

58
00:03:21,030 --> 00:03:26,220
conoce como el alcance de esta variable, es decir, cuánto va a durar en memoria esta variable.

59
00:03:26,610 --> 00:03:31,770
Así que estas variables van a existir mientras nuestro método main se siga ejecutando y esta variable

60
00:03:31,770 --> 00:03:36,600
de condición va a existir mientras se siga ejecutando este ciclo while y en cuanto termine de ejecutarse

61
00:03:36,600 --> 00:03:39,090
este ciclo también se destruye esta variable.

62
00:03:39,270 --> 00:03:40,770
Esto lo vamos a ver a continuación.

63
00:03:41,130 --> 00:03:42,860
Bien, entonces vamos a continuar.

64
00:03:42,870 --> 00:03:49,020
Vamos a ejecutar la línea 12 y entonces la condición arroja el siguiente valor vamos a mandarlo a imprimir.

65
00:03:49,260 --> 00:03:54,600
Podemos observar que ahora la variable de condición tiene el valor de uno, es decir, el valor de verdadero.

66
00:03:54,900 --> 00:04:01,200
Debido a lo siguiente la variable de contador se incrementó de 1 a 2, como ya sabemos, y entonces

67
00:04:01,200 --> 00:04:04,230
se revisa la condición si dos es menor o igual que cinco.

68
00:04:04,230 --> 00:04:05,370
En este caso es verdadero.

69
00:04:05,490 --> 00:04:09,060
Por lo tanto, este es el valor que se asigna a la variable de condición.

70
00:04:09,300 --> 00:04:13,860
Esto quiere decir que la siguiente vez que se ejecute nuestro ciclo while, entonces va a continuar

71
00:04:14,010 --> 00:04:18,510
debido a que la condición es verdadera y entonces podemos observar que la ejecución paso a paso de manera

72
00:04:18,510 --> 00:04:20,940
automática movió la línea de ejecución.

73
00:04:21,090 --> 00:04:25,470
Ahora regresamos a la línea ocho y se va a volver a ejecutar este bloque de código.

74
00:04:25,710 --> 00:04:30,390
Debido a que la condición que vamos a evaluar es verdadera, pero esto apenas lo vamos a comprobar.

75
00:04:30,750 --> 00:04:35,880
Así que si seleccionamos esta expresión en este momento, entonces nos indica que la variable de contador

76
00:04:35,910 --> 00:04:39,770
vale dos según lo que mandamos a imprimir y la variable de repetición es cinco.

77
00:04:39,870 --> 00:04:44,160
Por lo tanto, esa expresión regresa verdadero y vamos a volver a ejecutar este bloque de código.

78
00:04:44,490 --> 00:04:49,620
Así que vamos a presionar de nueva cuenta este botón de este hover y volvemos a entrar a nuestro bloque

79
00:04:49,620 --> 00:04:50,400
del ciclo while.

80
00:04:50,460 --> 00:04:54,930
Vamos a mandar a imprimir la variable de contador y vamos a incrementar esta variable.

81
00:04:55,170 --> 00:04:58,170
Esto quiere decir que esta variable de contador se va a incrementar en uno.

82
00:04:58,470 --> 00:05:03,660
Sin embargo, aquí algo interesante que sucede es que podemos observar que la variable de condición

83
00:05:03,660 --> 00:05:04,980
se volvió a crear.

84
00:05:05,160 --> 00:05:05,910
Esto quiere decir que.

85
00:05:06,020 --> 00:05:09,830
Una vez que terminó el ciclo while, esa variable de condición se destruyó.

86
00:05:10,100 --> 00:05:14,810
Y una vez que volvemos a entrar a la ejecución de este ciclo, esta variable de condición se vuelve

87
00:05:14,810 --> 00:05:15,380
a crear.

88
00:05:15,620 --> 00:05:20,420
Ahora, si no queremos que esta variable se esté creando cada vez que ejecutamos este ciclo, entonces

89
00:05:20,420 --> 00:05:23,960
esta variable la podríamos definir fuera de este ciclo while.

90
00:05:24,170 --> 00:05:27,800
Por ejemplo, en esta misma línea donde estamos definiendo estas variables iniciales.

91
00:05:27,920 --> 00:05:31,730
Pero de momento así lo hemos agregado precisamente para que viéramos este concepto.

92
00:05:31,940 --> 00:05:37,340
Esta variable se crea y se destruye debido a que este bloque de código inicia y termina.

93
00:05:37,580 --> 00:05:42,950
Así que cada vez que inicia este ciclo while, entonces en esta línea se crea esta variable y al llegar

94
00:05:42,950 --> 00:05:44,870
a esta línea 14 se destruye.

95
00:05:45,110 --> 00:05:50,180
Y así cada vez que ejecutamos este ciclo, entonces esta variable se está creando y cuando termina se

96
00:05:50,180 --> 00:05:51,050
está destruyendo.

97
00:05:51,380 --> 00:05:56,690
Bien, entonces, como hemos comentado, la variable de contador ahora vale tres y entonces si revisamos

98
00:05:56,690 --> 00:05:58,940
la condición, vamos a volver a ejecutar.

99
00:05:59,120 --> 00:06:00,260
Se manda a imprimir.

100
00:06:00,410 --> 00:06:05,780
Vamos a mandar a imprimir el resultado de la expresión, el resultado de evaluar la expresi��n si tres

101
00:06:05,780 --> 00:06:06,980
es menor o igual que cinco.

102
00:06:06,980 --> 00:06:11,450
Recordemos que esta variable ya se ha incrementado, entonces en este caso todavía regresa verdadero.

103
00:06:11,690 --> 00:06:16,400
Por lo tanto, al momento en que vamos a revisar ahora de nueva cuenta esa expresión, ya sabemos de

104
00:06:16,400 --> 00:06:21,290
antemano que el resultado va a ser verdadero y entonces vamos a ejecutar de nueva cuenta este ciclo.

105
00:06:21,800 --> 00:06:27,410
Aun así, si lo queremos comprobar, seleccionamos este bloque de código, esta expresión, y podemos

106
00:06:27,410 --> 00:06:32,690
comprobar que el valor que regresa la evaluación de esta expresión es el valor de verdadero, el valor

107
00:06:32,690 --> 00:06:33,140
de uno.

108
00:06:33,410 --> 00:06:36,020
Y podemos observar que de nueva cuenta regresamos a la línea ocho.

109
00:06:36,230 --> 00:06:37,430
La ejecución paso a paso.

110
00:06:37,640 --> 00:06:38,870
Regresamos al bloque ocho.

111
00:06:39,200 --> 00:06:43,670
Vamos a ejecutar de nueva cuenta y podemos observar que debido a que esta condición sigue siendo verdadera,

112
00:06:43,880 --> 00:06:45,920
volvemos a ejecutar nuestro bloque de código.

113
00:06:46,160 --> 00:06:48,080
Ahora estamos de nueva cuenta en la línea nueve.

114
00:06:48,410 --> 00:06:49,400
Vamos a continuar.

115
00:06:49,730 --> 00:06:52,190
Se imprime el valor de número igual a tres.

116
00:06:52,370 --> 00:06:56,210
Bien, vamos a ir un poco más rápido debido a que ya sabemos en qué consiste.

117
00:06:56,450 --> 00:07:00,050
Así que posteriormente se incrementa la variable de contador.

118
00:07:00,260 --> 00:07:04,430
Así que en memoria ya tenemos lo siguiente la variable de contador ya vale cuatro.

119
00:07:04,700 --> 00:07:09,560
Y entonces si mandamos a imprimir de nueva cuenta a nuestra expresión, ahora revisamos la expresión

120
00:07:09,570 --> 00:07:11,180
si cuatro es menor que cinco.

121
00:07:11,390 --> 00:07:12,880
En este caso todavía es verdadero.

122
00:07:12,890 --> 00:07:16,640
Por lo tanto, vamos a volver a ejecutar nuestro bloque de código del ciclo while.

123
00:07:17,090 --> 00:07:18,080
Vamos a comprobarlo.

124
00:07:18,230 --> 00:07:23,540
Presionamos de nueva cuenta en este hover, volvemos a entrar y se manda a imprimir la variable de número.

125
00:07:23,720 --> 00:07:29,960
Ahora en la línea diez se incrementa nuestra variable de contador y también se revisa la variable de

126
00:07:29,960 --> 00:07:30,560
condición.

127
00:07:30,710 --> 00:07:33,440
Podemos observar que la variable de contador ya se incrementó en uno.

128
00:07:33,710 --> 00:07:37,730
Ahora ya vale cinco y la condición también sigue siendo todavía verdadera.

129
00:07:38,150 --> 00:07:42,660
Vamos a mandarlo a imprimir y podemos observar que la condición corresponde con este valor.

130
00:07:42,680 --> 00:07:45,370
Se pregunta si cinco es menor o igual que cinco.

131
00:07:45,380 --> 00:07:49,550
Cinco no es menor que cinco, pero si es igual, por lo tanto todavía regresa verdadero.

132
00:07:50,090 --> 00:07:51,830
Así que esta condición es verdadera.

133
00:07:52,040 --> 00:07:53,060
Volvemos a ejecutar.

134
00:07:53,060 --> 00:07:55,130
Se manda a imprimir el valor de cinco.

135
00:07:55,400 --> 00:07:59,120
Se incrementa la variable de contador y mandamos a imprimir la expresión.

136
00:07:59,300 --> 00:08:03,480
Entonces en memoria sucede lo siguiente se incrementa la variable de contador.

137
00:08:03,530 --> 00:08:05,480
La variable de contador ya vale seis.

138
00:08:05,720 --> 00:08:10,820
Y entonces, al momento de evaluar en su expresión la variable de condición ya tiene el valor de cero.

139
00:08:11,090 --> 00:08:13,130
Tal como lo tenemos también en nuestra impresión.

140
00:08:13,370 --> 00:08:17,090
Así que en este momento se revisa la expresión si seis es menor o igual que cinco.

141
00:08:17,360 --> 00:08:19,100
En este caso ya es falsa la expresión.

142
00:08:19,100 --> 00:08:20,330
Por lo tanto regresa a cero.

143
00:08:20,600 --> 00:08:25,160
Y entonces la siguiente vez que se vuelva a evaluar nuestra condición, esta condición ya sabemos que

144
00:08:25,160 --> 00:08:26,540
va a tener el valor de falso.

145
00:08:26,750 --> 00:08:32,660
Por lo tanto, ya no se va a volver a ejecutar este bloque de código y nos vamos a ir directamente a

146
00:08:32,660 --> 00:08:36,380
la línea 15 para mandar a imprimir, que ya estamos fuera del ciclo while.

147
00:08:36,680 --> 00:08:37,700
Vamos a comprobarlo.

148
00:08:37,910 --> 00:08:42,340
Si presionamos el botón de este hover en este momento ya estamos fuera del ciclo while.

149
00:08:42,500 --> 00:08:46,270
Por lo tanto, en memoria se destruye la variable de condición.

150
00:08:46,280 --> 00:08:51,080
Ya terminó nuestro ciclo while, se destruye esa variable y solamente queda en memoria la variable de

151
00:08:51,080 --> 00:08:54,080
contador con el valor de seis y la variable de repeticiones.

152
00:08:54,350 --> 00:08:55,530
Este valor nunca cambió.

153
00:08:55,550 --> 00:08:58,640
Por lo tanto, el valor de esta variable puede ser una constante.

154
00:08:59,070 --> 00:08:59,260
Bien.

155
00:08:59,300 --> 00:09:00,830
Pero de momento así lo hemos definido.

156
00:09:01,280 --> 00:09:02,870
Y por último volvemos a ejecutar.

157
00:09:03,050 --> 00:09:04,340
Podemos llevar el mensaje.

158
00:09:04,350 --> 00:09:06,150
Ya estamos fuera del ciclo usual.

159
00:09:06,260 --> 00:09:10,160
Y básicamente con esto ya llegamos al final de la ejecución de nuestro programa.

160
00:09:10,400 --> 00:09:15,350
Bien, vamos a ejecutarlo y termina también la ejecución de nuestro programa y por lo tanto se van a

161
00:09:15,350 --> 00:09:20,660
destruir también de memoria las variables de contador y la variable de repeticiones.

162
00:09:20,960 --> 00:09:26,120
Así que al momento de terminar de ejecutar nuestro método main, también estas variables se van a destruir

163
00:09:26,120 --> 00:09:26,750
de memoria.

164
00:09:27,050 --> 00:09:31,490
Por último, quitamos el punto de ruptura y con esto terminamos la ejecución paso a paso de nuestro

165
00:09:31,490 --> 00:09:32,030
ejercicio.

166
00:09:32,300 --> 00:09:36,170
Les pedimos que también lo hagan en su equipo, ya que es muy importante que se familiaricen con este

167
00:09:36,170 --> 00:09:37,730
concepto de ejecución paso a paso.

168
00:09:37,940 --> 00:09:41,810
Esto les va a permitir resolver muchos problemas al momento de realizar sus programas.

169
00:09:42,100 --> 00:09:45,260
Bien, pongan en práctica lo que hemos visto y nos vemos en la siguiente lección.

170
00:09:45,470 --> 00:09:46,010
Saludos.
