1
00:00:01,260 --> 00:00:02,100
Hola y bienvenidos.

2
00:00:02,190 --> 00:00:04,530
Vamos a ver la ejecución paso a paso de nuestra función.

3
00:00:04,680 --> 00:00:05,440
Están listos?

4
00:00:05,520 --> 00:00:06,000
Vamos.

5
00:00:07,090 --> 00:00:11,350
Bien debido a que queremos ejecutar paso a paso este código, de momento vamos a asignar valores en

6
00:00:11,350 --> 00:00:15,490
código a nuestras variables para que podamos ejecutarlo paso a paso sin ningún problema.

7
00:00:15,850 --> 00:00:20,980
Así que vamos a quitar este código y ahora la variable de argumento A le voy a asignar el valor de dos

8
00:00:21,430 --> 00:00:23,530
y la variable de argumento b el valor de tres.

9
00:00:24,130 --> 00:00:28,180
La variable de resultado va almacenar el valor que retorne la función de sumar.

10
00:00:28,780 --> 00:00:33,310
Así que vamos a agregar un punto de ruptura en la línea 11 para poder ejecutar paso a paso.

11
00:00:33,610 --> 00:00:35,620
Así que presionamos el botón de este hover.

12
00:00:37,520 --> 00:00:40,160
Íbamos a comenzar con la ejecución paso a paso de nuestro programa.

13
00:00:40,520 --> 00:00:45,290
En la parte inferior podemos llevar también que de momento se está ejecutando la función main, pero

14
00:00:45,290 --> 00:00:50,030
en un momento más vamos a ver cómo se agrega a la pila de llamadas la llamada de la función sumar.

15
00:00:50,210 --> 00:00:54,620
Así que de manera muy similar a nuestra animación que estamos agregando, también el IDE nos muestra

16
00:00:54,620 --> 00:00:55,830
este tipo de información.

17
00:00:55,850 --> 00:00:59,960
Sin embargo, no es tan visual, pero sí puede ayudarnos Para conocer un poco más del detalle de la

18
00:00:59,960 --> 00:01:02,300
ejecución paso a paso de nuestras funciones.

19
00:01:02,640 --> 00:01:08,330
Bien, así que en primer lugar, ejecutamos la línea 11, presionamos Step Over y entonces en memoria

20
00:01:08,330 --> 00:01:09,320
se crean nuestras variables.

21
00:01:09,320 --> 00:01:14,270
Argumento va con el valor de dos y la variable argumento V con el valor de tres, tal cual los valores

22
00:01:14,270 --> 00:01:18,970
que le hemos asignado a nuestras variables y también si vamos a la parte inferior en localhost, podemos

23
00:01:18,980 --> 00:01:20,620
ver que también se han creado estas variables.

24
00:01:20,630 --> 00:01:25,730
Argumento A con el valor de dos y argumento B con el valor de tres y también la variable de resultado,

25
00:01:25,730 --> 00:01:27,500
pero de momento tiene un valor basura.

26
00:01:27,950 --> 00:01:29,120
Bien, vamos a continuar.

27
00:01:29,360 --> 00:01:31,220
En este caso ya estamos en la línea 13.

28
00:01:31,430 --> 00:01:36,530
Si queremos entrar al detalle de la función de sumar en lugar de este hover, vamos a presionar el botón

29
00:01:36,530 --> 00:01:38,150
de este pin, como ya sabemos.

30
00:01:38,540 --> 00:01:44,450
Así que presionamos este pin para entrar al detalle de la función y entonces en memoria se manda llamar

31
00:01:44,450 --> 00:01:45,560
nuestra función sumar.

32
00:01:45,800 --> 00:01:50,060
Podemos observar que se agrega a la pila de llamadas de nuestras funciones y también en nuestro IDE

33
00:01:50,060 --> 00:01:55,010
podemos observar que se ha mandado a llamar la función de sumar y esta es la función que se está ejecutando

34
00:01:55,010 --> 00:01:55,940
en este momento.

35
00:01:56,180 --> 00:02:00,770
Simplemente el orden es distinto, ya que aquí se están agregando las funciones hacia abajo y en este

36
00:02:00,770 --> 00:02:04,730
caso la función que se está ejecutando en este momento está hasta arriba, pero es prácticamente lo

37
00:02:04,730 --> 00:02:07,910
mismo, solamente es la forma en que se está animando todo este código.

38
00:02:08,420 --> 00:02:13,820
Bien, entonces ya sabemos que tenemos la función sumar, es la que se está ejecutando en este momento

39
00:02:14,060 --> 00:02:18,770
y la función de main se pone en pausa y entonces hasta que no termine de ejecutarse, la función de

40
00:02:18,770 --> 00:02:20,840
sumar no continúa la función de main.

41
00:02:21,260 --> 00:02:25,190
Lo mismo podemos observar en nuestra animación del lado derecho la memoria stack.

42
00:02:25,460 --> 00:02:29,960
Tenemos en pausa la función principal y se está ejecutando en este momento la función de sumar.

43
00:02:30,260 --> 00:02:33,430
Y también se van a crear estas variables con los siguientes valores Bien.

44
00:02:33,530 --> 00:02:35,960
Así que se ejecuta la llamada de la función de sumar.

45
00:02:36,200 --> 00:02:39,260
Entonces se pasa una copia de los argumentos.

46
00:02:40,100 --> 00:02:47,000
El argumento A le pasa una copia del valor a la variable A y también el argumento B le pasa una copia

47
00:02:47,000 --> 00:02:54,050
del valor al parámetro B, así que se pasa una copia de cada una de estas variables en el orden en que

48
00:02:54,050 --> 00:02:54,890
se han declarado.

49
00:02:55,100 --> 00:02:58,880
En este caso podemos observar que se manda la información de izquierda a derecha.

50
00:02:59,030 --> 00:03:00,860
Así es como se lee esta información.

51
00:03:01,100 --> 00:03:05,150
Así que realmente lo que sucede se encuentra primero esta variable y entonces también de izquierda a

52
00:03:05,150 --> 00:03:07,160
derecha se asignan estos valores.

53
00:03:07,370 --> 00:03:11,840
Posteriormente, después de la coma, continuamos con la siguiente información Y así es como se van

54
00:03:11,840 --> 00:03:13,130
asignando estos valores.

55
00:03:14,100 --> 00:03:17,870
Se van leyendo de izquierda a derecha y posteriormente en la línea cinco.

56
00:03:17,880 --> 00:03:23,880
Si la ejecutamos, entonces se revisa la suma de ambas B y se asigna este valor a la variable de resultado

57
00:03:23,880 --> 00:03:24,240
suma.

58
00:03:24,600 --> 00:03:26,490
Así que en nuestra memoria tenemos lo siguiente.

59
00:03:26,700 --> 00:03:29,850
La variable de resultado suma se le asigna el valor de cinco.

60
00:03:30,270 --> 00:03:35,130
Ahora, para que este valor no se pierda, entonces precisamente lo que vamos a hacer es regresar este

61
00:03:35,130 --> 00:03:35,490
valor.

62
00:03:35,490 --> 00:03:41,520
Por ello la palabra return se regresa a la llamada de la función principal y este valor que se regresa

63
00:03:41,520 --> 00:03:43,860
se asigna a la variable de resultado.

64
00:03:45,170 --> 00:03:48,560
Así que ejecutamos la línea seis, presionamos este hover.

65
00:03:49,220 --> 00:03:54,470
Entonces, en nuestra animación podemos observar que se termina de ejecutar la llamada de la función

66
00:03:54,470 --> 00:03:58,100
de sumar, pero se regresó el valor a la variable de resultado.

67
00:03:58,310 --> 00:04:03,230
Así que nuestra variable de resultado ya tiene almacenada esta información, así que se presionamos.

68
00:04:03,230 --> 00:04:06,700
Este hover se termina de llamar a la función de sumar.

69
00:04:06,710 --> 00:04:11,600
Podemos llevar también aquí en el IDE que ya se quitó la llamada de nuestra función de sumar y ya estamos

70
00:04:11,600 --> 00:04:15,350
de nueva cuenta en nuestro método principal ejecutando la línea 14.

71
00:04:15,620 --> 00:04:19,820
Y también del lado derecho podemos observar que la variable de resultado ya tiene el valor de cinco.

72
00:04:20,060 --> 00:04:24,500
Así que toda esta información también la tenemos en nuestro IDE, pero les estamos agregando esta animación

73
00:04:24,500 --> 00:04:27,560
para que sea todavía más visual y más clara de lo que está sucediendo.

74
00:04:28,250 --> 00:04:30,140
Así que vamos a ejecutar ahora la línea 14.

75
00:04:30,140 --> 00:04:34,910
Presionamos este hover y entonces en la salida podemos llevar el resultado de la suma.

76
00:04:35,150 --> 00:04:36,230
Es igual a cinco.

77
00:04:36,440 --> 00:04:40,820
Se está mandando a imprimir el valor de la variable de resultado, así que se manda a imprimir este

78
00:04:40,820 --> 00:04:42,680
valor el valor de cinco.

79
00:04:42,830 --> 00:04:47,540
Pero ya sabemos que también podríamos mandar a imprimir directamente la llamada de la función sumar

80
00:04:47,540 --> 00:04:52,310
y el resultado de mandar a llamar a esa función también aquí se imprimiría, así que también se imprimiría

81
00:04:52,310 --> 00:04:56,920
exactamente este mismo valor el valor de cinco, y así podríamos ahorrar esta variable.

82
00:04:56,930 --> 00:05:01,430
Pero debido a que estamos comenzando, de momento lo estamos separando para que todo quede completamente

83
00:05:01,430 --> 00:05:01,820
claro.

84
00:05:02,570 --> 00:05:03,440
Así que esta es la ejecución.

85
00:05:03,440 --> 00:05:03,980
Paso a paso.

86
00:05:03,980 --> 00:05:04,880
Vamos a terminar.

87
00:05:05,090 --> 00:05:10,520
Presionamos de nueva cuenta este hover y de nueva cuenta este hover para que podamos salir de la ejecución

88
00:05:10,520 --> 00:05:11,300
de nuestro programa.

89
00:05:11,810 --> 00:05:16,520
Quitamos el punto de ruptura y con esto ya hemos terminado la ejecución paso a paso de nuestro programa.

90
00:05:16,820 --> 00:05:22,550
Y al final también recordemos que si se termina de ejecutar nuestro método principal, entonces también

91
00:05:22,550 --> 00:05:27,740
se quita de la memoria estas variables y también la llamada al método principal.

92
00:05:29,470 --> 00:05:33,670
Bien, así que pongan en práctica la ejecución paso a paso de la función que hemos trabajado y nos vemos

93
00:05:33,670 --> 00:05:34,540
en el siguiente vídeo.

94
00:05:34,690 --> 00:05:35,230
Saludos.
