1
00:00:04,750 --> 00:00:09,720
Bueno me tocó el turno de las funciones anónimas y de los Clausius.

2
00:00:09,740 --> 00:00:17,930
Este capítulo es un capítulo especial dedicado a este tipo de funciones donde se va ya a complejizando

3
00:00:17,930 --> 00:00:25,880
un poco y no solo a complejizando sino se van haciendo más ricas las funciones vamos a ver vamos a tener

4
00:00:25,880 --> 00:00:35,810
que crear un ejercicio O6 vamos a crearlo en nuestra carpeta Goh vamos a crear una carpeta llamada ejercer

5
00:00:35,810 --> 00:00:40,650
O6 y dentro de ejercer Ozai nuestro Moine punto.

6
00:00:40,850 --> 00:00:48,410
Muy bien vamos a copiar y a escribir lo habitual y ahora lo que vamos a hacer es comenzar a explicar

7
00:00:48,410 --> 00:00:55,880
un poco lo de las funciones anónimas las funciones anónimas son funciones que no tienen nombre un yo

8
00:00:55,880 --> 00:01:03,200
puedo crear una variable y asignar la de tipo función para qué sirven para crear operaciones en las

9
00:01:03,200 --> 00:01:11,300
que no voy a necesitar llamar a una función sino que ya de alguna manera y solar todo su código lo voy

10
00:01:11,300 --> 00:01:19,190
a ocultar adentro de una variable y lo voy a poder modificar en tiempo de ejecución algo que con una

11
00:01:19,190 --> 00:01:21,650
función es imposible.

12
00:01:21,650 --> 00:01:30,060
Por ejemplo yo no puedo crear una función llamada Azuma y luego modificarla en tiempo de ejecución.

13
00:01:30,080 --> 00:01:37,280
Una vez que yo declare esta función ya esta función no hay forma de modificarla entonces para eso han

14
00:01:37,280 --> 00:01:40,480
creado las funciones anónimas.

15
00:01:40,480 --> 00:01:48,230
Vamos a ver un primer ejemplo dentro de Main vamos a ir por fuera vamos a declarar de manera global

16
00:01:48,230 --> 00:01:56,960
una variable vamos a llamarla por ejemplo cãlculo y vamos a decir que en lugar de ser de tipo entero

17
00:01:57,020 --> 00:02:06,050
o de tipo string o de tipo flotante o booleano va a ser de tipo función y aquí viene la novedad no solo

18
00:02:06,050 --> 00:02:12,430
las funciones son en sí misma métodos y funciones sino que también son tipos de datos.

19
00:02:12,530 --> 00:02:20,510
Entonces yo voy a crear una función que va a recibir dos números de parámetro que no hace falta en la

20
00:02:20,510 --> 00:02:27,740
declaración no usar ningún nombre ninguna variable Simplemente con colocar que voy a recibir los datos

21
00:02:27,740 --> 00:02:36,770
de tipo entero ya estoy creando mi variable cálculo y además le voy a decir que no solo va a recibir

22
00:02:36,770 --> 00:02:45,560
dos enteros sino que va a devolver un resultado de tipo entero muy bien y qué es lo que va a hacer esto

23
00:02:45,560 --> 00:02:52,940
yo aquí lo que estoy haciendo fijense es crear una variable de tipo función.

24
00:02:52,940 --> 00:03:00,740
Ahora tengo que asignarle la función en sí misma y va a ser una función que va a recibir aquí si tengo

25
00:03:00,740 --> 00:03:11,120
que colocar los nombres de los parámetros un número dos de tipo entero perdón y esto va a devolver un

26
00:03:11,120 --> 00:03:18,770
resultado fíjense en ningún lado use un nombre aquí he creado una función anónima donde no he usado

27
00:03:19,070 --> 00:03:27,170
ningún nombre y el resultado de esa función se va a alojar en cálculo qué es lo que va a hacer esto

28
00:03:27,170 --> 00:03:29,650
va a devolver no uno más.

29
00:03:29,660 --> 00:03:35,840
Número 2 esto es lo que va a ser nuestra función cuando nosotros llamemos a cálculo cálculo va a ser

30
00:03:35,840 --> 00:03:44,090
una función que lo que va a hacer es ejecutar lo que tiene de acuerdo a los parámetros que yo le voy

31
00:03:44,090 --> 00:03:48,080
a dar y me va a devolver este resultado.

32
00:03:48,080 --> 00:03:55,560
Nosotros ahora vamos a ser nuestro Main y vamos a decirle por ejemplo vamos a ver un ejemplo vamos a

33
00:03:55,560 --> 00:04:03,740
hacer un f y vamos a decirle que sumó cinco más +7 y que esto va a ser el resultado.

34
00:04:03,740 --> 00:04:12,470
Vamos a colocar aquí nuestro verbo le vamos a colocar un carriã retraigan para que luego pueda mostrar

35
00:04:12,470 --> 00:04:20,690
varios datos y le voy a decir que aquí va a mostrar el resultado de cálculo de 5,7 muy bien se entiende

36
00:04:20,690 --> 00:04:23,350
esto vamos a ejecutarlo.

37
00:04:23,450 --> 00:04:32,140
Vamos a agravarlo vamos a venir aquí a nuestra consola y vamos a borrar todo esto vamos a hacer la pasemos

38
00:04:32,160 --> 00:04:41,090
hundir tenemos nuestro punto muy bien perfecto hacemos un barran de Main con todo y nos va a mostrar

39
00:04:41,090 --> 00:04:50,060
que sumo cinco más siete es igual a 12 fíjense lo que hizo me creó una variable de tipo función a la

40
00:04:50,060 --> 00:04:58,100
cual yo voy a poder llamar libremente moviéndole dos valores aquí no hay mucho misterio ustedes dirán

41
00:04:58,100 --> 00:05:06,920
por qué lo hice así si puedo crear una función libremente llamado moverle dos valores y que me muestre

42
00:05:07,100 --> 00:05:11,180
o que me devuelva el resultado sin hacer todo esto.

43
00:05:11,180 --> 00:05:12,770
Cuál es la gracia de esto.

44
00:05:12,770 --> 00:05:19,550
Bueno la gracia de esto al hacerlo en una variable es que yo aquí puedo vamos a colocar primero hemos

45
00:05:19,550 --> 00:05:28,100
sumado ahora vamos a restar vamos a poner restamos y aquí yo voy a redefinir calculo algo que con una

46
00:05:28,100 --> 00:05:36,420
función normal es imposible voy a decir que cálculo es igual y ahora voy a crear una nueva función que

47
00:05:36,440 --> 00:05:45,830
en base a uno de tipo entero y dos de tipo entero me va a devolver un número entero que va a ser en

48
00:05:45,830 --> 00:05:53,150
este caso vamos a poner un rotor de núm uno menos dos.

49
00:05:53,300 --> 00:06:01,940
Fíjense esto yo he redefinido mi función calculo cálculo no solo es una variable es una variable de

50
00:06:01,940 --> 00:06:09,800
tipo función esto es lo bueno de las funciones anónimas al mover una función anónima a una variable

51
00:06:10,220 --> 00:06:11,400
esa variable.

52
00:06:11,540 --> 00:06:16,320
Puedo jugar puedo modificarla y ahora el resultado va a ser otro.

53
00:06:16,430 --> 00:06:25,520
Vamos a copiar esta línea la copiamos aquí y ahora vamos a decirle que restamos por ejemplo seis de

54
00:06:25,520 --> 00:06:26,460
cuatro.

55
00:06:26,540 --> 00:06:34,850
Vamos a poner que esto es seis menos cuatro y aquí vamos a poner cálculos seis calculó cuatro.

56
00:06:34,850 --> 00:06:43,700
Vamos a grabar vamos a venir aquí y vamos a ejecutar y tenemos que sumar cinco más siete es igual a

57
00:06:43,720 --> 00:06:52,040
12 y que restamos seis menos cuatro es igual a dos y hemos usado la misma función nada solo lo que hemos

58
00:06:52,040 --> 00:06:59,540
hecho es redefinir el retarán para que en este caso en lugar de hacer una suma haga una resta.

59
00:06:59,540 --> 00:07:08,130
Esto es lo más parecido no es lo mismo que una sobrecarga con la diferencia que la sobrecarga de funciones

60
00:07:08,150 --> 00:07:15,110
real la que hemos conocido en otros lenguajes me permitía cambiar la cantidad de parámetros de recepción

61
00:07:15,500 --> 00:07:22,250
y en este caso no. En este caso voy a tener que respetar la misma cantidad de parámetros de entrada

62
00:07:22,340 --> 00:07:31,480
voy a tener que respetar el tipo de dato de entrada y voy a poder recién ahí ejecutar un distinto resultado

63
00:07:31,480 --> 00:07:32,350
o código.

64
00:07:32,420 --> 00:07:39,410
Aquí nosotros tenemos un retorno pero aquí podríamos tener 20 30 40 líneas de código que hagan cosas

65
00:07:39,410 --> 00:07:41,960
diferentes unas a la otra.

66
00:07:42,050 --> 00:07:51,590
Vamos a replicar esto vamos a copiarlo y vamos a pegarlo aquí debajo y lo que vamos a hacer es ahora

67
00:07:51,620 --> 00:07:59,990
vamos a ser por ejemplo que dividimos perdón si esto les parece redundante pero hay que entenderlo muy

68
00:07:59,990 --> 00:08:09,170
bien y ahora vamos a decir que no uno va a devolver uno dividido dos monedas vamos a dividir por ejemplo

69
00:08:09,170 --> 00:08:14,250
12 dividido tres y vamos a colocar aquí calculo 12.

70
00:08:14,360 --> 00:08:21,560
Ahora fíjense que cálculo siempre se llama De la misma manera y estamos haciendo cosas diferentes porque

71
00:08:21,560 --> 00:08:29,150
estamos gracias a las funciones anónimas estamos reescribiendo nuestra función.

72
00:08:29,150 --> 00:08:36,470
Tenemos restamos seis menos cuatro sumamos y aquí tenemos nuestro dividimos 12 dividió a tres que nos

73
00:08:36,470 --> 00:08:37,950
da cuatro.

74
00:08:38,000 --> 00:08:42,950
Podría ser la de multiplicación va a ser muy redundante es lo mismo.

75
00:08:43,000 --> 00:08:48,670
Bueno y ahora vamos a ver otro tipo de ejemplo en lo que tiene que ver con funciones anónimas.

76
00:08:48,680 --> 00:08:54,590
Vamos a crear una función la vamos a llamar primero sin crearla que se va a llamar operaciones muy bien

77
00:08:54,590 --> 00:08:59,960
se hará gravará me va a dar error porque no existe esa función lo vamos a creer ahora vamos a decir

78
00:08:59,960 --> 00:09:09,140
que hay una función de tipo operaciones y esta función en su interior va a tener por ejemplo vamos a

79
00:09:09,140 --> 00:09:19,030
grabar resultado una variable que va a ser una variable de tipo función Fíjense que aquí no estoy nombrándola

80
00:09:19,040 --> 00:09:22,300
no le estoy poniendo un nombre a esta función y es lógico.

81
00:09:22,430 --> 00:09:29,090
Estamos viendo funciones anónimas y resultados lo que va a tener en su interior vamos a hacer una simple

82
00:09:29,090 --> 00:09:30,190
operación.

83
00:09:30,410 --> 00:09:37,640
Vamos a crear una variable de tipo entero y le vamos a mover un 23 vamos a grabar una variable de tipo

84
00:09:37,640 --> 00:09:47,700
entero que va a tener trece o catorce lo mismo y vamos a hacer un ratón de a más ve muy bien.

85
00:09:48,080 --> 00:09:58,490
Ahora fíjense una cosa yo ahora para poder ejecutar esto voy a tener que hacer aquí un LND que dé resultado

86
00:09:59,280 --> 00:10:07,330
porque el resultado se volvió a crear como una función este es otra manera es lo mismo que hemos visto

87
00:10:07,330 --> 00:10:09,000
aquí arriba.

88
00:10:09,400 --> 00:10:16,600
Lo único que cambia es que nosotros en la misma en el mismo bloque de código en la misma función hemos

89
00:10:16,600 --> 00:10:20,160
creado funciones anónimas y las vamos a llamar.

90
00:10:20,200 --> 00:10:29,500
Si yo ejecuto esto vamos a ver que el resultado se muestra debajo que es 36 y lo único que hice yo fue

91
00:10:29,500 --> 00:10:37,090
crear una función en la cual dentro se va a crear una variable de tipo función y que me va a devolver

92
00:10:37,330 --> 00:10:44,920
un valor bueno en lo que vamos a ver ahora es el tema de los Clausius los closing ustedes y googlea

93
00:10:44,980 --> 00:10:53,290
van a ver que no sólo son del lenguaje Goh los close up son un concepto de funciones anónimas que se

94
00:10:53,650 --> 00:11:01,600
están usando mucho que tienen que ver con la protección y la instalación de código de mantener nuestro

95
00:11:01,600 --> 00:11:07,270
código y sobre todo nuestras variables alejadas de los curiosos.

96
00:11:07,270 --> 00:11:14,350
Recuerden que el desarrollo de software hoy en día tiene que ver con muchos muchos programadores al

97
00:11:14,350 --> 00:11:18,820
mismo tiempo haciendo código y por ahí hay distintos niveles de seguridad.

98
00:11:18,910 --> 00:11:22,320
Hay ciertas funciones que no queremos que todos accedan.

99
00:11:22,480 --> 00:11:27,700
Entonces se maneja con los crossups un tema de instalación de código.

100
00:11:27,700 --> 00:11:33,730
Vamos a ver un ejemplo vamos a ver cómo desde los closed Hours que una de las características que tienen

101
00:11:33,730 --> 00:11:42,100
es que pueden acceder a variables creadas por fuera de la función lo cual lo hace muy útil muy muy potente

102
00:11:42,660 --> 00:11:48,610
que no tiene que ver con variables globales ni públicas sino que tienen que ver con variables creadas

103
00:11:48,610 --> 00:11:51,080
en la función original.

104
00:11:51,130 --> 00:11:57,130
Vamos a ver un ejemplo y lo van a comprender un poco más a veces quizás explicar en teoría y en palabras

105
00:11:57,130 --> 00:12:03,970
es difícil y vamos a ver ejemplos porque me interesa que ustedes entiendan el ejemplo de los Clausius.

106
00:12:04,090 --> 00:12:10,180
Hay muchos ejemplos en la web son muy pobres realmente los ejemplos que hay en la web con el tema de

107
00:12:10,180 --> 00:12:11,140
los crossups.

108
00:12:11,140 --> 00:12:19,330
Espero poder darles un ejemplo mucho más sustancial en este curso vamos a crear una función que no es

109
00:12:19,330 --> 00:12:27,430
anónima vamos a llamar a una función de tipo tabla y esta función va a recibir un valor de tipo entero

110
00:12:27,770 --> 00:12:30,240
y lo que nos va a devolver esta función.

111
00:12:30,250 --> 00:12:38,680
Atención con esto en lugar de devolvernos un entero o devolvernos un bulevar o lo que sea nos va a devolver

112
00:12:38,680 --> 00:12:41,280
a su vez otra función nueva.

113
00:12:41,320 --> 00:12:42,640
Esto se hace así.

114
00:12:42,790 --> 00:12:46,360
Esto me va a devolver una función de tipo entera.

115
00:12:46,360 --> 00:12:52,450
Vamos un poco en limpio creo una función tabla que recibe un valor y me devuelve una función que a su

116
00:12:52,450 --> 00:12:58,150
vez esa función que me devuelve me va a devolver un valor entero muy bien.

117
00:12:58,150 --> 00:13:04,330
Ahora viene lo que yo les dije de los datos que están por fuera de las funciones vamos a crear dos variables

118
00:13:04,360 --> 00:13:11,650
una llamada al número y que va a recibir valor lo que yo reciba de parametro y vamos a crear una nueva

119
00:13:11,770 --> 00:13:16,150
una nueva variable que sólo solamente va a estar presente dentro de tabla.

120
00:13:16,240 --> 00:13:22,570
En ningún otro lugar va a estar presente con lo cual va a estar protegida mi variable no va a poder

121
00:13:22,570 --> 00:13:28,440
ser modificada por fuera del código y que se va a llamar secuencia.

122
00:13:28,480 --> 00:13:37,780
Vamos a poner en minúscula para que no haya confusiones le vamos a asignar un valor inicial a mi secuencia

123
00:13:37,930 --> 00:13:39,650
de cero muy bien.

124
00:13:39,760 --> 00:13:45,870
Ahora vamos a hacer nuestro rotaron vamos a devolver esa función que necesitamos devolver.

125
00:13:46,000 --> 00:13:52,390
Vamos a devolver nuestra función fíjense que la declaración de lo que estoy devolviendo tiene que coincidir

126
00:13:52,390 --> 00:14:01,240
con la declaración inicial de nuestra función madre donde indica que lo que yo voy a devolver es como

127
00:14:01,240 --> 00:14:06,970
pasarle el parámetro de la función madre tiene que ser del mismo tipo una vez que yo hago el retorno

128
00:14:06,970 --> 00:14:16,840
de esto lo que voy a hacer ahora es secuencia la voy a incrementar en uno y lo que voy a devolver es

129
00:14:16,840 --> 00:14:26,980
un por ejemplo vamos a devolver un número por secuencia muy bien hay dos Reston por qué.

130
00:14:26,980 --> 00:14:35,260
Porque hay dos funciones una que es la que me sale de la de esta función que sería restar números por

131
00:14:35,260 --> 00:14:40,410
secuencia fijense y el otro retorno es el que me sale de la función tabla.

132
00:14:40,480 --> 00:14:47,680
Como tengo una función como muñecas rusas una función metida dentro de la otra tengo que tener dos ratón

133
00:14:48,340 --> 00:14:49,000
muy bien.

134
00:14:49,030 --> 00:14:57,430
Esto es lo que me va a devolver es un número multiplicado por la secuencia la secuencia previamente

135
00:14:57,670 --> 00:15:06,220
a la multiplicación la incrementó en uno así que si yo por ejemplo 2 va a multiplicar el 2 por 1 y me

136
00:15:06,220 --> 00:15:08,590
va a devolver este valor entero.

137
00:15:08,590 --> 00:15:17,260
Muy bien ahora vamos a nuestro Main debajo de operaciones lo que vamos a hacer vamos a colocar aquí

138
00:15:17,260 --> 00:15:25,510
un pequeño comentario que diga Clausius y lo que vamos a hacer es vamos a crear una variable vamos a

139
00:15:25,510 --> 00:15:34,210
crear una variable por ejemplo para iniciar el número tabla del dos vamos a hacer primero la tabla del

140
00:15:34,220 --> 00:15:41,320
2 ustedes van a poder hacer las tablas de lo que quieren aquí vamos a crear una nueva variable a la

141
00:15:41,320 --> 00:15:46,940
que le vamos a la vamos a convertir en nuestro closing y ahora lo van a entender.

142
00:15:47,170 --> 00:15:56,650
Vamos a llamar la variable mi tabla y lo que le vamos a pasar ahora es por ejemplo la ejecución la vamos

143
00:15:56,650 --> 00:16:03,620
a convertir en función de qué manera ejecutando tabla y pasándole tabla.

144
00:16:03,970 --> 00:16:07,700
Qué es lo que va a ser mi tabla se convierte en una función ahora por qué.

145
00:16:07,740 --> 00:16:08,210
Por qué.

146
00:16:08,240 --> 00:16:15,600
Tabla me devuelve una función lo que me devuelve tablas una función entonces cuando yo llamé a mi tabla

147
00:16:16,180 --> 00:16:24,550
siempre va a terminar funcionando como una función vamos a hacer aquí un favor si lo que queremos es

148
00:16:24,550 --> 00:16:30,670
mostrar una tabla de por ejemplo en la tabla del dos la tabla del tres vamos a tener que iterar para

149
00:16:30,670 --> 00:16:39,040
mostrar todos los valores vamos a crear una variable de tipo entero que las tablas arrancan del elemento

150
00:16:39,040 --> 00:16:43,530
cero dos por cero sino que es dos por uno.

151
00:16:43,630 --> 00:16:52,450
Vamos a arrancar del elemento 1 le vamos a decir que y mientras si se Menorah 11 para hacer los 10 elementos

152
00:16:52,450 --> 00:17:04,670
de la tabla vamos a perdona aquí tengo muy bien vamos a iterar vamos a iterar y a incrementar el valor

153
00:17:04,670 --> 00:17:14,590
de ahí y aquí adentro vamos a hacer un FME print LN de que de mi tabla.

154
00:17:14,750 --> 00:17:21,560
Ahora cuando ejecutemos vamos a caer en cuenta de que hay un comportamiento muy especial que tienen

155
00:17:21,560 --> 00:17:30,710
los Clausius y lo vamos a explicar primero lo vamos a grabar vamos a correr y vamos a ver que se ha

156
00:17:30,800 --> 00:17:40,580
dibujado mi tabla de multiplicar porque integrado diez veces llamando a una función Ahora fíjense yo

157
00:17:40,580 --> 00:17:42,500
acá no incremento nada.

158
00:17:42,500 --> 00:17:51,920
Acá no multiplico nada está ejecutando esto y ustedes me dirán Pero hay algo que no me cierra.

159
00:17:52,090 --> 00:18:01,340
Si cuando yo ejecuto mi tabla y mi tabla es una copia de tabla por qué secuencia no se pone en cero.

160
00:18:01,340 --> 00:18:02,530
Y éste es el.

161
00:18:02,540 --> 00:18:09,080
Esta es la maravilla de los Clausius cuando ustedes ejecuten tabla lo que van a estar ejecutando es

162
00:18:09,080 --> 00:18:10,350
esta parte del código.

163
00:18:10,460 --> 00:18:13,750
Esta parte del código no el resto.

164
00:18:14,140 --> 00:18:21,290
En el primer la primera ejecución que hagan de tabla se va a ejecutar esta parte secuencia se va a quedar

165
00:18:21,380 --> 00:18:31,100
grabada con cero pero cuando ustedes ejecuten mi tabla mi tabla que tomó de tabla tomó todo tablas no

166
00:18:31,340 --> 00:18:39,650
tomó lo que le devolvió tabla le devolvió una función a mi tabla no le interesa esto mi tabla simplemente

167
00:18:39,650 --> 00:18:42,980
tomó la función que me devolvió tabla.

168
00:18:43,250 --> 00:18:50,810
Entonces a medida que voy ejecutando la secuencia que se graba en memoria y que está alojada en memoria

169
00:18:50,810 --> 00:18:58,980
y que no pierde les COP va a ir incrementándose cuando secuencia aquí pasa a ser secuencia +1.

170
00:18:59,240 --> 00:19:08,390
Esto va manejándose memoria y se va ir incrementando sin problema esto es una de las novedades que incluyeron

171
00:19:08,510 --> 00:19:12,030
en el mundo del desarrollo con los Clausius.

172
00:19:12,170 --> 00:19:21,650
Esto es algo muy usado hoy en día en los desarrollos porque permite que el código sea totalmente independiente

173
00:19:21,920 --> 00:19:30,320
y que puedan ir creando funciones de Ustedes fíjense que los clásicos como dijimos al comienzo son funciones

174
00:19:30,320 --> 00:19:37,790
anónimas y las funciones anónimas también nos permiten esto que es la reconstrucción de una función

175
00:19:38,060 --> 00:19:44,240
o el cambio de una función en tiempo de ejecución que hasta ahora y con los lenguajes tradicionales

176
00:19:44,300 --> 00:19:47,140
era algo imposible de imaginar.

177
00:19:47,240 --> 00:19:52,280
Así que espero que más o menos se hayan comprendido el tema de los Clausius.

178
00:19:52,340 --> 00:19:58,090
Bueno nos vemos en el próximo capítulo para seguir comprendiendo un poco más del lenguaje godo.
