En el ejercicio anterior,
aprendimos sobre dos nuevos aspectos de JavaScript,
su soporte para funciones de primera clase y cierres.
También vimos cómo Node maneja el aspecto de programación asíncrona y cómo Node
soporta la ejecución asíncrona de código con
el uso de devoluciones de llamada y también el manejo de errores.
Veamos un ejemplo de cómo hacemos uso de esto
dentro de nuestra aplicación Node en este ejercicio.
Continuando con lo que dejamos en el ejercicio anterior,
ahora voy a ir y modificar el módulo Nodo rectángulo,
para que pueda tomar la ayuda de devoluciones de llamada.
Así que voy a eliminar estas exportaciones aquí,
y en su lugar, van a modificar esta función.
Voy a hacer uso de estas dos funciones un poco más tarde,
así que es por eso que las estoy guardando en la parte inferior.
Así que déjame mantenerlos a un lado.
Y luego modificaré este módulo rectángulo de la siguiente manera.
Así que diremos module.exports.
Así que estamos usando la forma estándar en que se maneja el módulo.
Y esto va a exportar esta función que toma estos tres parámetros,
x e y y devolución de llamada.
La devolución de llamada es una función que se va a suministrar cuando se llama a este módulo.
Así que este es el uso de las funciones de primera clase de las que hemos hablado anteriormente.
Así que dentro de esta devolución de llamada, para
que pueda ver que está obteniendo dos parámetros, x e y.
En este caso, para
el rectángulo, la x e y corresponden a la longitud y anchura
del rectángulo que se está pasando como los dos valores.
Así que dentro de aquí, vamos a comprobar
si x es menor o igual a cero o y es menor o igual a cero.
Hemos escrito código como este aquí.
Así que voy a copiar este código desde aquí
y luego traerlo aquí y luego vamos a editar.
Entonces, en este caso, esto es si x es
menor o igual a cero o y es menor que o igual a cero.
En este caso, ¿qué hacemos?
En este caso, notamos que
las dimensiones del rectángulo son menores o iguales a cero.
Así que tenemos que manejarlo
de manera diferente, y haremos lo demás.
La otra parte donde manejamos la situación en la que el rectángulo es un rectángulo válido.
Entonces, en este caso,
lo que haremos es usar un setTimeout.
Así que aquí, estoy simulando el hecho de que lo que
sea que se esté haciendo en este rectángulo va a tomar algún tiempo.
Entonces este es el procesamiento asincrónico.
Ahora, como no tengo mucho trabajo que hacer en segundo plano,
así que voy a simular eso simplemente usando la
función setTimeout de JavaScript y luego
retrasar antes de que se llame a la función de devolución de llamada.
Así que la forma en que arreglo esto es la siguiente.
Entonces, dentro del setTimeout,
voy a llamar a esta función allí
y organizar un retraso de
2.000 milisegundos o dos segundos después de lo cual se va a llamar a esta función.
Así que si recuerdas,
el setTimeout que es compatible con JavaScript,
toma como primer parámetro una función y
el segundo parámetro sería el período de tiempo para el que esto se va a retrasar.
Así que déjame sangrar esto.
Ahora, necesito completar esta función aquí.
Así que he empezado con la función de flecha aquí
que no toma parámetros y luego cuando se llama,
voy a emitir una llamada a la devolución de llamada.
Esta devolución de llamada es una función de devolución de llamada que
se va a pasar como el tercer parámetro aquí.
Esta función de devolución de llamada, como notó, toma dos parámetros.
El primero es el error y el segundo es el valor devuelto.
Entonces, en este caso, ya que tenemos un error,
porque x es menor o igual a cero e y es menor o igual a cero,
por lo que el primer valor que voy a pasar como nuevo error,
y este error es exactamente esta cadena que estaba usando en el console.log entonces,
y eso es lo que pasaré como el error aquí.
Permítanme ahora eliminar ese console.log,
ya no lo necesito.
Entonces, para la devolución de llamada,
voy a generar un nuevo objeto de error y luego pasar esto
como el valor de retorno para la función de devolución de llamada, el primer parámetro.
Así que diré que las dimensiones del rectángulo deben ser mayores que cero.
Así que diremos l,
este es el valor x y el y que obtenemos como los valores de entrada allí.
Así que esa es la devolución de llamada.
Y la segunda parte de esta devolución de llamada,
voy a pasar como nulo porque esto va a devolver un error.
Entonces, cuando devuelva un error como el primer parámetro,
el segundo parámetro será ignorado cuando esa devolución de llamada fue recibida por
el módulo de nodo desde donde estamos llamando a esta función en particular allí.
Así que, con este arreglo,
tan menos de cero,
así que permítanme darle un poco de espacio aquí para que esté correctamente sangrada aquí.
Entonces, la forma en que estoy organizando esto
aquí es que si x es menor que cero e y es menor que cero,
voy a devolver la llamada a la función de devolución de llamada que se ha pasado,
pero el primer parámetro pasará en
error porque aquí notamos que hay un error,
y el segundo parámetro será nulo.
Si este no es el caso,
entonces voy a llamar a la misma devolución de llamada,
pero con el primer parámetro.
Así que déjame copiar ese código aquí.
Todavía voy a usar el setTimeout aquí.
Pero esa primera parte no va a ser un error,
en cambio, la primera parte,
en este caso, no hay error.
Así que solo voy a pasar ese valor como nulo.
Entonces eso significa que el error se establece en nulo.
Así que este es un rectángulo válido.
Así que podemos calcular los valores para el rectángulo.
Pero en su lugar, simplemente voy a pasar
un objeto JavaScript que contiene las dos funciones
como los dos valores dentro de este objeto JavaScript.
Así que, aquí voy a tomar estos dos,
el perímetro y el área,
y luego estos dos serán pasados como los dos valores aquí, el
perímetro y el área.
Y estos dos, ya que resultan ser un objeto JavaScript,
por lo que el perímetro y
el área serán las dos propiedades que pasaré dentro de esos objetos JavaScript,
y eso es todo.
Así que aquí, en el segundo caso,
el error se establece en nulo porque no hay error,
pero la segunda parte,
observe que estoy pasando un objeto JavaScript que contiene dos propiedades,
perímetro y área, que son dos funciones aquí.
Así que las dos funciones son la función perimetral y la función de área.
Por lo tanto, este objeto JavaScript se pasará como
el valor devuelto para la devolución de llamada aquí, el segundo valor.
Y de nuevo, voy a retrasar esto por
un intervalo de dos segundos antes de que el valor sea pasado por esta función.
La razón por la que estoy usando setTimeout es para simular
un retraso antes de que la devolución de llamada llegue desde el otro lado.
Entonces, este tipo de representa situaciones en las
que, por ejemplo, emite una llamada a la base de datos a la base de datos,
y la base de datos debe leerse antes de que el valor se vuelva a transferir a usted.
Así que eso va a tomar una cierta cantidad de tiempo.
Así que básicamente estoy simulando esto en este momento usando la función setTimeout aquí.
Más adelante, verá que cuando integremos el MongoDB con
nuestro Express en los ejercicios posteriores,
ese retraso tendría que ser simulado,
será causado automáticamente por el hecho de que necesita realizar
operaciones de base de datos entre bastidores antes de obtener los datos.
Así que aquí, después de haber completado esta actualización de módulos de rectángulo,
aquí ves que el módulo rectángulo toma
tres parámetros, ya que es una llamada de entrada aquí,
x, y y devolución de llamada.
Y así, la devolución de llamada es la función de devolución de llamada que se suministra aquí.
Y esta función de devolución de llamada se llamará aquí dentro,
y cuando se llame a la función de devolución
de llamada, o se devuelve
un error o se devuelve una función que le permite calcular el perímetro y el área del rectángulo.
Ahora, este patrón de llamar y pasar una función de devolución de llamada
desde un módulo de nodo y luego el segundo módulo de nodo que cuando se complete,
pasará de nuevo el resultado usando la función de devolución de llamada es
exactamente el patrón que verá a menudo repetido en las aplicaciones de nodo.
Así que esa es la razón por la que lo estoy ilustrando.
Por supuesto, este es un ejemplo artificial que estoy ilustrando aquí, pero muestra
todos los patrones estándar que usará con
las funciones de nodo y devolución de llamada y también el manejo de errores.
Ahora, hemos actualizado el módulo rectángulo aquí.
Vamos a arreglar ese archivo index.js para que pueda pasar en la función de devolución de llamada y
luego manejar el valor devuelto que se envía desde el módulo rectángulo.
Volviendo a index.js,
ahora vamos a actualizar el archivo index.js de la siguiente manera.
Voy a eliminar esto del archivo index.js en su lugar.
Aquí, lo que terminaremos haciendo es llamar a
este módulo rectángulo y
luego pasar el l y el b como los dos parámetros.
Y el tercer parámetro que voy a pasar es esa función de devolución de llamada.
Entonces, la función de devolución de llamada tiene dos parámetros, err y rectángulo.
Y esta función de devolución de llamada se implementa de la siguiente manera aquí.
Así que aquí, ves que estoy llamando a
este módulo de nodo rectángulo y estoy
pasando la longitud y la amplitud de los dos primeros parámetros.
Y el tercer parámetro es, por supuesto,
una función de devolución de llamada que estoy implementando aquí.
Entonces, esta es una función de flecha que estoy implementando aquí.
Entonces, dentro de esta función de devolución de llamada,
¿cómo manejo el valor de retorno?
Así que aquí diré si (err),
por lo que si se devuelve el valor de error,
entonces simplemente haré console.log y diré
«ERROR» y luego el segundo valor es err.message.
Recordemos que en el rectángulo,
habíamos creado este nuevo objeto de error
y luego pasado en esta cadena dentro de este objeto de error.
Esta cadena se adjuntará
al objeto error a la propiedad message del objeto error aquí.
Entonces, en el archivo index.js,
estoy recuperando la propiedad de mensaje del objeto de error
y luego la imprimo en mi consola aquí.
Entonces, si ocurre un error,
voy a imprimir el mensaje de error usando esto.
Y entonces, así es como manejaría el error que fue devuelto por una función de devolución de llamada.
De lo contrario, por supuesto, en este caso,
el módulo rectángulo ha devuelto la función rectángulo,
el objeto que contiene el perímetro y las funciones de área, por
lo que puedo seguir adelante e imprimir ese valor.
Así que aquí, voy a decir que el área del rectángulo
de dimensiones l igual a,
así que voy a decir,
y b igual a.
La razón por la que lo estoy identificando
explícitamente será muy clara cuando ejecutemos este ejemplo.
Diré que es rectangle.area.
Ahora, observe que para esta área,
no estoy enviando ningún parámetro aquí porque va a valores,
la longitud y la respiración ya se han pasado aquí en l y b,
y esos ya estarían disponibles para esto
y aquí debido al cierre que admite JavaScript.
Debido a que estos x e y han entrado como los parámetros,
por lo que serán accesibles allí mismo en esta función de devolución de llamada.
Así que esos x_y estarán disponibles automáticamente para nosotros aquí.
Por lo tanto, de hecho,
no necesito proporcionar estos parámetros x e y aquí en absoluto porque
esos x e y se recuperarán de este x e y de allí.
Así que ni siquiera necesito pasar esos dos valores aquí.
Así que por eso, ahí mismo,
puedo llamar a rectangle.area.
Y este cálculo de área obtendrá automáticamente los l y b que han sido pasados
por la llamada rectángulo al módulo de nodo directo anteriormente.
Así que este es el cierre de JavaScript que opera aquí.
Entonces, ése es el primero.
Estoy imprimiendo el área del rectángulo.
Lo mismo, permítanme también imprimir los perímetros.
Así que para imprimir los perímetros,
así que diré console.log.
El perímetro del rectángulo será el perímetro del rectángulo.
Ahora, debo decirles que este tipo de enfoque para implementar requiere un poco
de esfuerzo para comprender e internalizar la capacidad de la función asíncrona.
Toma algo de tiempo para que entiendas completamente cómo funciona realmente.
Ahora para ilustrar el hecho de que
esta llamada a la función resultará en una llamada al módulo Node,
pero esta parte se ejecutará sólo después de
un retraso de dos segundos debido al hecho de que estamos utilizando la marca de tiempo establecida.
Ahora, como estudiamos en la operación asíncrona,
porque hemos pasado del procesamiento a la parte posterior,
permítanme también presentar un console.log más aquí para hacer un punto.
Así que diremos que esta declaración es
después de la llamada a rect.
La razón por la que estoy ilustrando este punto es que cuando emite esta llamada,
este código no se ejecutará hasta después de un retraso de dos segundos.
Entonces, mientras tanto,
su función, la función principal aquí,
continuará y luego ejecutará la siguiente línea de código que vea aquí.
Así que esta es la continuación que verá aquí.
Por lo tanto, con estos cambios,
vamos a guardar los cambios y luego ver cómo se ejecuta esta aplicación ahora.
Así que guardando los cambios.
Vamos a la terminal y ejecutar esta aplicación de nodo.
Ahora, yendo a la terminal, agregue el mensaje.
Permítanme escribir npm start e inmediatamente notará
que la resolución y esta declaración se imprimieron antes.
Y luego de este cierto retraso,
el área y el perímetro fueron impresos.
Así que ese es un retraso de dos segundos que introdujimos usando el tiempo de espera establecido.
Por lo tanto, notó que en la versión anterior,
esto fue impreso e inmediatamente el área y el perímetro se imprimieron justo debajo de eso.
Pero ahora, observe que esos valores se imprimen un poco más tarde.
Entonces, en el medio, sus llamadas de función con los diferentes parámetros que ya se han ido
y luego las devoluciones de llamada se vuelven a llamar después de dos segundos de retraso para cada uno de ellos.
Y debido al hecho de que existe el cierre que admite JavaScript,
por lo que se conservan los valores que se pasan.
Y así, cuando se llama a la función de devolución de llamada,
se imprime el valor apropiado.
Así que es por eso que ves que el área y
el perímetro están impresos correctamente y estos dos aquí,
estas dos declaraciones aquí,
corresponden a esta llamada particular a dirigir
con l es igual a dos y b es igual a cuatro.
Y luego estos dos,
los próximos a dos, por supuesto,
corresponden a este particular y a los restantes como ven aquí. Por
lo tanto, lo que quería ilustrar es el hecho de que cuando realiza un cálculo asíncrono,
el cálculo asíncrono toma su propio tiempo
para devolver el valor mientras que su cálculo principal
continuará adelante sin esperar a que se complete la devolución de llamada.
Por lo tanto, cuando necesita hacer una cierta cantidad de trabajo,
pasó como una devolución de llamada a ese otro módulo.
Y cuando ese otro módulo complete su trabajo,
va a devolver la llamada y luego ese código se ejecutará.
Así que ese es el punto que he ilustrado usando este ejemplo.
Una vez más, como dije,
esto requiere un poco de imaginación y comprensión
para que internalice la forma en que esto funciona,
pero verá que con Node y también Express y cuando usamos MongoDB,
verá este tipo de patrón que se repite muy a menudo en la forma en que escribimos nuestro código.
Así que con esta sencilla ilustración de devoluciones de llamada y manejo de errores,
completamos este ejercicio.
Este es un buen momento para que usted haga un comentario get con ese mensaje,
nodo, devoluciones de llamada y manejo de errores.