Implement Infinite Currying Multiplication in JavaScript: mul(2)(3)(4)

Currying in JavaScript provides a way to implement partial functions in JavaScript, and one of the use cases is to implement Infinite currying in JavaScript to calculate multiplication using partial functions, such as mul(2)(3)(4). This is one of the most common JavaScript interview questions.

Implementing Infinite Currying Multiplication in JavaScript

Let's implement a function that performs infinite multiplication using currying. The function should be able to take any number of arguments and return the multiplication of all those arguments. This is known as Infinite Currying Multiplication.

Steps to Implement Infinite Currying Multiplication

1. Create a function called curryMultiply that takes one argument.
2. Within the curryMultiply function, return another function that takes the next argument.
3. Inside the nested function, multiply the current argument with the accumulated product.
4. Return the nested function if there are more arguments to process, or return the accumulated product if all arguments have been processed.

Code Example

function curryMultiply(x) {
    let mul = x;
    
    // Multiply and return another function
    function inner(y) {
        mul = mul * y;
        return inner;
    }

    inner.toString = function() {
        return mul;
    };

    return inner;
}

// Usage
const result = curryMultiply(2)(3)(4)(5);
console.log(result.toString()); // Output: 120

Explanation of the Code

In the above code snippet, we define a function curryMultiply that takes an initial argument x. The inner function inner is returned, which multiplies the current argument with the accumulated product and returns itself to allow chaining.

Inner function has access to the mul at any given point of time due to closure in JavaScript. We also override the toString method of the inner function to return the accumulated product when the function is converted to a string.

Real-World Example: Calculating Total Price

Let's consider a real-world example where Infinite Currying Multiplication can be useful. Suppose you need to create a calculator application, where we can have a mul partial function which can used to provide multiplication whenever user enter any number and hit multiplication.

// Calculator example
const mul = curryMultiply(1);

const multiplication = mul(10)(20)(30)(40);
console.log(multiplication.toString()); // Output: 240000 

Benefits of Infinite Currying Multiplication

• Allows for flexible and clean function chaining.
• Enables the creation of specialized partial functions dynamically.
• Reduces repetitive code when dealing with multiple operations.

Final thoughts

Practice implementing Infinite Currying Multiplication with different scenarios to solidify your understanding. This knowledge will not only help you tackle interview questions but also improve your problem-solving skills in frontend development.

Learn Next

1. Top JavaScript Interview questions
2. Promise Polyfill in JavaScript
3. Promise.all Polyfill in JavaScript
4. 5 Rules to master this keyword in JavaScript