1
00:00:01,010 --> 00:00:01,900
Hola y bienvenidos.

2
00:00:01,970 --> 00:00:05,430
Vamos a ver a continuación la ejecución paso a paso de nuestro procedimiento.

3
00:00:05,540 --> 00:00:06,350
Están listos?

4
00:00:06,440 --> 00:00:06,920
Vamos.

5
00:00:08,050 --> 00:00:13,450
Bien, va a ser muy importante que podamos entender a detalle la ejecución paso a paso de una función,

6
00:00:13,450 --> 00:00:15,130
en este caso de nuestro procedimiento.

7
00:00:15,370 --> 00:00:20,110
Así que para poder ejecutar nuestro procedimiento paso a paso desde nuestro método principal, vamos

8
00:00:20,110 --> 00:00:21,460
a agregar un punto de ruptura.

9
00:00:21,730 --> 00:00:26,140
Sin embargo, en este caso, el punto de ruptura no lo podemos agregar si es que no asignamos un valor

10
00:00:26,140 --> 00:00:27,010
a nuestra variable.

11
00:00:27,220 --> 00:00:32,650
Así que de momento voy a quitar estas líneas de código y le voy a asignar un valor en código duro a

12
00:00:32,650 --> 00:00:33,490
nuestro argumento.

13
00:00:33,730 --> 00:00:36,580
Le voy a asignar el valor de diez a nuestra variable de argumento.

14
00:00:37,030 --> 00:00:37,290
Bien.

15
00:00:37,510 --> 00:00:39,940
Y entonces ahora sí, ya podemos agregar un punto de ruptura.

16
00:00:40,150 --> 00:00:44,110
Esto ya sería una línea válida, ya que estamos asignando un valor a una variable.

17
00:00:44,680 --> 00:00:48,940
Así que una vez que hemos establecido el punto de ruptura, vamos a presionar el botón de debug para

18
00:00:48,940 --> 00:00:50,650
comenzar la ejecución paso a paso.

19
00:00:51,100 --> 00:00:53,440
Así que hacemos lo siguiente Presionamos el botón de debug.

20
00:00:54,530 --> 00:00:58,650
Y agregamos nuestras ventanas, la ventana de salida, la consola y también nuestra animación.

21
00:00:58,700 --> 00:01:03,020
Recordemos que esta ventana no es parte del hide, es una animación que la estamos agregando por separado.

22
00:01:03,390 --> 00:01:08,930
Bien, entonces ejecutamos la línea diez para poder ejecutar la presionamos el botón de este hover,

23
00:01:09,230 --> 00:01:11,960
así que en ese momento se crea nuestra variable de argumento.

24
00:01:11,960 --> 00:01:14,240
Es una variable local, pero a nuestro método main.

25
00:01:14,240 --> 00:01:15,440
Como podemos observar.

26
00:01:15,440 --> 00:01:16,910
Y se le asigna el valor de días.

27
00:01:17,150 --> 00:01:21,890
Ahora, para pasar el control a nuestra función de imprimir, vamos a utilizar un botón diferente.

28
00:01:22,190 --> 00:01:27,620
Recordemos que de momento veníamos utilizando el botón de este hover, pero ese botón ejecuta la línea

29
00:01:27,620 --> 00:01:31,150
por completo sin entrar al detalle de la ejecución de nuestra función.

30
00:01:31,160 --> 00:01:36,080
Pero en este caso, debido a que si queremos entrar al detalle de la función, en este caso del procedimiento,

31
00:01:36,260 --> 00:01:38,360
entonces presionamos el botón de este bin.

32
00:01:38,690 --> 00:01:41,270
Incluso podemos observar el pequeño icono que nos muestra.

33
00:01:41,420 --> 00:01:43,880
Estamos entrando al detalle de la función.

34
00:01:43,970 --> 00:01:48,320
En cambio, el botón de este hover solamente ejecuta la línea sin entrar al detalle de la función.

35
00:01:48,800 --> 00:01:53,630
Así que vamos a presionar este botón de este pin y podemos ver que se pone en pausa la ejecución del

36
00:01:53,630 --> 00:01:54,650
programa principal.

37
00:01:55,250 --> 00:01:58,580
En nuestra animación podemos llevar que el método Main está en pausa.

38
00:01:59,150 --> 00:02:04,910
Aquí podemos ver que está en ejecución el método de imprimir y de manera interna se define la variable

39
00:02:04,940 --> 00:02:06,260
local de parámetro.

40
00:02:06,410 --> 00:02:10,760
Así que ahora se le va a pasar una copia del valor de argumento hacia la variable de parámetro.

41
00:02:11,180 --> 00:02:14,870
Y aquí vemos más claramente los conceptos entre argumento y parámetro.

42
00:02:15,110 --> 00:02:20,000
El argumento es la información que se va a pasar a nuestra función y el parámetro es la variable local

43
00:02:20,000 --> 00:02:24,770
definida dentro de nuestro método, el cual recibe la información enviada a esta función.

44
00:02:24,920 --> 00:02:26,690
En este caso, a este procedimiento.

45
00:02:26,930 --> 00:02:31,730
Así que se le pasa una copia del valor de este argumento a nuestra variable de parámetro.

46
00:02:32,250 --> 00:02:35,690
Bien, ahora ya estamos en la línea cinco y se ejecutamos esta línea.

47
00:02:35,930 --> 00:02:38,720
Esta línea no tenemos que entrar al detalle del método print.

48
00:02:38,900 --> 00:02:44,540
Por lo tanto, podemos presionar el botón de este hover y entonces vemos en consola el valor recibido

49
00:02:44,540 --> 00:02:47,060
es el valor recibido es el valor de días.

50
00:02:47,330 --> 00:02:51,620
Así que de esta manera se manda a imprimir la información que estamos recibiendo en nuestro método.

51
00:02:51,890 --> 00:02:56,660
De momento todavía se encuentra en memoria esta variable, pero una vez que termine de ejecutarse este

52
00:02:56,660 --> 00:03:00,020
método, ya estamos en la línea seis, que es la última línea de este método.

53
00:03:00,140 --> 00:03:05,210
Por lo tanto, se va a destruir la llamada de esta función y también se destruye la variable de parámetro.

54
00:03:05,300 --> 00:03:09,840
Y podemos ver que cada vez que se manda a llamar una función se agrega también a la memoria stack.

55
00:03:10,010 --> 00:03:15,020
Así que las llamadas de las funciones también se van apilando, se van llamando en sí una tras otra,

56
00:03:15,200 --> 00:03:17,930
según tantas llamadas como hagamos a diferentes funciones.

57
00:03:18,110 --> 00:03:22,610
Esto lo vamos a ver también a detalle más adelante, pero podemos observar en esta animación que también

58
00:03:22,610 --> 00:03:25,520
la llamada a las funciones se agregará a la memoria stack.

59
00:03:25,790 --> 00:03:27,840
Bien, entonces ejecutamos la línea seis.

60
00:03:27,890 --> 00:03:29,810
Vamos a presionar el botón de este hover.

61
00:03:30,140 --> 00:03:35,990
Podemos llevar que regresamos a la función principal a la línea 13 y entonces en memoria lo que sucede

62
00:03:35,990 --> 00:03:41,270
es lo siguiente se quita de la memoria el procedimiento de imprimir y también se elimina de la memoria

63
00:03:41,270 --> 00:03:42,530
la variable de parámetro.

64
00:03:42,770 --> 00:03:45,800
Y ahora continuamos con la ejecución del método principal.

65
00:03:46,130 --> 00:03:52,730
Ahora, en la línea 13 podemos volver a presionar el botón de este punto para volver a ejecutar la función.

66
00:03:52,970 --> 00:03:57,680
Así que en memoria se vuelve a crear una llamada a la función de imprimir y se le va a asignar ahora

67
00:03:57,680 --> 00:03:58,910
otro valor de parámetro.

68
00:03:59,150 --> 00:04:04,070
Recordemos que ahora la información que le estamos pasando es el argumento de 100 y se va a asignar

69
00:04:04,070 --> 00:04:05,270
a la variable de parámetro.

70
00:04:05,450 --> 00:04:09,530
Así que en este caso ya no estamos usando este argumento, sino que le estamos enviando directamente

71
00:04:09,530 --> 00:04:12,980
este valor de 100 y se la asigna a la variable de parámetro.

72
00:04:13,430 --> 00:04:15,600
Así que se le pasó una copia de este valor.

73
00:04:15,680 --> 00:04:20,300
Bien, vamos a ejecutar esta línea presionando este hover y entonces se manda a imprimir el valor de

74
00:04:20,300 --> 00:04:20,510
100.

75
00:04:20,510 --> 00:04:23,390
Como podemos observar, ya es la última línea de nuestro método.

76
00:04:23,390 --> 00:04:28,220
Así que de nueva cuenta, si presionamos este hover, entonces de memoria se va a quitar la llamada

77
00:04:28,220 --> 00:04:29,300
de la función imprimir.

78
00:04:29,660 --> 00:04:33,470
Podemos ver que se quita la llamada y regresamos a la función principal.

79
00:04:33,650 --> 00:04:39,170
En este caso estamos en la línea 14 y si volvemos a presionar este punto vamos a entrar al detalle del

80
00:04:39,170 --> 00:04:40,050
procedimiento.

81
00:04:40,070 --> 00:04:45,380
Pero si ya no queremos entrar al detalle, simplemente presionamos este hover y podemos ver que se manda

82
00:04:45,380 --> 00:04:48,310
a imprimir directamente el valor de 200.

83
00:04:48,320 --> 00:04:49,610
Ya no entramos al detalle.

84
00:04:49,640 --> 00:04:54,440
Así que en la animación ya no se vio ese detalle, pero simplemente es lo mismo que ya vimos en la ejecución

85
00:04:54,440 --> 00:04:55,810
de cualquiera de estas llamadas.

86
00:04:55,880 --> 00:04:58,880
Pero si presionamos este hover ya no se ve este detalle.

87
00:04:59,210 --> 00:05:02,000
Bien, con esto entonces ya estamos en la línea 16.

88
00:05:02,030 --> 00:05:05,630
Ya se mandaron a imprimir los tres valores de 100 y 200.

89
00:05:05,900 --> 00:05:09,140
Ya sabemos cómo reutilizar este bloque de código de la función de imprimir.

90
00:05:09,350 --> 00:05:12,200
Simplemente lo mandamos a llamar las veces que sea necesario.

91
00:05:12,440 --> 00:05:17,460
Podemos observar que el método principal también a su vez es una función y entonces esta función regresa

92
00:05:17,460 --> 00:05:22,790
a un valor de tipo entero y por ello, si todo funciona correctamente, al final retornamos el valor

93
00:05:22,790 --> 00:05:23,270
de cero.

94
00:05:23,420 --> 00:05:27,990
Si retorna el valor de cero, quiere decir que la ejecución de nuestro programa se realizó correctamente.

95
00:05:28,010 --> 00:05:31,430
Si arroja algún valor distinto de cero, entonces ocurrió algún error.

96
00:05:31,610 --> 00:05:36,230
Y ahora, si ya podemos entender a detalle, entonces para que es esta definición del tipo de dato que

97
00:05:36,230 --> 00:05:39,740
va a regresar una función y también el tipo retornado, el valor de cero.

98
00:05:40,200 --> 00:05:42,250
Bien, vamos a presionar este hover.

99
00:05:42,320 --> 00:05:47,330
Ya estamos en la última línea de la ejecución de nuestro método principal y entonces ya termina de ejecutarse

100
00:05:47,330 --> 00:05:48,140
nuestro programa.

101
00:05:48,450 --> 00:05:53,720
Bien, podemos quitar el punto de ruptura y con esto terminamos la ejecución paso a paso de un procedimiento.

102
00:05:54,500 --> 00:05:59,300
Como hemos comentado, procedimiento o función es lo mismo, excepto que en este caso un procedimiento

103
00:05:59,300 --> 00:06:04,310
no regresa ningún tipo de información, solamente se manda a llamar, pero en estos casos no estamos

104
00:06:04,310 --> 00:06:07,280
regresando ningún tipo de información al método principal.

105
00:06:07,670 --> 00:06:11,840
Bien, pongan en práctica lo que hemos visto y vamos a continuar con más temas de funciones en el siguiente

106
00:06:11,840 --> 00:06:12,200
video.

107
00:06:12,350 --> 00:06:12,920
Saludos.
