Ahora vamos a crear dos situaciones más
en el que van a aparecer los cierres.
Para que puedas empezar a identificar cierres
en su propio código en el futuro.
Y ambos ejemplos van a demostrar
que no necesitamos devolver si la función
de otra función para crear un cierre.
Muy bien, entonces comencemos con nuestro primer ejemplo aquí.
Voy a empezar definiendo una variable vacía llamada f
y luego una expresión de función g.
Estos son solo algunos nombres genéricos
porque lo que hacen las funciones aquí realmente no importa.
Luego aquí, definí esto como una variable
y luego voy a reasignar la variable F
que creamos aquí.
Y voy a asignarle un valor de función.
Y esta función simplemente registrará
la variable a la consola
digamos dos veces.
Bien, y eso es todo por ahora al menos.
Así que tratemos de llamar a g
así que va a ser una función dispersa.
Y entonces el resultado de esta función es que a será 23
y esa variable F que tenemos aquí
se convertirá en esta función.
Y así, después de g podemos llamar a F.
Así que intentemos eso.
Y obtenemos 46 que es de hecho 23 por dos, muy bien.
Y lo que esto prueba es que este valor F aquí
entonces esta función F realmente se cierra sobre cualquier variable
del contexto de ejecución en el que se definió.
Y eso es cierto incluso cuando la variable en sí.
Así que F aquí técnicamente ni siquiera estaba definido en el interior
de este entorno variable aquí, a la derecha.
Así que esta variable F se definió fuera de aquí
en el ámbito global, se creó aquí
pero luego como le asignamos una función aquí
en esto la función g,
así que aquí mismo en instilar cerrado
sobre el entorno variable de la función g.
Y eso incluye esta una variable.
Y por lo tanto es capaz de acceder a esta una variable aquí
incluso después de la función g aquí en este punto
por supuesto ya ha terminado su ejecución, verdad.
Así que eso es justo lo que aprendimos en la última lección.
Así que en este punto de la ejecución,
el entorno variable de g ya no está, verdad.
Pero f, entonces esta función aquí cerrada
ese entorno variable y por lo tanto es capaz
para acceder a la variable.
Básicamente, usando la analogía de o menos video,
la variable a está dentro de la mochila de la función f.
Pero ahora vamos a llevarlo al siguiente nivel
y crear una nueva función aquí.
Así que eso es h y va a ser muy similar.
Todo lo que va a hacer es definir b como algún otro valor,
digamos esto y luego lo haremos de nuevo,
reasignar f, aquí mismo.
Así que llamemos a este ab ahora, por supuesto.
Así que este de aquí intentará acceder a b
y multiplicar por dos.
Bien, entonces lo que quiero ver con esto
es lo que sucede cuando asignamos el valor f
una segunda función.
Bien, aquí llamamos g y entonces g se asignará a
o variable vacía esta función f.
Bien, y luego si llamamos h después
o en realidad hagámoslo después de llamar a f por primera vez.
Entonces, cuando llamamos h, entonces la variable f
será asignado nuevamente.
Entonces, una segunda función que es esta aquí.
Entonces, lo que quiero ver es lo que f hace entonces.
Entonces, veamos.
Y de nuevo, teniendo en cuenta que F en este punto
es una función diferente a esta de aquí
porque fue reasignado por h.
Solo escribimos eso aquí.
Bien, ahora obtenemos 1554, que es probablemente 777 veces dos.
y de hecho lo es.
Y entonces esto prueba que la función f
fue reasignado aquí
también cerrado sobre el entorno variable de h.
Y así es como puede acceder a la variable b aquí
que se ha fijado en 777.
Así que vamos a inspeccionar el entorno variable como
lo hicimos al final del último video.
Entonces de f y luego podremos ver que en el cierre,
de hecho tiene el valor de b
y ahora ya no tiene el valor de a.
Así que después del cierre que tenía antes.
Así que en este punto aquí en el cierre contenido
el valor a y, por supuesto, también podemos ver eso.
Entonces, en este momento, el cierre es de hecho un 23, correcto.
Y entonces, cuando reasignamos la función a un nuevo valor,
entonces ese viejo cierre básicamente desaparece
y ahora el cierre es b.
Así que esta variable aquí del lugar de nacimiento
donde fue reasignado.
Y esto es realmente fascinante en mi opinión.
que el cierre puede cambiar asi
a medida que se reasigna la variable.
Así que es cierto que un cierre siempre asegura
que una función no pierda la conexión
a las variables que estaban presentes en su lugar de nacimiento.
Así que siempre los recordará.
En nuestro caso aquí, la función
nació dentro de g primero
y luego renació esencialmente de nuevo en h.
Y entonces, primero el cierre contenía la variable a
de su primer lugar de nacimiento.
Y luego, cuando renació para seguir nuestra analogía
luego recordó esta variable B de su lugar de nacimiento.
Bien, entonces este fue el ejemplo uno.
Ahora vamos a crear otro ejemplo.
Bien, entonces espero que la primera haya sido clara aquí.
Entonces, cada vez que sucede algo como esto
donde tus funciones reasignadas aún sin devolverlas,
tenga en cuenta que también esto creará un cierre
pero ahora pasando a nuestro segundo ejemplo aquí
y eso va a ser un temporizador.
Así que un temporizador es otro gran ejemplo.
que no necesitamos devolver una función
para ver un cierre en acción.
Así que aquí estoy volviendo al ejemplo de la aerolínea.
Así que creando una función llamada pasajeros a bordo
y luego obtenemos el número de pasajeros y el tiempo de espera.
Entonces vamos a crear una nueva variable aquí
que estoy llamando perGroup.
Y eso es porque el abordaje suele ocurrir en grupos.
y solemos tener tres grupos.
Así que voy a dividir a todos los pasajeros.
Así que el número de pasajeros que está abordando por tres
y al final de esta función,
Quiero bloquear a la consola.
Empezaremos a abordar y luego esperaremos unos segundos, ¿de acuerdo?
Y ahora usemos un temporizador
y aún no hemos usado un temporizador en este curso.
Y aprenderemos más sobre ellos más adelante.
pero este es un buen caso de uso
que quería usar un temporizador ahora.
Y en realidad es muy simple.
Entonces solo usamos la función de tiempo de espera establecido
y una función de tiempo de espera establecido necesita dos parámetros.
La primera es una función que se ejecutará, está bien.
Y esta función se ejecutará después de un cierto tiempo.
Por ejemplo, podemos especificar 1.000 milisegundos
porque el segundo argumento aquí es milisegundos.
Y eso significará que cualquier código
está dentro de esta función se ejecutará
después de un segundo.
Déjame hacer eso aquí
solo para que veas esto como un ejemplo.
Así que si nos salvé ahora espera un segundo
y luego aquí ves que aparece el temporizador.
Así que voy a hacer eso de nuevo.
Bien, verás que después de este segundo,
esta función fue ejecutada.
Bien, y entonces esto, como ya aprendimos antes
es esencialmente una función de devolución de llamada.
Y en este caso se llama literalmente más tarde.
Entonces, en este caso, después de un segundo.
Así que vamos a crear una función de devolución de llamada aquí.
Y primero quiero iniciar sesión en la consola.
Ahora estamos abordando todos y luego los n pasajeros.
Y entonces este n aquí es este parámetro de la función.
Así que de esta función madre que esencialmente es la función
o el alcance en el que esta función de devolución de llamada aquí
se está creando.
Y eso, por supuesto, será importante.
para nuestro ejemplo de cierre.
Y luego usemos también la variable perGroup ahora.
Hay tres grupos cada uno con
pasajeros, está bien,
esa es nuestra función y ahora llamémosla.
Y aquí queremos especificar espera y luego veces 1,000
porque vamos a pasar a esperar en segundos.
Y este argumento aquí debe estar en milisegundos.
y entonces solo multiplicamos por 1,000.
Aborde pasajeros, digamos que tenemos 180 pasajeros
y tarda dos, digamos tres segundos.
Así que inmediatamente cuando llamamos a esta función,
esta variable será creada
luego se llamará al tiempo de espera establecido
y básicamente registrará esta función de devolución de llamada aquí.
Y luego eso se llamará después de tres segundos.
Pero inmediatamente también este console.log aquí
será llamado, de acuerdo.
Así que este console.log aquí no esperará estos tres segundos
para que estos establezcan el tiempo de espera para finalizar la devolución de llamada.
Bien, inmediatamente se crea esta variable,
se ejecuta esta función de tiempo de espera establecido y se ejecuta console.log.
Y luego, después de tres segundos, esta función aquí
será ejecutado.
Y entonces, veamos qué sucede con la variable n
ya la variable perGroup que está en esta función.
Inmediatamente obtuvimos este registro y luego de tres segundos,
estamos abordando los 180 y hay tres grupos
con 60 pasajeros cada uno.
Está bien, funcionó.
Y nuevamente, tenga en cuenta que esta función de devolución de llamada aquí
se ejecutó de forma completamente independiente
desde la función de pasajeros a bordo.
Muy bien, pero aún así la función de devolución de llamada
fue capaz de utilizar todas las variables que fueron
en el entorno variable en el que fue creado.
Eso es n y perGroup.
Y una vez más, esta es una señal clara
de un cierre que se está creando, a la derecha.
Entonces, la única forma en que esta función de devolución de llamada aquí
puede tener acceso a las variables que se definen
en la función de pasajeros a bordo
que hace tiempo que terminó la ejecución es si creó un cierre.
Y eso es exactamente lo que sucedió.
Y sí, así es como obtuvimos acceso a perGroup
y también este argumento de la función
así que esto espera aquí, a la derecha.
Entonces, como mencioné en la última lección,
el cierre por supuesto también incluye los argumentos
y eso es porque son realmente solo
una variable local en la función.
Y para terminar, demostremos ahora también
que el cierre sí tiene prioridad
sobre la cadena de escultura.
Así que aquí en el ámbito global,
También voy a crear una variable llamada perGroup equals
y luego solo algo de valor aquí.
Entonces, si la cadena de alcance tuviera prioridad sobre el cierre,
entonces esta función de devolución de llamada aquí
de hecho usaría esta variable aquí
esta variable global
porque podemos imaginar esta función aquí
básicamente siendo ejecutado en el ámbito global, está bien.
Entonces, si no fuera por el cierre, usaría esto.
Así que déjame demostrarte eso.
Entonces, si elimino esta variable,
entonces podrá usar el perGroup
y los datos están aquí afuera.
Así que de hecho ahora tenemos 1,000
pero luego como lo volvemos a poner aquí
entonces la función de devolución de llamada se cerrará sobre esta variable.
Entonces se cerrará
todo el entorno variable de hecho.
Y entonces entonces usará este año primero, correcto.
Y lo hizo.
Entonces, de hecho, una divulgación incluso tiene prioridad
sobre la cadena de escultura.
Bien, y con esto,
terminamos estas dos conferencias sobre los cierres
y esperan que después de este,
ahora puede identificar un poco mejor los cierres
como suceden en su código o incluso aquí en mi código
a lo largo de los códigos
porque veremos algunos cierres ocurriendo
algunas veces más en el futuro.
Ahora todo lo que queda por hacer es el desafío de la codificación.
en el proximo video donde estaras pensando
sobre los cierres una vez más.