Que signifie = + _ en JavaScript

Je me demandais ce que l' opérateur = + _ signifie en JavaScript. On dirait qu'il fait des affectations.

Exemple:

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

r = +_;

• +essaie de convertir tout ce qui _est en nombre.
• _n'est qu'un nom de variable (pas un opérateur), ça pourrait l'être a, fooetc.

Exemple:

+"1"

transtypez "1" en nombre pur 1.

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

rest maintenant 1, non "1".

De plus, selon la page MDN sur les opérateurs arithmétiques :

L'opérateur unaire plus précède son opérande et évalue son opérande mais tente de le convertir en nombre, s'il ne l'est pas déjà . [...] Il peut convertir des représentations de chaîne de nombres entiers et flottants, ainsi que les valeurs non-chaîne true, falseet null. Les entiers aux "0x"formats décimal et hexadécimal ( préfixé) sont pris en charge. Les nombres négatifs sont pris en charge (mais pas pour hex). S'il ne peut pas analyser une valeur particulière, il évaluera NaN.

Il est également noté que

plus unaire est le moyen le plus rapide et préféré de convertir quelque chose en nombre

Ce n'est pas un opérateur d'affectation.

• _ est juste un paramètre passé à la fonction.

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

• Sur la ligne suivante r = +_; + infront convertit cette variable ( _) en un nombre ou une valeur entière et l'affecte à la variabler

NE PAS LE CONFONDRE AVEC l' +=opérateur

=+sont en fait deux opérateurs =est l'affectation et +et _ est un nom de variable.

comme:

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

Mes codes suivants vous aideront à montrer l'utilisation de =+pour convertir une chaîne en int .
exemple:

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

sorties 10

use: Voici ydonc int à 5cause du =+
contraire:

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

sorties 55

Où as _est une variable.

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

sorties 10

De plus, il serait intéressant de savoir que vous pourriez également obtenir la même chose avec ~(si la chaîne est int chaîne (float sera arrondi à int) )

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

produit également 10

~est au niveau du bit NON: inverse les bits de son opérande. Je l'ai fait deux fois sans changement d'amplitude.

Ça ne l'est pas =+. En JavaScript, cela +signifie le changer en nombre.

+'32' renvoie 32.

+'a' renvoie NaN.

Vous pouvez donc utiliser isNaN()pour vérifier s'il peut être changé en nombre.

C'est sournois.

La chose importante à comprendre est que le caractère de soulignement ici est en fait un nom de variable , pas un opérateur.

Le signe plus devant cela obtient la valeur numérique positive du trait de soulignement - c'est-à-dire que la conversion effective de la variable de soulignement en un int. Vous pouvez obtenir le même effet avec parseInt(), mais le casting du signe plus est probablement utilisé ici car il est plus concis.

Et cela laisse juste le signe égal comme juste une affectation de variable standard.

Ce n'est probablement pas délibérément écrit pour confondre, car un programmeur Javascript expérimenté reconnaîtra généralement le trait de soulignement comme une variable. Mais si vous ne savez pas, c'est vraiment très déroutant. Je ne l'écrirais certainement pas comme ça; Je ne suis pas un fan des noms de variables courts sans signification dans le meilleur des cas - Si vous voulez que les noms de variables courts en code JS économisent de l'espace, utilisez un minifieur; ne l'écrivez pas avec des variables courtes pour commencer.

= + _ convertira _ en nombre.

Alors

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

donnerait un numéro.

Je suppose que tu veux dire r = +_;? Dans ce cas, c'est la conversion du paramètre en a Number. Dites _est «12,3», puis +'12.3'revient 12.3. Ainsi, dans la déclaration citée +_est affectée à r.

_est juste un nom de variable, passé en paramètre de la fonction hexbin.radiuset +converti en nombre

Permettez-moi de faire un exemple similaire à votre fonction.

var hexbin = {},r  ;

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

et exécutez cet exemple de fonction .. qui génère

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

true boolean
1 number false

Il attribuera une nouvelle valeur à la variable de gauche un nombre.

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

+_est presque équivalent de parseFloat(_). Observez que parseIntcela s'arrêtera au caractère non numérique tel que le point, alors que parshFloatnon.

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

Très peu de différences:

• Une chaîne vide est ""évaluée en a 0, tandis que parseInt () est évaluée enNaN
• Pour plus d'informations, regardez ici: parseInt vs unary plus - quand utiliser lequel

Autrement dit, +_ équivaut à utiliser le constructeur Number () .

En fait, cela fonctionne même sur les dates:

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

DÉMO: http://jsfiddle.net/dirtyd77/GCLjd/

Vous trouverez également plus d'informations sur MDN - Unary plus (+) :

L'opérateur unaire plus précède son opérande et évalue son opérande mais tente de le convertir en nombre, s'il ne l'est pas déjà. Bien que la négation unaire (-) puisse également convertir des non-nombres, unaire plus est le moyen le plus rapide et préféré de convertir quelque chose en nombre, car il n'effectue aucune autre opération sur le nombre. Il peut convertir des représentations de chaîne d'entiers et de flottants, ainsi que les valeurs non-chaîne true, false et null. Les entiers aux formats décimal et hexadécimal ("0x" -préfixé) sont pris en charge. Les nombres négatifs sont pris en charge (mais pas pour hex). S'il ne peut pas analyser une valeur particulière, il sera évalué à NaN.

Dans cette expression:

r = +_;

• '+' agit ici comme un opérateur unaire qui essaie de convertir la valeur de l'opérande droit. Il ne convertit pas l'opérande mais la valeur évaluée. Il _restera donc "1" s'il en était ainsi à l'origine, mais le rnombre deviendra pur.

Considérez ces cas si l'on veut appliquer le + pour la conversion numérique

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

Cependant, c'est le convertisseur numérique le plus rapide que je recommanderais à peine d'en abuser s'il est utilisé. parseInt/parseFloatsont de bonnes alternatives plus lisibles.