Calcón
calc es una función asincrónica que queremos hacer análisis (análisis de rendimiento). Por convención, su último parámetro es una callback . Usamos calc como este:
calc (arg, (err, res) => console.log (err || res))
Quizás la forma más fácil de analizar el rendimiento en una función como calc es agregar una lógica de sincronización donde necesitamos analizar:
const t0 = date.now () calc (arg, (err, res) => {const t1 = date.now () console.log (`log: time: $ {t1 = t0}`) console.log (err || res)}) Sin embargo, esta no es una solución reutilizable. Cada vez que queremos cronometrar una función, tenemos que introducir un T0 en el alcance externo y cambiar callback para medir y registrar el tiempo.
La forma ideal para mí es poder cronometrarlo simplemente envolviendo una función asincrónica:
TIMEIT (calc) (arg, (err, res) => console.log (err || res))
timeIt debe poder realizar el análisis y el tiempo de ejecución de registro para cada bien asincrónica.
Tenga en cuenta que timeIt(calc) tiene la misma firma de función que la función Calc original, es decir, aceptan los mismos parámetros y devuelven el mismo valor, solo agrega una característica al CALE (una característica que se puede registrar).
Calc y TimeIT (Calc) pueden ser reemplazados entre sí en cualquier momento.
timeIt en sí es una función de orden superior porque acepta una función y devuelve una función. En nuestro ejemplo, acepta una función asíncrona de calc y devuelve una función con los mismos parámetros y valor de retorno que Calc.
A continuación se muestra cómo implementamos la función TIMEIT:
const timeit = r.Curry ((informe, f) => (... args) => {const t0 = date.Now () const nargs = r.init (args) const tallback = r.last (args) nargs.push (((... TIMEIT1 = TIMEIT (((t, err, res) => console.log (`log: $ {err || res} producido después: $ {t}`)) const calc = (x, y, z, callback) => setTimeout () => callback (nulo, x * y / z), 1000) calc (18, 7, 3, (err, res) => consultor res)) TIMEIT1 (Calc) (18, 7, 3, (err, res) => console.log (err || res)) Esta implementación timeIt acepta dos parámetros:
Informe: se utiliza una función para generar resultados de análisis
F: Función asincrónica que queremos hacer análisis
timeIt1 es una función conveniente y práctica, solo usa console.log para registrar los resultados de la medición de tiempo. Lo definimos pasando en report a la función timeIt más general.
Logramos el objetivo, y ahora podemos envolver la función asíncrona en timeIt1 y el tiempo es cronometrado:
TimeIt1 (Calc) (18, 7, 3, (err, res) => console.log (err || res))
La función General timeIt recibe una función de devolución de llamada report y una función asincrónica y devuelve una nueva función asíncrona. Esta función asincrónica tiene los mismos parámetros y el valor de retorno que la función original. Podemos usar esto:
TIMEIT ((Time, ... resultado) => // Informe de devolución de llamada: registre el tiempo, asyncFunc) (parámetros ..., (... resultado) => // resultado de la función async)
Ahora vamos a sumergirnos en la implementación de timeIt . Simplemente podemos generar una función general como timeIt1 , porque timeIt se corre en Corylated usando R.curry .
No planeo discutir la coriculización en esta publicación, pero el siguiente código demuestra el uso principal de la coriculización:
const f = R.Curry ((x, y) => x + y) f (1, 10) // == 11f (1) (10) // == 11Const Plus1 = F (1) Plus1 (10) // == 11
Por otro lado, hay varios problemas con TimeIT implementado de esta manera:
(... args) => {const t1 = date.now () llamado (... args) Informe (t1 - t0, ... args)} Esta es una función anónima (también conocida como lambda, devolución de llamada) que se llama después de que la función original se ejecuta asincrónicamente. El principal problema es que esta función no tiene mecanismo para manejar excepciones. Si callback lanza una excepción, report nunca se llamará.
Podemos agregar una try / catch a esta función lambda , pero la raíz del problema es que callback y report son dos funciones void , y no están asociadas. timeIt contiene dos continuaciones ( report y callback ). Si solo registramos el tiempo de ejecución en console o si estamos seguros de que ni report ni callback arrojarán excepciones, entonces todo está bien. Pero si queremos realizar algún comportamiento basado en los resultados del análisis (llamado escala automática), entonces necesitamos fortalecer y aclarar la secuencia de continuación en nuestro programa.
De acuerdo, espero que el contenido completo de este artículo sea útil para el estudio y el trabajo de todos. Si tiene alguna pregunta, puede dejar un mensaje para comunicarse.