Understand the function in JavaScript and when to use it.

In this article, we will discuss functional care in JavaScript, a modern concept in functional programming.

JavaScript is one of the basic technologies of the web. The majority of websites use it, and all modern web browsers support it without the need for plugins. In this regard, we are discussing various tips and tricks that will help you develop your daily JavaScript.

What is Function Curry?

Function Creation is an advanced technique for working with JavaScript functions. In fact, it is not limited to JavaScript – it is also used in other programming languages.

According to Wikipedia:

Caring is a function-changing technique that moves multiple arguments into a sequence of functions, each of which takes an argument.

In other words, curry is just a change of function that takes multiple arguments into a set of household functions that take the same argument. For example, for a function. f It takes three arguments, you will like it. f(arg1, arg2, arg3). This is how you can call a function carrier when you use it. f(arg1)(arg2)(arg3).

Let’s say you have a function that takes three arguments, as shown in the following paragraphs.

function fooBar(arg1, arg2, arg3) {
   …
}

To call this function, you will use the following syntax.

fooBar(1,2,3);

Now, let’s see a simple implementation of the Cred version of the above function:

function fooBarCurriedVersion(arg1) {
  return (arg2) => { 
    return (arg3) => { 
      return fooBar(arg1, arg2, arg3)
    }  
  }
}

And with that, you can make calls fooBarCurriedVersion Work with the following syntax:

fooBarCurriedVersion(arg1)(arg2)(arg3);

One of the advantages of this is that you can move any argument into a function. For example, if you only know its value. arg1 At some point in the code, you can simply call the credited function with that argument and move the resulting function to the rest of your code.

Let’s try to understand how it works.

First of all , fooBarCurriedVersion(arg1) The statement is acted upon, and it returns a caliber that takes the same argument. Next, the callable function that is returned by. fooBarCurriedVersion Called with function. arg2 Argument, and it returns the caliber, which takes the same argument. Finally, the calibration function returning from the previous step is called with. arg3 Reason.

It is important to note that since all functions are turned off, the values ​​of the argument that are accepted are stored between function calls. So once you call the argument of a cold function, the example of that function will fix that argument, no matter what other examples you make later.

You can also call the credit function as shown in the following paragraphs. It works evenly. fooBar(arg1)(arg2)(arg3).

let callableOne = fooBarCurriedVersion(arg1);
let callableTwo = callableOne(arg2);
let result = callableTwo(arg3);

As you can see, when we are using function carriage, the function takes the same argument and the caller returns the function, which takes the next argument and returns the second calibrated function, and so on until all the arguments Do not run out

In fact, you can say it as shown in the following pieces.

let callable = fooBarCurriedVersion(1);
let result = callable(2)(3);

So these are the basics of function care in JavaScript. In the next section, we will go through a real world example to show how it works.

A real world example.

Now, you know how the function Carry works in JavaScript. In this section, we will see how you can use it in your daily JavaScript development.

First, let’s look at the following function, which calculates the final price of a product after adding the necessary charges and applying a discount.

function calFinalPrice(actualPrice, charges, discountRate) {
    var finalPrice;

    finalPrice = actualPrice + charges - (actualPrice * discountRate/100);
}

Now, you can call this function as shown in the following paragraphs.

const actualPrice = 100;
const charges = 20;

// get discount rate from the configuration
const discountRate = getDiscountRateFromConfig();

calFinalPrice(actualPrice, charges, discountRate);

As you can see, we are taking a discount rate from the configuration, so it’s going to be fine every time. So we can avoid passing it in the third argument every time. calFinalPrice Function, if we create an older version of the function as shown in the following paragraphs.

First, we have implemented. calFinalPriceWithDiscount Function, which is the carred version. calFinalPrice In the first argument of the function. calFinalPriceWithDiscount Function, we have passed the discount rate, which will be used later to calculate the final price of the product.

Of discVersionFunc The variable holds a calibrator, which takes two arguments: the actual cost and the charges. Since discVersionFunc The version wraps up the discount rate, you don’t have to pass it every time you need to calculate the final price of the product.

Finally, you can calculate the final price of a product by passing the price and charge values, as shown in the section above.

Now, we say you want to give a special discount for a while. You can still use it calFinalPriceWithDiscount Function, as shown in the following paragraphs.

const speicalDiscountRate = getSpecialDiscountRateFromConfig();
const specialDiscVersionFunc = calFinalPriceWithDiscount(specialDiscountRate);

alert(specialDiscVersionFunc(100)(25));
alert(specialDiscVersionFunc(200)(15));

As you can see, the main advantage of function carrier is that when you need to repeatedly call a function with the same parameters, you can reuse and refactor your code, which over time At the same time, it is very easy to maintain.

When to use Function Curry

Creating a function may be helpful in some cases, but it is not something you want to default with all your functions. Consider function carrying when it helps you in one of these goals:

• Writing cleaner code
• Removing expensive calculations
• Creating a single argument function for. map Or forEach

Write cleaner code with less repetition.

Sometimes performing a function can simplify your code. Suppose you have a logging function. logToFile(filename, appname, text) Inserts some text into the file. To make it easier to include logging statements in your code, you’ll want to set the file name and app name once and then type something like this. log(text). To achieve this, you can create a version of the logging function:

//a curried version of the logging function
const logCurried = filename => appname => text => logToFile(filename, appname, text)

//create logging functions for a specific file and app
let log = logCurried("somepath/filename-error.log")("My App")
let logWarning = logCurried("somepath/filename-warning.log")("My App")

//now we can use the functions like this:
log("an error occurred")
logWarning("just a warning")

Remove expensive accounts.

Another use for credited functions is to save expensive calculations such as file I / O or database reading. For example, let’s say you have the following function:

//get attributes from an item in the database
function getItemAttribute (id, attribute) {
    //read the item from the database
    let item = databaseRead(id)
    
    //return the requested attribute value
    return  item[attribute]
}

//get some attributes from a particular item
let color=getItemAttribute("item001", "color")
let shape=getItemAttribute("item001", "shape")
let size=getItemAttribute("item001", "size")

Suppose we wanted to read multiple attributes in a row from the same function. This means reading the same database record multiple times, which is pointless and slow. We can rewrite. getItemAttribute Work with curry to make it more effective:

//get attributes from an item in the database
function getItemAttribute (id) {
    //read the item from the database
    let item = databaseRead(id)
    
    //and return a function to get attributes from that item
    return attribute => item[attribute]
}

//get some attributes from a particular item
const item001 = getItemAttributes("item001")
let color=item001("color")
let shape=item001("shape")
let size=item001("size")

Create a single argument function for. map Or forEach

Using map And forEach Ways, you can apply functions to every element of a row. However, these methods expect that the function will have a specific signature – usually you will want to use only one parameter method. Using Function Carrier, you can create versions of any function that can be used with. map Or forEach.

Can learn more about you map And forEach In our other JavaScript tutorials.

• 
  Javascript
  Map, filter and minimize in JavaScript
  Pelek horn stock.
• 
  Javascript
  JavaScript Map vs. Everyone: When to Use Everyone.
  سجل سونی

Result

Today, we discussed how the function Carry works in JavaScript. We also went through some real world examples to understand the practical use of function carry in JavaScript.