¿Qué significa = + _ en JavaScript?

Me preguntaba qué significa el operador = + _ en JavaScript. Parece que hace tareas.

Ejemplo:

hexbin.radius = function(_) {
   if (!arguments.length)
       return r;
   r = +_;
   dx = r * 2 * Math.sin(Math.PI / 3);
   dy = r * 1.5;
   return hexbin;
};

r = +_;

• +intenta lanzar lo que _sea ​​a un número.
• _es solo un nombre de variable (no un operador), podría ser a, fooetc.

Ejemplo:

+"1"

lanzar "1" al número puro 1.

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

res ahora 1no "1".

Además, según la página MDN sobre operadores aritméticos :

El operador unario más precede a su operando y lo evalúa, pero intenta convertirlo en un número, si aún no lo está . [...] Puede convertir representaciones de cadena de números enteros y flotadores, así como los valores que no son cadenas true, falsey null. "0x"Se admiten enteros en formato decimal y hexadecimal ( prefijado). Se admiten números negativos (aunque no para hexadecimal). Si no puede analizar un valor particular, lo evaluará NaN.

También se observa que

Unary Plus es la forma más rápida y preferida de convertir algo en un número

No es un operador de asignación.

• _ es solo un parámetro pasado a la función.

  hexbin.radius = function(_) {
                  //       ^ It is passed here
      // ...
  };
  

• En la línea siguiente, r = +_; +delante convierte esa variable ( _) en un número o valor entero y lo asigna a la variabler

NO LO confunda con el +=operador

=+en realidad son dos operadores =es asignación +y _es nombre de variable.

me gusta:

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

Los siguientes códigos lo ayudarán a mostrar el uso de =+convertir una cadena en int .
ejemplo:

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

salidas 10

uso: Entonces aquí yestá int 5por lo =+
contrario:

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

salidas 55

Donde como _es una variable.

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

salidas 10

Además, sería interesante saber que también podría lograr lo mismo con ~(si string es int string (float será redondeado a int) )

y = ~~'5'  // notice used two time ~
x = y  + 5
alert(x);

también salidas 10

~NO es bit a bit: invierte los bits de su operando. Lo hice dos veces sin ningún cambio de magnitud.

No es =+. En JavaScript, +significa cambiarlo a número.

+'32' devuelve 32.

+'a' devuelve NaN.

Por lo tanto, puede isNaN()verificar si se puede cambiar a número.

Es astuto.

Lo importante es entender que el carácter de subrayado aquí es en realidad un nombre de variable , no un operador.

El signo más delante de eso es obtener el valor numérico positivo de subrayado, es decir, convertir efectivamente la variable de subrayado para que sea un int. Podría lograr el mismo efecto con parseInt(), pero la conversión de signos más probablemente se use aquí porque es más concisa.

Y eso solo deja el signo igual como solo una asignación de variable estándar.

Probablemente no esté escrito deliberadamente para confundir, ya que un programador Javascript experimentado generalmente reconocerá el guión bajo como una variable. Pero si no sabes que definitivamente es muy confuso. Ciertamente no lo escribiría así; No soy fanático de los nombres cortos de variables sin sentido en el mejor de los casos: si desea nombres cortos de variables en el código JS para ahorrar espacio, use un minificador; no lo escriba con variables cortas para comenzar.

= + _ arrojará _ en un número.

Entonces

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

saldría número.

Supongo que quieres decir r = +_;? En ese caso, es la conversión del parámetro a a Number. Digamos que _es '12 .3 ', luego +'12.3'regresa 12.3. Por lo tanto, en la declaración citada +_se asigna a r.

_es solo un nombre de variable, se pasa como un parámetro de función hexbin.radiusy +se convierte en número

Déjame hacer un ejemplo igual a tu función.

var hexbin = {},r  ;

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

y ejecuta esta función de ejemplo ... que genera

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 (verdadero);

true boolean
1 number false

Asignará un nuevo valor a la variable del lado izquierdo.

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

+_es casi equivalente de parseFloat(_). Observe que parseIntse detendrá en caracteres no numéricos como el punto, mientras parshFloatque no lo hará.

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

Muy pocas diferencias:

• La cadena vacía se ""evalúa como a 0, mientras que parseInt () se evalúa comoNaN
• Para obtener más información, consulte aquí: parseInt vs unary plus: cuándo usar qué

En pocas palabras, +_ es equivalente a usar el constructor Number () .

De hecho, incluso funciona en fechas:

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

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

También se puede encontrar más información en la sección MDN - Unary plus (+) :

El operador unario más precede a su operando y lo evalúa, pero intenta convertirlo en un número, si aún no lo está. Aunque la negación unaria (-) también puede convertir no números, unario más es la forma más rápida y preferida de convertir algo en un número, ya que no realiza ninguna otra operación en el número. Puede convertir representaciones de cadenas de enteros y flotantes, así como los valores que no son cadenas verdadero, falso y nulo. Se admiten enteros en formato decimal y hexadecimal ("0x" -prefijado). Se admiten números negativos (aunque no para hexadecimal). Si no puede analizar un valor particular, se evaluará a NaN.

En esta expresión:

r = +_;

• '+' actúa aquí como un operador unario que intenta convertir el valor del operando correcto. No convierte el operando sino el valor evaluado. Por _lo tanto, se mantendrá "1" si fue así originalmente, pero rse convertirá en un número puro.

Considere estos casos si uno quiere aplicar el + para la conversión numérica

+"-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

Sin embargo, es el convertidor numérico más rápido. Apenas recomendaría uno para usarlo en exceso si lo utiliza. parseInt/parseFloatson buenas alternativas más legibles.