What does = +_ mean in JavaScript

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
alert(x);

outputs 10

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

y = '5'
x = y +5
alert(x);

outputs 55

Where as _ is a variable.

_ = + '5'
x = _ + 5
alert(x)

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
alert(x);

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  ;

hexbin.radius = function(_) {
   if (!arguments.length)
      return r;
   console.log( _ , typeof _ )    
   r = +_;
   console.log( r , typeof r , isNaN(r) );   
}

and run this example function .. which outputs

hexbin.radius( "1");

1 string
1 number false 

hexbin.radius( 1 );

1 number
1 number false

hexbin.radius( [] );

[] object
0 number false

hexbin.radius( 'a' );

a string
NaN number true

hexbin.radius( {} );

Object {} object
NaN number true

hexbin.radius( 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

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

DEMO: http://jsfiddle.net/dirtyd77/GCLjd/

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.

+_ 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:

• Empty string "" evaluates to a 0, while parseInt() evaluates to NaN
• For more info look here: parseInt vs unary plus - when to use which

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.