What is the meaning of an Underscore in javascript function parameter?

Question

I was going through the code of one of the chart library written in javascript, wherein I've seen passing underscore(_) as a function parameter. What does that mean?

e.g.

chart.x = function(_) {
    if (!arguments.length) return lines.x;
    lines.x(_);
    lines2.x(_);
    return chart;
  };

Can someone please update on this...Thanks.

Solution 1

The underscore symbol _ is a valid identifier in JavaScript, and in your example, it is being used as a function parameter.

A single underscore is a convention used by some javascript programmers to indicate to other programmers that they should "ignore this binding/parameter". Since JavaScript doesn't do parameter-count checking the parameter could have been omitted entirely.

This symbol is often used (by convention again) in conjunction with fat-arrow functions to make them even terser and readable, like this:

const fun = _ => console.log('Hello, World!')
fun()

In this case, the function needs no params to run, so the developer has used the underscore as a convention to indicate this. The same thing could be written like this:

const fun = () => console.log('Hello, World!')
fun()

The difference is that the second version is a function with no parameters, but the first version has a parameter called _ that is ignored. These are different though and the second version is safer, if slightly more verbose (1 extra character).

Also, consider a case like

arr.forEach(function (_, i) {..})

Where _ indicates the first parameter is not to be used.

The use of underscores like this can get very confusing when using the popular lodash or underscore libraries.

Solution 2

_ in fat arrow function is called as throwaway variable. It means that actually we're creating an variable but simply ignoring it. More devs are now a days using this as syntactic sugar or short hand while writing code, as it's easy and one character less to write the code.

Instead of using _, you can use other variables like temp, x, etc

for examples:

() => console.log('Hello World')



_ => console.log('Hello World')




x => console.log('Hello World')

But personally i prefer to use () type over throwaway variable if no arguments are needed.

See the following code, then you will understand it better.

_ as an argument,

  f = _=> {
    return _ + 2 ;
}

f(3) will return 5

For better understanding, check wes bos

Comments

[Admin]

If it was omitted entirely, then he would have nothing to pass to lines.x() and lines2.x(_).

[remjx]

To confirm my understanding, passing _ in this case is equivalent to passing null, and _ is used just for aesthetics/readability?

[Felipe]

@MarkJackson The _ will still hold a value. You can test this by declaring a function with a parameter _ that logs that parameter, and you will see it logs whatever was passed in

[Simon Alling]

@MarkJackson: No, _ isn't special; it's a valid identifier in JS, just like x or foo. These definitions are equivalent: a) function f(x) { return x; }, b) function f(_) { return _; }. I'd say @sagar43's answer is incorrect, because _ is in fact used in the body of chart.x, so omitting the parameter (chart.x = function() { ... }) would change the function's semantics.

[Software Engineer]

@SimonAlling I've edited the answer to address your concerns.

[Asker]

@sagar43 Could you please elaborate on how "the second version is safer"?