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?

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

Can someone please update on this...Thanks.

so @GabyakaG.Petrioli if you call that function with any parameter irrespective of type or no. of parameters..it will call that function? — Azhar, Dec 24 '14 at 12:42
In the specific function if you pass no parameters it will return `lines.x` right away, if you pass more than one, then it will use the first only and pass it to `lines.x` and `lines2.x` and finally return the `chart`. — Gabriele Petrioli, Dec 24 '14 at 12:44

score 131 · Accepted Answer · edited Dec 08 '19 at 00:36

131

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.

edited Dec 08 '19 at 00:36

Software Engineer

15,457
7
74
102

answered Dec 24 '14 at 12:35

sagar43

3,341
3
29
49

2

If it was omitted entirely, then he would have nothing to pass to `lines.x()` and `lines2.x(_)`. – Dec 24 '14 at 12:59
1

To confirm my understanding, passing `_` in this case is equivalent to passing `null`, and `_` is used just for aesthetics/readability? – remjx Dec 10 '18 at 00:12
2

@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 – Felipe May 20 '19 at 17:01
@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. – Simon Alling Aug 26 '19 at 13:55
@SimonAlling I've edited the answer to address your concerns. – Software Engineer Dec 08 '19 at 00:36
1

@sagar43 Could you please elaborate on how "the second version is safer"? – Asker Dec 23 '20 at 17:51
In your case `arr.forEach(function (_, i) {..})`, what should I use for the second parameter if I want to get only the third parameter...? – MattTreichel Aug 23 '23 at 15:28

score 19 · Answer 2 · answered Jan 05 '20 at 19:42

_ 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

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

2 Answers2

Linked

Related