1
00:00:00,720 --> 00:00:01,580
Hola y bienvenidos.

2
00:00:01,590 --> 00:00:06,480
Vamos a ver a continuación la diferencia entre parámetros y argumentos cuando trabajamos con funciones.

3
00:00:06,510 --> 00:00:07,330
Están listos?

4
00:00:07,380 --> 00:00:07,860
Vamos.

5
00:00:09,080 --> 00:00:13,670
Bien, para aclarar este concepto vamos a trabajar con la misma función que vimos en el ejemplo anterior.

6
00:00:13,910 --> 00:00:15,950
Es simplemente la función llamada imprimir.

7
00:00:16,130 --> 00:00:17,630
Ese es el nombre de nuestra función.

8
00:00:17,810 --> 00:00:20,900
Va a recibir cierta información, en este caso la variable de número.

9
00:00:21,050 --> 00:00:22,680
Esta variable es una variable local.

10
00:00:22,700 --> 00:00:23,480
A este método.

11
00:00:23,720 --> 00:00:25,430
Así que de manera interna.

12
00:00:25,640 --> 00:00:30,140
El cuerpo de esta función simplemente manda a imprimir a consola la información que está recibiendo

13
00:00:30,140 --> 00:00:31,310
en esta variable de número.

14
00:00:31,610 --> 00:00:35,930
Por otro lado, ya sabemos que tenemos que mandar a llamar nuestra función para que realmente se ejecute.

15
00:00:36,170 --> 00:00:40,670
Así que desde el programa principal podemos tener ciertas líneas de código, pero en cierto momento

16
00:00:40,670 --> 00:00:42,430
vamos a mandar a llamar nuestra función.

17
00:00:42,530 --> 00:00:46,850
Sin embargo, para aclarar el concepto entre parámetro y argumento, en primer lugar vamos a definir

18
00:00:46,850 --> 00:00:47,600
una variable.

19
00:00:47,930 --> 00:00:51,650
Esta variable va a ser la información que vamos a pasar a la función de imprimir.

20
00:00:51,860 --> 00:00:55,730
Así que en cierto momento vamos a mandar a llamar la función de imprimir.

21
00:00:56,030 --> 00:01:00,470
Pero en este caso podemos observar que le estamos pasando la variable y entonces la función de imprimir

22
00:01:00,470 --> 00:01:03,650
recibe esta información almacenada en nuestra variable.

23
00:01:03,860 --> 00:01:06,350
Así que aquí viene la aclaración del concepto de argumento.

24
00:01:06,620 --> 00:01:11,000
Un argumento es la información, el valor que se envía a una función.

25
00:01:11,240 --> 00:01:15,650
Así que por ello la información que pasamos a una función se le conoce como argumento.

26
00:01:16,160 --> 00:01:21,170
Y por otro lado, para entender el concepto de parámetro, cuando ejecutamos nuestra función principal

27
00:01:21,170 --> 00:01:25,820
y se manda a llamar la función de imprimir, recordemos que en este caso la función principal se pone

28
00:01:25,820 --> 00:01:31,670
en pausa y ahora se cede el control para que se pueda ejecutar la función de imprimir y en este caso

29
00:01:31,670 --> 00:01:36,140
se crea la variable de número en memoria y a esto se le conoce como parámetro.

30
00:01:36,410 --> 00:01:41,930
Así que los parámetros de una función son las variables locales definidas en nuestra función para poder

31
00:01:41,930 --> 00:01:43,940
recibir el valor de los argumentos.

32
00:01:44,180 --> 00:01:49,010
Así que en este caso la variable de parámetro es una variable local a nuestro método imprimir.

33
00:01:49,160 --> 00:01:54,020
Por lo tanto, la variable de número sería nuestro parámetro y el valor de la variable se le va a asignar

34
00:01:54,020 --> 00:01:55,310
a esta variable de número.

35
00:01:55,460 --> 00:02:00,770
Por lo tanto, el parámetro se inicializa con el valor de 100 y entonces podemos separar los dos conceptos.

36
00:02:00,920 --> 00:02:05,810
La información que se envía a una función van a ser los argumentos y las variables que se definen en

37
00:02:05,810 --> 00:02:07,670
nuestro método son los parámetros.

38
00:02:08,000 --> 00:02:13,820
Así que este parámetro va a recibir la información, en este caso el valor de nuestro argumento, el

39
00:02:13,820 --> 00:02:14,420
valor de 100.

40
00:02:14,780 --> 00:02:16,880
Sin embargo, esta diferencia es bastante técnica.

41
00:02:16,880 --> 00:02:19,010
Simplemente es para que ustedes sepan la diferencia.

42
00:02:19,010 --> 00:02:24,410
Pero pueden encontrarse que en muchos casos parámetro o argumento lo manejan exactamente igual, debido

43
00:02:24,410 --> 00:02:27,820
a que simplemente es información que se pasa a nuestra función.

44
00:02:27,830 --> 00:02:32,630
Por lo tanto, se le puede manejar de manera similar tanto parámetro o argumento, ya que simplemente

45
00:02:32,630 --> 00:02:35,630
es información que se pasa o que se recibe en una función.

46
00:02:35,750 --> 00:02:40,580
Pero al final de cuentas el objetivo es exactamente el mismo simplemente pasar información a nuestra

47
00:02:40,580 --> 00:02:41,120
función.

48
00:02:41,540 --> 00:02:41,680
Bien.

49
00:02:41,810 --> 00:02:46,820
Y entonces, una vez que ya se han inicializado los parámetros de nuestra función, entonces se empieza

50
00:02:46,820 --> 00:02:48,580
a ejecutar el cuerpo de nuestra función.

51
00:02:48,650 --> 00:02:53,480
En este caso se manda a imprimir la variable de número a consola y se imprime el valor de 100.

52
00:02:53,780 --> 00:02:58,610
Una vez que termina de ejecutarse este método, se destruyen los parámetros, las variables que se hayan

53
00:02:58,610 --> 00:03:00,200
definido dentro de este método.

54
00:03:00,410 --> 00:03:05,540
Así que en este caso la variable de parámetro, la variable de número ya se destruyó y se cede el control

55
00:03:05,540 --> 00:03:09,020
de nueva cuenta a nuestra función principal y continúa la ejecución.

56
00:03:09,020 --> 00:03:13,940
Se reanuda la ejecución del programa principal y una vez que termina la ejecución del programa principal,

57
00:03:13,940 --> 00:03:16,250
entonces termina la ejecución de todo nuestro programa.

58
00:03:16,850 --> 00:03:20,330
Y con esto, entonces tenemos la diferencia entre parámetro y argumento.

59
00:03:21,080 --> 00:03:24,170
Ahora vamos a ver la diferencia entre procedimiento y función.

60
00:03:24,350 --> 00:03:29,540
Básicamente, la diferencia es muy sencilla un procedimiento no regresa ningún tipo de información.

61
00:03:29,720 --> 00:03:32,930
Por lo tanto, una función como en este caso la función de imprimir.

62
00:03:32,930 --> 00:03:35,780
Podemos observar que el tipo de retorno es de tipo void.

63
00:03:35,990 --> 00:03:39,080
Esto quiere decir que no va a regresar ningún tipo de información.

64
00:03:39,260 --> 00:03:42,170
En este caso puede recibir información de manera opcional.

65
00:03:42,200 --> 00:03:47,390
Por ello es que estamos definiendo la variable de parámetro y de manera interna solamente manda imprimir

66
00:03:47,390 --> 00:03:51,890
información a consola, pero podemos observar que no va a regresar ningún tipo de información.

67
00:03:51,890 --> 00:03:56,270
Por ello es que no se utiliza la palabra reservada return debido a que no va a regresar ningún tipo

68
00:03:56,270 --> 00:03:57,050
de información.

69
00:03:57,270 --> 00:04:02,990
Y entonces, en primer lugar, se define nuestro procedimiento y cuando se manda llamar nuestro procedimiento

70
00:04:02,990 --> 00:04:07,730
desde el programa principal, podemos ver que simplemente se manda a llamar, pero no está regresando

71
00:04:07,730 --> 00:04:09,020
ningún tipo de información.

72
00:04:09,170 --> 00:04:14,690
Así que cuando se ejecuta el programa, se cede el control a la función de imprimir, se ejecuta la

73
00:04:14,690 --> 00:04:19,250
función de imprimir y al momento en que termina simplemente se mandan a imprimir la información de 100

74
00:04:19,520 --> 00:04:24,710
y entonces al terminar no regresa ningún tipo de información, ningún tipo de valor al programa principal.

75
00:04:24,710 --> 00:04:28,640
Simplemente se cede el control y continuamos con la ejecución de nuestro programa.

76
00:04:28,880 --> 00:04:33,470
Por lo tanto, la función de imprimir solamente regresa el control, pero no recibió ningún otro valor

77
00:04:33,470 --> 00:04:34,310
para procesar.

78
00:04:34,490 --> 00:04:38,930
Así que continuamos con la ejecución de nuestro programa y termina de ejecutarse este procedimiento.

79
00:04:39,170 --> 00:04:42,080
Sin embargo, podemos ver que es prácticamente lo mismo que una función.

80
00:04:42,140 --> 00:04:45,590
La única diferencia es que no va a regresar ningún tipo de información.

81
00:04:45,860 --> 00:04:48,420
Ahora, vamos a ver entonces en qué consiste una función.

82
00:04:48,470 --> 00:04:52,700
Básicamente, una función si regresa un valor al terminar de ejecutarse.

83
00:04:52,970 --> 00:04:54,980
Así que vamos a ver un ejemplo de una función.

84
00:04:55,220 --> 00:05:00,410
Vamos a definir en primer lugar la función de sumar, pero ya desde la definición de esta función podemos

85
00:05:00,410 --> 00:05:05,180
observar que sí va a regresar un tipo de dato, en este caso un valor de tipo entero.

86
00:05:05,600 --> 00:05:08,510
Entonces definimos nuestras variables, por ejemplo, las variables.

87
00:05:08,760 --> 00:05:11,730
Y B, que son los parámetros que va a recibir esta función.

88
00:05:11,910 --> 00:05:17,850
Y entonces el cuerpo de esta función lo que va a hacer es regresar la suma de los valores de A y B.

89
00:05:18,060 --> 00:05:23,520
Así que en este caso definimos una variable llamada resultado de tipo de dato entero y va almacenar

90
00:05:23,520 --> 00:05:24,900
la suma de ambas b.

91
00:05:25,460 --> 00:05:30,600
Ahora, una vez que ya hemos definido esta variable con el resultado de la suma de ambas B, simplemente

92
00:05:30,600 --> 00:05:36,480
regresamos esta variable y entonces Básicamente esta línea es la diferencia entre una función y un procedimiento.

93
00:05:36,720 --> 00:05:38,850
En este caso, si estamos regresando un valor.

94
00:05:38,850 --> 00:05:43,740
Pero este valor tiene que ser exactamente del tipo que hemos indicado al momento de definir nuestra

95
00:05:43,740 --> 00:05:44,250
función.

96
00:05:44,640 --> 00:05:47,670
Así que este valor de resultado tiene que ser un valor de tipo entero.

97
00:05:47,970 --> 00:05:50,220
De lo contrario, va a marcar un error de compilación.

98
00:05:50,710 --> 00:05:53,280
Bien, pero esta es apenas la definición de nuestra función.

99
00:05:53,550 --> 00:05:58,280
Ahora, nuestras funciones no necesariamente se tienen que mandar a llamar desde la función principal.

100
00:05:58,290 --> 00:06:00,770
Podemos mandarla desde cualquier otra función.

101
00:06:00,780 --> 00:06:05,100
Sin embargo, en este caso, como estamos comenzando, las funciones que vamos a definir normalmente

102
00:06:05,100 --> 00:06:08,490
las vamos a mandar a llamar desde la función principal, el método main.

103
00:06:08,730 --> 00:06:10,580
Pero ya sabemos que no tiene que ser así.

104
00:06:10,590 --> 00:06:14,460
Las funciones que definamos las podemos mandar a llamar desde cualquier otra función.

105
00:06:14,810 --> 00:06:19,200
Bien, entonces posteriormente vamos a hacer la llamada de nuestra función desde el programa principal.

106
00:06:19,530 --> 00:06:25,490
Así que vamos a definir nuestras variables A y B, la variable A con el valor de dos y la variable B

107
00:06:25,500 --> 00:06:26,490
con el valor de tres.

108
00:06:26,760 --> 00:06:30,540
Estas variables no tienen que llamarse igual que los parámetros de la función.

109
00:06:30,540 --> 00:06:31,860
Puede ser cualquier otro nombre.

110
00:06:32,070 --> 00:06:34,020
Y además también definimos una variable c.

111
00:06:34,260 --> 00:06:39,090
Esta variable c es la que va a almacenar el resultado que va a regresar la función de sumar.

112
00:06:39,330 --> 00:06:44,100
Así que en este caso podemos observar que la diferencia es que la función de sumar si va a regresar

113
00:06:44,100 --> 00:06:44,790
un valor.

114
00:06:44,790 --> 00:06:47,150
Así que se manda a llamar la función de sumar.

115
00:06:47,160 --> 00:06:50,790
Pasamos los argumentos que están almacenados en las variables A y B.

116
00:06:50,790 --> 00:06:54,420
Recordemos que el argumento es la información que vamos a pasar hacia la función.

117
00:06:54,630 --> 00:07:00,060
Por lo tanto, las variables A y B serán nuestros argumentos, y esas variables A y B serían los parámetros,

118
00:07:00,060 --> 00:07:05,340
es decir, las variables locales que van a recibir la información que le vamos a pasar a nuestra función.

119
00:07:05,490 --> 00:07:09,990
Sin embargo, estas variables, aunque es común que se llamen iguales, no tienen que llamarse exactamente

120
00:07:09,990 --> 00:07:10,350
igual.

121
00:07:10,560 --> 00:07:14,880
Estos pueden ser cualquier otro nombre, y eso también podría ser cualquier otro nombre, pero es común

122
00:07:14,880 --> 00:07:15,870
que se llamen igual.

123
00:07:16,560 --> 00:07:20,640
Y entonces, una vez que ya hemos recibido el valor que regresa a la función, simplemente mandamos

124
00:07:20,640 --> 00:07:21,810
a imprimir el resultado.

125
00:07:21,960 --> 00:07:26,520
Podemos llevar que en este caso, a diferencia del procedimiento, el procedimiento lo que hizo fue

126
00:07:26,520 --> 00:07:28,800
simplemente mandar a imprimir información a consola.

127
00:07:28,980 --> 00:07:33,660
En este caso, la función de sumar no está mandando a imprimir nada, sino que simplemente procesa la

128
00:07:33,660 --> 00:07:38,610
información, es decir, realiza la suma y regresa un resultado, el resultado de la suma.

129
00:07:38,790 --> 00:07:43,500
Por lo tanto, la impresión ya no proviene de la función de sumar, sino proviene del programa principal.

130
00:07:43,870 --> 00:07:49,200
Bien, ahora si ejecutamos entonces nuestro programa principal, se definen nuestras variables en memoria

131
00:07:49,410 --> 00:07:52,890
y entonces, cuando se van a llamar nuestra función de sumar, se pone en pausa.

132
00:07:52,890 --> 00:07:55,020
El programa principal se manda llamar.

133
00:07:55,050 --> 00:07:56,130
La función de sumar.

134
00:07:56,430 --> 00:08:00,760
Se recibe la información de los argumentos y se quedan en memoria nuestros parámetros.

135
00:08:00,780 --> 00:08:04,560
La variable A con el valor de dos y la variable b con el valor de tres.

136
00:08:04,830 --> 00:08:07,560
Sin embargo, estas variables son locales al método de sumar.

137
00:08:07,710 --> 00:08:12,650
Una vez que termina de ejecutarse en nuestro método sumar se van a destruir estas variables y entonces

138
00:08:12,660 --> 00:08:15,310
empieza a ejecutarse el cuerpo de nuestra función.

139
00:08:15,330 --> 00:08:20,820
Así que la función de sumar simplemente realiza la suma de ambas b, es decir, dos más tres, y esta

140
00:08:20,820 --> 00:08:22,920
suma se asigna a la variable de resultado.

141
00:08:23,250 --> 00:08:26,880
Así que esta variable de resultado es la que contiene la información que queremos retornar.

142
00:08:27,060 --> 00:08:31,830
Por lo tanto, utilizamos la palabra reservada return y regresamos el valor que tenga almacenado la

143
00:08:31,830 --> 00:08:32,940
variable de resultado.

144
00:08:33,120 --> 00:08:36,090
Así que esta es la diferencia principal entre procedimiento y función.

145
00:08:36,240 --> 00:08:40,080
Aquí podemos observar que si vamos a regresar un valor tiene que ser de tipo entero.

146
00:08:40,290 --> 00:08:42,710
El mismo tipo con el que declaramos nuestra función.

147
00:08:42,720 --> 00:08:45,280
Se regresa el control a nuestra función principal.

148
00:08:45,300 --> 00:08:47,550
Una vez que ya termina de ejecutarse nuestro método.

149
00:08:47,550 --> 00:08:50,550
Y entonces en este momento la función de sumar.

150
00:08:50,550 --> 00:08:52,110
Si regresa un valor.

151
00:08:52,110 --> 00:08:55,260
En este caso el valor de cinco y se asigna a la variable c.

152
00:08:55,560 --> 00:09:00,480
Así que aunque no es requerido que procesemos el valor que regresa una función, es normal que la información

153
00:09:00,480 --> 00:09:03,330
que regrese a una función la almacenamos en alguna variable.

154
00:09:03,540 --> 00:09:08,280
Sin embargo, esto no requerido es opcional y una vez que ya tenemos este valor de cinco en la variable

155
00:09:08,280 --> 00:09:13,140
C, continúa la ejecución de nuestro programa principal y simplemente termina por imprimir el valor

156
00:09:13,140 --> 00:09:13,680
de cinco.

157
00:09:13,890 --> 00:09:16,370
Pero ya podemos observar la diferencia entre procedimiento.

158
00:09:16,380 --> 00:09:20,970
El procedimiento no regresó ningún tipo de información, simplemente mandó a imprimir información.

159
00:09:21,150 --> 00:09:22,170
En cambio, una función.

160
00:09:22,170 --> 00:09:25,830
Podemos observar que sí está obligada a regresar cierto tipo de información.

161
00:09:26,100 --> 00:09:29,100
Y esos son los conceptos básicos cuando vamos a trabajar con funciones.

162
00:09:29,400 --> 00:09:33,810
Son términos algo técnicos, pero ahora que empecemos a trabajar con las funciones, vamos a ver que

163
00:09:33,810 --> 00:09:35,010
va a ser bastante sencillo.

164
00:09:35,160 --> 00:09:39,750
Simplemente es familiarizarnos al inicio con estos términos, pero una vez que los empecemos a trabajar,

165
00:09:39,750 --> 00:09:41,520
vamos a ver que todo se va a simplificar.

166
00:09:41,820 --> 00:09:46,230
Bien, vamos a tener hasta aquí y vamos a comenzar con ejemplos de funciones en el siguiente vídeo.

167
00:09:46,380 --> 00:09:46,950
Saludos.
