JavaScript: Chaîne comparée à numérique

Question

Nous savons que par défaut, le 'obj' ci-dessous est une chaîne. Sans utiliser 'parseInt', comment JavaScript le compare-t-il à un nombre?

obj = document.frm.weight.value; 
if(obj < 0 || obj > 5){ 
    alert("Enter valid range!"); 
    return false; 
} 

Answer 1

Si l'un des opérandes de < ou > est le numéro, l'autre sera casté à un certain nombre.

alert("3" > 3); // false 
alert("3.5" > 3); // true 

EDIT et d'autres explications:

S'il est impossible de lancer l'autre paramètre dans un certain nombre, il est casté dans la valeur spéciale appelée NaN - l'abréviation signifie «N ot aN umber ". La valeur NaN a une propriété spéciale qui est absolument incomparable - tous les opérateurs de relation comme <, > et = renverront false si l'un des arguments est NaN.

alert("" > 3);  // false 
alert("3.5?" > 3); // false 
alert({} > 3);  // false 

Notez également que dans la deuxième ligne, si nous avons utilisé

alert(parseInt("3.5?") > 3); 

il alerte true, parce que parseInt lit "3.5" de la chaîne "3.5?", puis arrête la lecture à "?" et évalue ainsi à 3.5 . Cependant,

alert("3.5?" > 3); 

retours false parce que la distribution string-number n'est pas aussi bienveillant que parseInt. Comme "3.5" n'est en effet pas un nombre, il est casté en NaN.

Answer 2

La chaîne sera convertie en nombre en utilisant des règles arbitraires. Généralement, vous verrez des règles comme celles-ci:

• Si la chaîne commence par 0x, traitez-la comme un nombre hexadécimal.
• Si la chaîne commence par 0, traitez-la comme un nombre octal. (pas dans tous les navigateurs)
• Sinon, traitez-le comme décimal.

Cela signifie en particulier que l'entrée comme « 09 » pourrait être source de confusion dans le navigateur et il peut être interprété comme 9 ou 0 (parce que neuf n'est pas un chiffre octal valide).

En général, lorsque vous comparez une chaîne à un nombre, vous devez toujours appeler manuellement parseInt avec un argument radix de 10. De cette façon, il n'y a pas de surprises.

Answer 3

Eh bien, comme une mise en œuvre EMCAScript, Javascript va suivre la Résumé Relational Comparaison algorithme tel que défini dans la section 11.8.5 de l'ECMA-262.

Tout d'abord Javascript appliquera à la fois opérandes l'opérateur interne ToPrimitive, qui doit retourner une valeur primitive ( non définie, booléen, chaîne, null ou nombre) sur la base des arguments passés à il. Si une valeur primitive est transmise à ToPrimitive, la valeur de retour est la valeur d'argument transmise à l'opérateur, s'il s'agit d'un objet une méthode interne appelée tous les objets dans Javascript est appelée [[DefaultValue]]. Cette méthode est responsable du renvoi d'un type primitif représenté par un objet. En fonction du type de code, cette méthode peut appeler les méthodes toString ou valueOf de l'objet.

Par exemple:

var x = {valueOf: function() { return 3; }}; 

console.log(x > 2); // true 
console.log(x < 1); // false 
console.log(x == 3); // true 

Comment le Javascript décider quelle méthode il devrait appeler? Eh bien, l'opérateur ToPrimitive peut recevoir un paramètre facultatif, il est utilisé pour donner la préférence à un type spécifique, par ex. Number ou String. Si Number est passé, la méthode valueOf sera appelée en premier, si cette méthode n'existe pas dans l'objet ou ne renvoie pas un type primitif, toString est appelée alors. Si String est passé, l'inverse se produit: toString est appelé en premier, s'il n'existe pas dans l'objet ni renvoie une valeur primitive, valueOf est appelée.
C'est pourquoi, dans l'extrait ci-dessus, je peux comparer librement un objet et un type primitif. Il est vraiment important de comprendre quand il s'agit de comparaison. Ensuite, si les deux opérandes sont Strings, Javascript suivra un algorithme intéressant et spécifique lié à Unicode Standard, vérifiant les valeurs des points de code. Sinon, Javascript jettera les deux opérandes à Number et leur valeur mathématique sera comparée. Notez que si l'un d'entre eux est NaN la comparaison évalue à undefined, ce qui serait false dans une instruction if.

Quelques exemples:

// true => ToNumber(true) > ToNumber(false) 
console.log(true > false); 
// true => ToNumber("5") < ToNumber(10) 
console.log("5" < 10); 
// false ToNumber(ToPrimitive(obj, Number)) == ToNumber(10) 
console.log(({valueOf: function() { return 10}}) > 10); 
// false, it's not related to the length of the strings, 
// the code point value of each char is used to evaluate the comparison 
console.log('Hello worlds' > 'hello'); 

espère que cela aide à clarifier quelque chose.