Bueno me tocó el turno de las funciones anónimas y de los Clausius.
Este capítulo es un capítulo especial dedicado a este tipo de funciones donde se va ya a complejizando
un poco y no solo a complejizando sino se van haciendo más ricas las funciones vamos a ver vamos a tener
que crear un ejercicio O6 vamos a crearlo en nuestra carpeta Goh vamos a crear una carpeta llamada ejercer
O6 y dentro de ejercer Ozai nuestro Moine punto.
Muy bien vamos a copiar y a escribir lo habitual y ahora lo que vamos a hacer es comenzar a explicar
un poco lo de las funciones anónimas las funciones anónimas son funciones que no tienen nombre un yo
puedo crear una variable y asignar la de tipo función para qué sirven para crear operaciones en las
que no voy a necesitar llamar a una función sino que ya de alguna manera y solar todo su código lo voy
a ocultar adentro de una variable y lo voy a poder modificar en tiempo de ejecución algo que con una
función es imposible.
Por ejemplo yo no puedo crear una función llamada Azuma y luego modificarla en tiempo de ejecución.
Una vez que yo declare esta función ya esta función no hay forma de modificarla entonces para eso han
creado las funciones anónimas.
Vamos a ver un primer ejemplo dentro de Main vamos a ir por fuera vamos a declarar de manera global
una variable vamos a llamarla por ejemplo cãlculo y vamos a decir que en lugar de ser de tipo entero
o de tipo string o de tipo flotante o booleano va a ser de tipo función y aquí viene la novedad no solo
las funciones son en sí misma métodos y funciones sino que también son tipos de datos.
Entonces yo voy a crear una función que va a recibir dos números de parámetro que no hace falta en la
declaración no usar ningún nombre ninguna variable Simplemente con colocar que voy a recibir los datos
de tipo entero ya estoy creando mi variable cálculo y además le voy a decir que no solo va a recibir
dos enteros sino que va a devolver un resultado de tipo entero muy bien y qué es lo que va a hacer esto
yo aquí lo que estoy haciendo fijense es crear una variable de tipo función.
Ahora tengo que asignarle la función en sí misma y va a ser una función que va a recibir aquí si tengo
que colocar los nombres de los parámetros un número dos de tipo entero perdón y esto va a devolver un
resultado fíjense en ningún lado use un nombre aquí he creado una función anónima donde no he usado
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
va a devolver no uno más.
Número 2 esto es lo que va a ser nuestra función cuando nosotros llamemos a cálculo cálculo va a ser
una función que lo que va a hacer es ejecutar lo que tiene de acuerdo a los parámetros que yo le voy
a dar y me va a devolver este resultado.
Nosotros ahora vamos a ser nuestro Main y vamos a decirle por ejemplo vamos a ver un ejemplo vamos a
hacer un f y vamos a decirle que sumó cinco más +7 y que esto va a ser el resultado.
Vamos a colocar aquí nuestro verbo le vamos a colocar un carriã retraigan para que luego pueda mostrar
varios datos y le voy a decir que aquí va a mostrar el resultado de cálculo de 5,7 muy bien se entiende
esto vamos a ejecutarlo.
Vamos a agravarlo vamos a venir aquí a nuestra consola y vamos a borrar todo esto vamos a hacer la pasemos
hundir tenemos nuestro punto muy bien perfecto hacemos un barran de Main con todo y nos va a mostrar
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
cual yo voy a poder llamar libremente moviéndole dos valores aquí no hay mucho misterio ustedes dirán
por qué lo hice así si puedo crear una función libremente llamado moverle dos valores y que me muestre
o que me devuelva el resultado sin hacer todo esto.
Cuál es la gracia de esto.
Bueno la gracia de esto al hacerlo en una variable es que yo aquí puedo vamos a colocar primero hemos
sumado ahora vamos a restar vamos a poner restamos y aquí yo voy a redefinir calculo algo que con una
función normal es imposible voy a decir que cálculo es igual y ahora voy a crear una nueva función que
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
este caso vamos a poner un rotor de núm uno menos dos.
Fíjense esto yo he redefinido mi función calculo cálculo no solo es una variable es una variable de
tipo función esto es lo bueno de las funciones anónimas al mover una función anónima a una variable
esa variable.
Puedo jugar puedo modificarla y ahora el resultado va a ser otro.
Vamos a copiar esta línea la copiamos aquí y ahora vamos a decirle que restamos por ejemplo seis de
cuatro.
Vamos a poner que esto es seis menos cuatro y aquí vamos a poner cálculos seis calculó cuatro.
Vamos a grabar vamos a venir aquí y vamos a ejecutar y tenemos que sumar cinco más siete es igual a
12 y que restamos seis menos cuatro es igual a dos y hemos usado la misma función nada solo lo que hemos
hecho es redefinir el retarán para que en este caso en lugar de hacer una suma haga una resta.
Esto es lo más parecido no es lo mismo que una sobrecarga con la diferencia que la sobrecarga de funciones
real la que hemos conocido en otros lenguajes me permitía cambiar la cantidad de parámetros de recepción
y en este caso no. En este caso voy a tener que respetar la misma cantidad de parámetros de entrada
voy a tener que respetar el tipo de dato de entrada y voy a poder recién ahí ejecutar un distinto resultado
o código.
Aquí nosotros tenemos un retorno pero aquí podríamos tener 20 30 40 líneas de código que hagan cosas
diferentes unas a la otra.
Vamos a replicar esto vamos a copiarlo y vamos a pegarlo aquí debajo y lo que vamos a hacer es ahora
vamos a ser por ejemplo que dividimos perdón si esto les parece redundante pero hay que entenderlo muy
bien y ahora vamos a decir que no uno va a devolver uno dividido dos monedas vamos a dividir por ejemplo
12 dividido tres y vamos a colocar aquí calculo 12.
Ahora fíjense que cálculo siempre se llama De la misma manera y estamos haciendo cosas diferentes porque
estamos gracias a las funciones anónimas estamos reescribiendo nuestra función.
Tenemos restamos seis menos cuatro sumamos y aquí tenemos nuestro dividimos 12 dividió a tres que nos
da cuatro.
Podría ser la de multiplicación va a ser muy redundante es lo mismo.
Bueno y ahora vamos a ver otro tipo de ejemplo en lo que tiene que ver con funciones anónimas.
Vamos a crear una función la vamos a llamar primero sin crearla que se va a llamar operaciones muy bien
se hará gravará me va a dar error porque no existe esa función lo vamos a creer ahora vamos a decir
que hay una función de tipo operaciones y esta función en su interior va a tener por ejemplo vamos a
grabar resultado una variable que va a ser una variable de tipo función Fíjense que aquí no estoy nombrándola
no le estoy poniendo un nombre a esta función y es lógico.
Estamos viendo funciones anónimas y resultados lo que va a tener en su interior vamos a hacer una simple
operación.
Vamos a crear una variable de tipo entero y le vamos a mover un 23 vamos a grabar una variable de tipo
entero que va a tener trece o catorce lo mismo y vamos a hacer un ratón de a más ve muy bien.
Ahora fíjense una cosa yo ahora para poder ejecutar esto voy a tener que hacer aquí un LND que dé resultado
porque el resultado se volvió a crear como una función este es otra manera es lo mismo que hemos visto
aquí arriba.
Lo único que cambia es que nosotros en la misma en el mismo bloque de código en la misma función hemos
creado funciones anónimas y las vamos a llamar.
Si yo ejecuto esto vamos a ver que el resultado se muestra debajo que es 36 y lo único que hice yo fue
crear una función en la cual dentro se va a crear una variable de tipo función y que me va a devolver
un valor bueno en lo que vamos a ver ahora es el tema de los Clausius los closing ustedes y googlea
van a ver que no sólo son del lenguaje Goh los close up son un concepto de funciones anónimas que se
están usando mucho que tienen que ver con la protección y la instalación de código de mantener nuestro
código y sobre todo nuestras variables alejadas de los curiosos.
Recuerden que el desarrollo de software hoy en día tiene que ver con muchos muchos programadores al
mismo tiempo haciendo código y por ahí hay distintos niveles de seguridad.
Hay ciertas funciones que no queremos que todos accedan.
Entonces se maneja con los crossups un tema de instalación de código.
Vamos a ver un ejemplo vamos a ver cómo desde los closed Hours que una de las características que tienen
es que pueden acceder a variables creadas por fuera de la función lo cual lo hace muy útil muy muy potente
que no tiene que ver con variables globales ni públicas sino que tienen que ver con variables creadas
en la función original.
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
es difícil y vamos a ver ejemplos porque me interesa que ustedes entiendan el ejemplo de los Clausius.
Hay muchos ejemplos en la web son muy pobres realmente los ejemplos que hay en la web con el tema de
los crossups.
Espero poder darles un ejemplo mucho más sustancial en este curso vamos a crear una función que no es
anónima vamos a llamar a una función de tipo tabla y esta función va a recibir un valor de tipo entero
y lo que nos va a devolver esta función.
Atención con esto en lugar de devolvernos un entero o devolvernos un bulevar o lo que sea nos va a devolver
a su vez otra función nueva.
Esto se hace así.
Esto me va a devolver una función de tipo entera.
Vamos un poco en limpio creo una función tabla que recibe un valor y me devuelve una función que a su
vez esa función que me devuelve me va a devolver un valor entero muy bien.
Ahora viene lo que yo les dije de los datos que están por fuera de las funciones vamos a crear dos variables
una llamada al número y que va a recibir valor lo que yo reciba de parametro y vamos a crear una nueva
una nueva variable que sólo solamente va a estar presente dentro de tabla.
En ningún otro lugar va a estar presente con lo cual va a estar protegida mi variable no va a poder
ser modificada por fuera del código y que se va a llamar secuencia.
Vamos a poner en minúscula para que no haya confusiones le vamos a asignar un valor inicial a mi secuencia
de cero muy bien.
Ahora vamos a hacer nuestro rotaron vamos a devolver esa función que necesitamos devolver.
Vamos a devolver nuestra función fíjense que la declaración de lo que estoy devolviendo tiene que coincidir
con la declaración inicial de nuestra función madre donde indica que lo que yo voy a devolver es como
pasarle el parámetro de la función madre tiene que ser del mismo tipo una vez que yo hago el retorno
de esto lo que voy a hacer ahora es secuencia la voy a incrementar en uno y lo que voy a devolver es
un por ejemplo vamos a devolver un número por secuencia muy bien hay dos Reston por qué.
Porque hay dos funciones una que es la que me sale de la de esta función que sería restar números por
secuencia fijense y el otro retorno es el que me sale de la función tabla.
Como tengo una función como muñecas rusas una función metida dentro de la otra tengo que tener dos ratón
muy bien.
Esto es lo que me va a devolver es un número multiplicado por la secuencia la secuencia previamente
a la multiplicación la incrementó en uno así que si yo por ejemplo 2 va a multiplicar el 2 por 1 y me
va a devolver este valor entero.
Muy bien ahora vamos a nuestro Main debajo de operaciones lo que vamos a hacer vamos a colocar aquí
un pequeño comentario que diga Clausius y lo que vamos a hacer es vamos a crear una variable vamos a
crear una variable por ejemplo para iniciar el número tabla del dos vamos a hacer primero la tabla del
2 ustedes van a poder hacer las tablas de lo que quieren aquí vamos a crear una nueva variable a la
que le vamos a la vamos a convertir en nuestro closing y ahora lo van a entender.
Vamos a llamar la variable mi tabla y lo que le vamos a pasar ahora es por ejemplo la ejecución la vamos
a convertir en función de qué manera ejecutando tabla y pasándole tabla.
Qué es lo que va a ser mi tabla se convierte en una función ahora por qué.
Por qué.
Tabla me devuelve una función lo que me devuelve tablas una función entonces cuando yo llamé a mi tabla
siempre va a terminar funcionando como una función vamos a hacer aquí un favor si lo que queremos es
mostrar una tabla de por ejemplo en la tabla del dos la tabla del tres vamos a tener que iterar para
mostrar todos los valores vamos a crear una variable de tipo entero que las tablas arrancan del elemento
cero dos por cero sino que es dos por uno.
Vamos a arrancar del elemento 1 le vamos a decir que y mientras si se Menorah 11 para hacer los 10 elementos
de la tabla vamos a perdona aquí tengo muy bien vamos a iterar vamos a iterar y a incrementar el valor
de ahí y aquí adentro vamos a hacer un FME print LN de que de mi tabla.
Ahora cuando ejecutemos vamos a caer en cuenta de que hay un comportamiento muy especial que tienen
los Clausius y lo vamos a explicar primero lo vamos a grabar vamos a correr y vamos a ver que se ha
dibujado mi tabla de multiplicar porque integrado diez veces llamando a una función Ahora fíjense yo
acá no incremento nada.
Acá no multiplico nada está ejecutando esto y ustedes me dirán Pero hay algo que no me cierra.
Si cuando yo ejecuto mi tabla y mi tabla es una copia de tabla por qué secuencia no se pone en cero.
Y éste es el.
Esta es la maravilla de los Clausius cuando ustedes ejecuten tabla lo que van a estar ejecutando es
esta parte del código.
Esta parte del código no el resto.
En el primer la primera ejecución que hagan de tabla se va a ejecutar esta parte secuencia se va a quedar
grabada con cero pero cuando ustedes ejecuten mi tabla mi tabla que tomó de tabla tomó todo tablas no
tomó lo que le devolvió tabla le devolvió una función a mi tabla no le interesa esto mi tabla simplemente
tomó la función que me devolvió tabla.
Entonces a medida que voy ejecutando la secuencia que se graba en memoria y que está alojada en memoria
y que no pierde les COP va a ir incrementándose cuando secuencia aquí pasa a ser secuencia +1.
Esto va manejándose memoria y se va ir incrementando sin problema esto es una de las novedades que incluyeron
en el mundo del desarrollo con los Clausius.
Esto es algo muy usado hoy en día en los desarrollos porque permite que el código sea totalmente independiente
y que puedan ir creando funciones de Ustedes fíjense que los clásicos como dijimos al comienzo son funciones
anónimas y las funciones anónimas también nos permiten esto que es la reconstrucción de una función
o el cambio de una función en tiempo de ejecución que hasta ahora y con los lenguajes tradicionales
era algo imposible de imaginar.
Así que espero que más o menos se hayan comprendido el tema de los Clausius.
Bueno nos vemos en el próximo capítulo para seguir comprendiendo un poco más del lenguaje godo.