Curry en JavaScript explicado con ejemplos

va adentro JavaScript es un proceso dentro programación funcional puede convertir una función con muchos argumentos en una secuencia de funciones anidadas. Devuelve una nueva función que inserta el siguiente argumento en la matriz.

En otras palabras, en lugar de que una función tome todos los argumentos a la vez, toma el primero y devuelve una nueva función, que toma el segundo y devuelve una nueva función que toma el tercero, y así sucesivamente. se ha cumplido.

Es decir, cuando convertimos una llamada de función sum(1,2,3) incluido sum(1)(2)(3).

También llamado el número de argumentos que acepta una función. arity.

function sum(a, b) {
    // do something
}
function _sum(a, b, c) {
    // do something
}

Función sum toma dos argumentos (dos funciones arit) y _sum toma tres argumentos (una función de tres argumentos).

Las funciones curry se construyen encadenando cierres y definiendo simultáneamente y devolviendo inmediatamente sus funciones internas.

¿Por qué curry es útil en JavaScript?

1. Currying te ayuda a pasar la misma variable una y otra vez.
2. Ayuda a crear una función de nivel superior.

Currying convierte una función de múltiples argumentos en una secuencia/serie de funciones que toman cada una un solo argumento.

Por ejemplo:

function sum(a, b, c) {
    return a + b + c;
}
sum(1,2,3); // 6

Como puede ver, esta es una función con argumentos enteros. Creemos una versión curva de la función y veamos cómo llamar a la misma función (y obtener el mismo resultado) serie de llamadas:

function sum(a) {
    return (b) => {
        return (c) => {
            return a + b + c
        }
    }
}
console.log(sum(1)(2)(3)) // 6

Incluso podemos separarlo. sum(1)(2)(3) para un mejor entendimiento:

const sum1 = sum(1);
const sum2 = sum1(2);
const result = sum2(3);
console.log(result); // 6

Más sobre JavaScript: ¿Qué son los patrones de diseño de JavaScript?

¿Cómo funciona Currying en JavaScript?

Veamos cómo funciona el curry. Pasamos 1 por sum función:

let sum1 = sum(1);

Esta función devuelve:

return (b) => {
        return (c) => {
            return a + b + c
        }
}

ahora, sum1 tiene la definición de función anterior que toma un argumento b.

llamamos sum1 función, inclusión 2:

let sum2 = sum1(2);

Él sum1 devolverá la tercera función:

return (c) => {
            return a + b + c
}

La función devuelta ahora se almacena en un archivo sum2 variable.

sum2 estarán:

sum2 = (c) => {
            return a + b + c
}

Cuándo sum2 se llama con 3 como parámetro const result = sum2(3);calcula con los parámetros dados anteriormente: a = 1, b = 2 y regresa 6.

console.log(result); // 6

La última función solo acepta c variable, pero realizará la operación en otras variables que ya han sido devueltas por el alcance de la función envolvente. Sin embargo, funciona gracias a eso. Closure.

Más sobre JavaScript: 8 estructuras de datos de JavaScript comunes

curry vs. Implementación parcial en JavaScript

Algunos podrían comenzar a pensar que la cantidad de funciones internas de una función seleccionada depende de la cantidad de argumentos que acepta. Sí, eso lo convierte en un curry.

tomemos lo mismo sum ejemplo:

function sum(a) {
    return (b, c) => {
        return a * b * c
    }
}

Se puede llamar:

let x = sum(10);
x(3,12);
x(20,12);
x(20,13);
// OR
sum(10)(3,12);
sum(10)(20,12);
sum(10)(20,13);

La función anterior espera tres argumentos y tiene dos funciones anidadas a diferencia de nuestra versión anterior que esperaba tres argumentos y tenía tres funciones anidadas.

Esta versión no es un curry. Solo hemos aplicado parcialmente sum función.

Está relacionado con el curry y la aplicación parcial. cierrepero son conceptos diferentes.

Una implementación parcial transforma una función en otra función con una aritmética menor.

function sum1(x, y, z) {
    return sum2(x,y,z)
}
// to
function sum1(x) {
    return (y,z) => {
        return sum2(x,y,z)
    }
}

Para curry, se ve así:

function sum1(x) {
    return (y) = > {
        return (z) = > {
            return sum2(x,y,z)
        }
    }
}

Currying crea funciones anidadas según el número de argumentos de la función. Cada función toma un argumento. Si no hay argumento, no hay curry.

Así es como puede desarrollar una función que toma una función y devuelve una función de bucle:

function currying(fn, ...args) {
    return (..._arg) => {
        return fn(...args, ..._arg);
    }
}

La función anterior acepta una función (fn) y un número variable de parámetros (…args). Después del operador resto, se usa para sumar el número de parámetros. fn incluido …args.

A continuación, devolvemos una función que también recopila los parámetros restantes …_args. Esta función llama a la función original fn pasar a …args y …_args utilizando el operador de propagación como parámetros. A continuación, el valor se devuelve al usuario.

Ahora podemos crear una función de curry usando la función anterior.

function sum(a,b,c) {
    return a + b + c
}
let add = currying(sum,10);
add(20,90); // 120
add(70,60); // 140

El cierre hace posible el curry en JavaScript. Espero que hayas aprendido algo nuevo sobre el curry.