# What does = +_ mean in JavaScript

I was wondering what the = +_ operator means in JavaScript. It looks like it does assignments.

Example:

``````hexbin.radius = function(_) {
if (!arguments.length)
return r;
r = +_;
dx = r * 2 * Math.sin(Math.PI / 3);
dy = r * 1.5;
return hexbin;
};
`````` ``````r = +_;
``````
• `+` tries to cast whatever `_` is to a number.
• `_` is only a variable name (not an operator), it could be `a`, `foo` etc.

Example:

``````+"1"
``````

cast "1" to pure number 1.

``````var _ = "1";
var r = +_;
``````

`r` is now `1`, not `"1"`.

Moreover, according to the MDN page on Arithmetic Operators:

The unary plus operator precedes its operand and evaluates to its operand but attempts to converts it into a number, if it isn't already. [...] It can convert string representations of integers and floats, as well as the non-string values `true`, `false`, and `null`. Integers in both decimal and hexadecimal (`"0x"`-prefixed) formats are supported. Negative numbers are supported (though not for hex). If it cannot parse a particular value, it will evaluate to `NaN`.

It is also noted that

unary plus is the fastest and preferred way of converting something into a number It is not an assignment operator.

• `_` is just a parameter passed to the function.

``````hexbin.radius = function(_) {
//       ^ It is passed here
// ...
};
``````
• On the next line `r = +_;` `+` infront casts that variable (`_`) to a number or integer value and assigns it to variable `r`

DO NOT CONFUSE IT WITH `+=` operator `=+` are actually two operators `=` is assignment and `+` and `_` is variable name.

like:

``````i = + 5;
or
j = + i;
or
i = + _;
``````

My following codes will help you to show use of `=+` to convert a string into int.
example:

``````y = +'5'
x = y +5
``````

outputs 10

use: So here `y` is int `5` because of `=+`
otherwise:

``````y = '5'
x = y +5
``````

outputs 55

Where as `_` is a variable.

``````_ = + '5'
x = _ + 5
``````

outputs 10

Additionally, It would be interesting to know you could also achieve same thing with `~` (if string is int string (float will be round of to int))

``````y = ~~'5'  // notice used two time ~
x = y  + 5
``````

also outputs 10

`~` is bitwise NOT : Inverts the bits of its operand. I did twice for no change in magnitude. It's not `=+`. In JavaScript, `+` means change it into number.

`+'32'` returns 32.

`+'a'` returns NaN.

So you may use `isNaN()` to check if it can be changed into number. It's a sneaky one.

The important thing to understand is that the underscore character here is actually a variable name, not an operator.

The plus sign in front of that is getting the positive numerical value of underscore -- ie effectively casting the underscore variable to be an int. You could achieve the same effect with `parseInt()`, but the plus sign casting is likely used here because it's more concise.

And that just leaves the equals sign as just a standard variable assignment.

It's probably not deliberately written to confuse, as an experienced Javascript programmer will generally recognise underscore as a variable. But if you don't know that it is definitely very confusing. I certainly wouldn't write it like that; I'm not a fan of short meaningless variable names at the best of times -- If you want short variable names in JS code to save space, use a minifier; don't write it with short variables to start with. = +_ will cast _ into a number.

So

``````var _ = "1",
r = +_;
console.log(typeof r)
``````

would output number. I suppose you mean `r = +_;`? In that case, it's conversion of the parameter to a `Number`. Say `_` is '12.3', then `+'12.3'` returns `12.3`. So in the quoted statement `+_` is assigned to `r`. `_` is just a a variable name, passed as a parameter of function `hexbin.radius` , and `+` cast it into number

Let me make a exmple same like your function .

``````var hexbin = {},r  ;

if (!arguments.length)
return r;
console.log( _ , typeof _ )
r = +_;
console.log( r , typeof r , isNaN(r) );
}
``````

and run this example function .. which outputs

``````1 string
1 number false
``````

``````1 number
1 number false
``````

``````[] object
0 number false
``````

``````a string
NaN number true
``````

``````Object {} object
NaN number true
``````

``````true boolean
1 number false
`````` It Will assign new value to left side variable a number.

``````var a=10;
var b="asg";
var c=+a;//return 10
var d=-a;//return -10
var f="10";

var e=+b;
var g=-f;

console.log(e);//NAN
console.log(g);//-10
`````` `+_` is almost equivalent of `parseFloat(_)` . Observe that `parseInt` will stop at non numeric character such as dot, whereas `parshFloat` will not.

EXP:

``````    parseFloat(2.4) = 2.4
vs
parseInt(2.4) = 2
vs
+"2.4" = 2.4
``````

Exp:

``````var _ = "3";
_ = +_;

console.log(_); // will show an integer 3
``````

Very few differences: Simply put, `+_` is equivalent to using the Number() constructor.

In fact, it even works on dates:

``````var d = new Date('03/27/2014');
console.log(Number(d)) // returns 1395903600000
console.log(+d) // returns 1395903600000
``````

More information can also be found on MDN - Unary plus (+) section:

The unary plus operator precedes its operand and evaluates to its operand but attempts to converts it into a number, if it isn't already. Although unary negation (-) also can convert non-numbers, unary plus is the fastest and preferred way of converting something into a number, because it does not perform any other operations on the number. It can convert string representations of integers and floats, as well as the non-string values true, false, and null. Integers in both decimal and hexadecimal ("0x"-prefixed) formats are supported. Negative numbers are supported (though not for hex). If it cannot parse a particular value, it will evaluate to NaN. In this expression:

``````r = +_;
``````
• '+' acts here as an unary operator that tries to convert the value of the right operand. It doesn't convert the operand but the evaluated value. So `_` will stay "1" if it was so originally but the `r` will become pure number.

Consider these cases whether one wants to apply the + for numeric conversion

``````+"-0" // 0, not -0
+"1" //1
+"-1" // -1
+"" // 0, in JS "" is converted to 0
+null // 0, in JS null is converted to 0
+undefined // NaN
+"yack!" // NaN
+"NaN" //NaN
+"3.14" // 3.14

var _ = "1"; +_;_ // "1"
var _ = "1"; +_;!!_ //true
var _ = "0"; +_;!!_ //true
var _ = null; +_;!!_ //false
``````

Though, it's the fastest numeric converter I'd hardly recommend one to overuse it if make use of at all. `parseInt/parseFloat` are good more readable alternatives.