Conversion implicite de type de données en javascript. Conversion des types de données en JavaScript. Méthodes JavaScript pour convertir des chaînes en nombres

En JavaScript, les valeurs peuvent être converties assez librement (explicitement et implicitement) d'un type à un autre. Par exemple, si un opérateur s'attend à recevoir une valeur d'un certain type et qu'il reçoit une valeur d'un autre type, l'interpréteur essaiera automatiquement d'effectuer des conversions vers le type souhaité :

Console.log(10 + "machines"); // "10 voitures". Le nombre est implicitement converti en chaîne console.log("7" * "4"); // 28. Les deux chaînes sont implicitement converties en nombres

Conversion implicite- c'est à ce moment-là que l'interpréteur effectue automatiquement une conversion de type, c'est-à-dire sans la participation du programmeur. Conversion explicite- c'est à ce moment-là que la conversion est effectuée par le programmeur lui-même. La conversion explicite est également appelée moulage de caractères:

Console.log("7" * "4"); // 28. Conversion implicite console.log(Number("7") * Number("4")); // 28. Conversion explicite

Le tableau ci-dessous décrit comment JavaScript convertit les valeurs d'un type à un autre. Les cellules vides correspondent aux situations où aucune conversion n'est requise :

Signification	Convertir en:
	Chaîne	Nombre	Booléen	Un objet
indéfini nul	"indéfini" "nul"	NaN 0	FAUX FAUX	type d'erreurErreur type d'erreurErreur
vrai FAUX	"vrai" "FAUX"	1 0		nouveau booléen (vrai) nouveau booléen (faux)
"" (ligne vide) "1.2" "un" "-10" "+10" "011" "0xff"		0 1.2 NaN -10 10 11 255	FAUX vrai vrai vrai vrai vrai vrai	nouvelle chaîne ("") nouvelle chaîne ("1.2") nouvelle chaîne ("un") nouvelle chaîne("-10") nouvelle chaîne ("+10") nouvelle chaîne ("011") nouvelle chaîne ("0xff")
0 -0 NaN Infini -Infini 3	"0" "0" "NaN" "Infini" "-Infini" "3"		FAUX FAUX FAUX vrai vrai vrai	nouveau numéro (0) nouveau numéro (-0) nouveau numéro (NaN) nouveau numéro (infini) nouveau nombre (-Infini) nouveau numéro(3)
() (n'importe quel objet) (tableau vide) (1 élément numérique) arr (tout autre tableau) function()() (n'importe quelle fonction)	voir Conversion d'objets "" "9" voir Conversion d'objets voir Conversion d'objets	voir Conversion d'objets 0 9 NaN NaN	vrai vrai vrai vrai vrai

Pour une conversion explicite en types simples, les fonctions suivantes sont utilisées : Boolean(), Number(), String(). Pour la conversion implicite, l'interpréteur utilise les mêmes fonctions que celles utilisées pour la conversion explicite.

Pour une conversion explicite, vous pouvez utiliser des opérateurs au lieu de fonctions. Par exemple, si l’un des opérandes de l’opérateur + est une chaîne, alors l’autre opérande est également converti en chaîne. L'opérateur unaire + convertit son opérande en nombre. Opérateur unaire ! convertit l'opérande en valeur booléenne et l'inverse. Tout cela est devenu la raison de l'émergence des méthodes uniques de conversion de type suivantes que l'on peut trouver dans la pratique :

X + "" // Identique à String(x) +x // Identique à Number(x). Vous pouvez également voir x - 0 !!x // Identique à Boolean(x)

Convertir en nombres

La fonction Number() convertit les valeurs selon les règles suivantes :

• Les valeurs booléennes true et false sont converties respectivement en 1 et 0.
• Les nombres sont renvoyés inchangés.
• La valeur null est convertie en 0 .
• La valeur non définie est convertie en NaN.

Il existe des règles spéciales pour les chaînes :

• Si une chaîne ne contient que des chiffres précédés d'un signe + ou -, ou sans signe, elle est toujours convertie en un nombre décimal entier. Les zéros non significatifs sont ignorés, par exemple "0011" est converti en 11.
• Si la chaîne est un nombre à virgule flottante avec un signe + ou - ou non signé, elle est convertie en nombre à virgule flottante correspondant (les zéros non significatifs sont également ignorés).
• Si la chaîne est un nombre hexadécimal, elle est convertie en entier décimal correspondant.
• Si la chaîne est vide, elle est convertie en 0.
• Si la chaîne contient quelque chose de différent des options précédentes, elle est convertie en NaN.
• La méthode valueOf() est appelée sur les objets et la valeur qu'elle renvoie est automatiquement convertie selon les règles précédentes. Si cette conversion aboutit à NaN , la méthode toString() est appelée et les règles de conversion des chaînes en nombres sont appliquées.

Les opérateurs unaires + et - suivent les mêmes règles que la fonction Number().

Conversion en valeurs booléennes

La fonction Boolean() convertit une valeur en son équivalent booléen :

• Les valeurs suivantes sont converties en false : undefined , null , 0 , -0 , NaN , "" .
• False est renvoyé inchangé.
• Toutes les autres valeurs sont converties en true .

Convertir en chaînes

La fonction String() convertit les valeurs selon les règles suivantes :

• Pour toutes les valeurs autres que null et indéfinies, la méthode toString() est automatiquement appelée et une représentation sous forme de chaîne de la valeur est renvoyée.
• Pour null, la chaîne « null » est renvoyée.
• Pour la valeur non définie, la chaîne « non définie » est renvoyée.

Conversion de types simples en objets

Pour convertir des valeurs simples en objets, les constructeurs Boolean() , Number() , String() sont utilisés :

Var oNum = nouveau numéro (3); var oStr = new String("1.2"); var oBool = new Boolean(true); alert(type de oNum); // alerte "objet" (type de oStr); // alerte "objet" (type de oBool); // "objet"

Conversion d'objets en valeurs simples

Tous les objets héritent de deux méthodes de conversion : toString() et valueOf() .

La méthode toString() renvoie la représentation sous forme de chaîne de l'objet. Par défaut, cela ne renvoie rien d'intéressant :

Alerte((x : 1).toString()); // ""

Certains types ont des versions plus spécialisées de la méthode toString(). Par exemple, la méthode toString() sur un tableau convertit tous ses éléments en chaînes, puis les concatène en une seule chaîne, en insérant des virgules entre eux :

Alerte(.toString()); // "1,2,3"

Le but de la méthode valueOf() est moins clairement défini : elle est censée convertir un objet en la valeur simple qui le représente, si une telle valeur existe. Les objets sont par nature des valeurs composites, et la plupart des objets ne peuvent pas être représentés comme une seule valeur simple, donc par défaut la méthode valueOf() renvoie une référence plutôt qu'une simple valeur :

Alerte(typeof (x:2).valueOf()); // "objet"

Lors de la conversion d'un objet en chaîne, l'interpréteur JavaScript effectue les opérations suivantes :

• Si l'objet possède une méthode toString(), l'interpréteur l'appelle. S'il renvoie une valeur simple, l'interpréteur convertit la valeur en chaîne (si ce n'est pas une chaîne) et renvoie le résultat de la conversion.
• Si l'objet n'a pas de méthode toString() ou si la méthode ne renvoie pas une valeur simple, alors l'interpréteur vérifie la présence d'une méthode valueOf(). Si cette méthode est définie, l'interpréteur l'appelle. S'il renvoie une valeur simple, l'interpréteur convertit cette valeur en chaîne (si ce n'est pas une chaîne) et renvoie le résultat de la conversion.

Lors de la conversion d'un objet en nombre, l'interpréteur fait la même chose, mais essaie d'abord la méthode valueOf() :

• Si un objet possède une méthode valueOf() qui renvoie une valeur simple, l'interpréteur convertit (si nécessaire) cette valeur en nombre et renvoie le résultat.
• Si l'objet n'a pas de méthode valueOf() ou si la méthode ne renvoie pas une valeur simple, alors l'interpréteur vérifie la présence d'une méthode toString(). Si l'objet possède une méthode toString() qui renvoie une valeur simple, l'interpréteur effectue la conversion et renvoie la valeur résultante.
• Sinon, l'interpréteur conclut que ni toString() ni valueOf() ne peuvent obtenir une valeur simple et génère une TypeError.

Les méthodes toString() et valueOf() sont en lecture/écriture, vous pouvez donc les remplacer et spécifier explicitement ce qui sera renvoyé lors de la conversion :

Var obj = (); obj.toString = function() ( return "object"; ); alert("Voici " + obj); // "Ceci est un objet"

Le type de variable utilisé dans l'expression ne fait aucune différence. Si l'expression est mathématique, toutes ses variables seront automatiquement interprétées comme numériques. Si des chaînes sont traitées, alors tous les « participants » de l'expression sont traités comme des chaînes. Cependant, le défi de la conversion de chaîne en nombre en JavaScript existe dans un contexte beaucoup plus large.

Méthodes JavaScript pour convertir des chaînes en nombres

L'arsenal de méthodes pour convertir des chaînes en nombres n'est pas vaste, mais il est suffisant dans tous les cas simples. Ici, JavaScript (en particulier pour les débutants) est le chemin du simple au complexe à l'aide d'exemples pratiques.

Vous pourriez être intéressé par :

L'exemple décrit quatre chaînes différentes. Dans le premier bloc de sortie, la fonction typeof définit le type de chaque variable sous forme de chaîne. Chaque chaîne est ensuite très simplement convertie en nombre. Dans le deuxième bloc de sortie, les changements dans les variables après la conversion sont visibles ; leur type est devenu un nombre. L'exemple de conversion JavaScript parseFloat est particulièrement illustratif : il était "12e+3" et est devenu "12000".

Les changements lors de la conversion d’une chaîne en nombre peuvent être importants ! Mais seuls les premiers caractères comptent : ils doivent être numériques. S'il n'y a aucun caractère numérique, le résultat sera NaN.

La conversion inverse d'une chaîne qui « devient » un nombre n'est pas toujours la même chaîne. Ce point peut être utilisé pour vérifier l'exactitude de la saisie des informations numériques.

Le parseInt() La fonction analyse un argument de chaîne et renvoie un entier de la base spécifiée (la base dans les systèmes numériques mathématiques).

La source de cet exemple interactif est stockée dans un référentiel GitHub. Si vous souhaitez contribuer au projet d'exemples interactifs, veuillez cloner https://github.com/mdn/interactive-examples et envoyez-nous une pull request.

Syntaxe

parseInt (chaîne, base)

Paramètres

string La valeur à analyser. Si cet argument n'est pas une chaîne, il est alors converti en une seule à l'aide de l'opération abstraite ToString. Les espaces de début de cet argument sont ignorés. radix Facultatif Un entier compris entre 2 et 36 qui représente la base (la base dans les systèmes numériques mathématiques) de la chaîne. Soyez prudent - c'est le cas pas par défaut à 10 ! Le explique plus en détail ce qui se passe lorsque la base n'est pas fournie.

Valeur de retour

Un entier analysé à partir de la chaîne donnée.

Si la base est inférieure à 11 et que le premier caractère autre qu'un espace ne peut pas être converti en nombre, NaN est renvoyé.

Description

La fonction parseInt convertit son premier argument en chaîne, analyse cette chaîne, puis renvoie un entier ou NaN .

Si ce n'est pas NaN , la valeur de retour sera l'entier qui est le premier argument pris comme nombre dans la base spécifiée. (Par exemple, une base de 10 est convertie à partir d'un nombre décimal, 8 est convertie à partir d'un nombre octal, 16 à partir d'un nombre hexadécimal, et ainsi de suite.)

Pour les radicaux supérieurs à 10, les lettres de l'alphabet anglais indiquent des chiffres supérieurs à 9. Par exemple, pour les nombres hexadécimaux (base 16), A à F sont utilisés.

Si parseInt rencontre un caractère qui n'est pas un chiffre dans la base spécifiée, il l'ignore ainsi que tous les caractères suivants et renvoie la valeur entière analysée jusqu'à ce point. parseInt tronque les nombres en valeurs entières. Les espaces de début et de fin sont autorisés.

Parce que certains nombres utilisent le caractère e dans leur représentation sous forme de chaîne (par ex. 6.022e23 pour 6,022 × 10 23), l'utilisation de parseInt pour tronquer des nombres produira des résultats inattendus lorsqu'elle sera utilisée sur des nombres très grands ou très petits. parseInt devrait pasêtre utilisé comme substitut à Math.floor() .

parseInt comprend exactement deux signes : + pour positif et - pour négatif (depuis ECMAScript 1). Cela constitue une première étape de l'analyse après la suppression des espaces. Si aucun signe n’est trouvé, l’algorithme passe à l’étape suivante ; sinon, il supprime le signe et exécute l'analyse numérique sur le reste de la chaîne.

Si radix est undefined , 0 ou unspecified, JavaScript suppose ce qui suit :

1. Si la chaîne d'entrée commence par "0x" ou "0X" (un zéro, suivi d'un X minuscule ou majuscule), la base est supposée être 16 et le reste de la chaîne est analysé comme un nombre hexadécimal.
2. Si la chaîne d'entrée commence par "0" (un zéro), la base est supposée être 8 (octal) ou 10 (décimal). La base exacte choisie dépend de la mise en œuvre. ECMAScript 5 précise que 10 (décimal) devraitêtre utilisé, mais tous les navigateurs ne le prennent pas encore en charge. Pour cette raison, spécifiez toujours une base lors de l'utilisation de parseInt.
3. Si la chaîne d'entrée commence par une autre valeur, la base est 10 (décimale).

Si le premier caractère ne peut pas être converti en nombre, parseInt renvoie NaN sauf si la base est supérieure à 10 .

À des fins arithmétiques, la valeur NaN n’est un nombre quelle que soit la base. Vous pouvez appeler la fonction isNaN pour déterminer si le résultat de parseInt est NaN . Si NaN est transmis aux opérations arithmétiques, le résultat de l'opération sera également NaN .

Pour convertir un nombre en sa chaîne littérale dans une base particulière, utilisez thatNumber .toString(radix) .

Exemples

Utilisation de parseInt

Les exemples suivants renvoient tous 15 :

ParseInt("0xF", 16) parseInt("F", 16) parseInt("17", 8) parseInt(021, 8) parseInt("015", 10) // mais `parseInt(015, 10)` le fera return 13 parseInt(15.99, 10) parseInt("15,123", 10) parseInt("FXX123", 16) parseInt("1111", 2) parseInt("15 * 3", 10) parseInt("15e2", 10) parseInt("15px", 10) parseInt("12", 13)

Les exemples suivants renvoient tous NaN :

ParseInt("Hello", 8) // Pas du tout un nombre parseInt("546", 2) // Les chiffres autres que 0 ou 1 ne sont pas valides pour la base binaire

Les exemples suivants renvoient tous -15 :

ParseInt("-F", 16) parseInt("-0F", 16) parseInt("-0XF", 16) parseInt(-15.1, 10) parseInt("-17", 8) parseInt("-15", 10) parseInt("-1111", 2) parseInt("-15e1", 10) parseInt("-12", 13)

Les exemples suivants renvoient tous 4 :

ParseInt(4.7, 10) parseInt(4.7 * 1e22, 10) // Un très grand nombre devient 4 parseInt(0.00000000000434, 10) // Un très petit nombre devient 4

L'exemple suivant renvoie 224 :

ParseInt("0e0", 16) parseInt("123_456") // 123

Interprétations octales sans base

Bien que déconseillées par ECMAScript 3 et interdites par ECMAScript 5, de nombreuses implémentations interprètent une chaîne numérique commençant par un 0 comme octal. Ce qui suit peut avoir un résultat octal ou un résultat décimal. Spécifiez toujours une base pour éviter ce comportement peu fiable.

ParseInt("0e0") // 0 parseInt("08") // 0, car "8" n'est pas un chiffre octal.

ECMAScript 5 supprime l'interprétation octale

La spécification ECMAScript 5 de la fonction parseInt ne permet plus aux implémentations de traiter les chaînes commençant par un caractère 0 comme des valeurs octales. ECMAScript 5 déclare :

La fonction parseInt produit une valeur entière dictée par l'interprétation du contenu de l'argument de chaîne en fonction de la base spécifiée. L'espace blanc au début de la chaîne est ignoré. Si la base est indéfinie ou 0 , elle est supposée être 10 sauf lorsque le nombre commence par les paires de caractères 0x ou 0X , auquel cas une base de 16 est supposée.

Cela diffère d'ECMAScript 3, qui a été déconseillé mais autorisait l'interprétation octale.

De nombreuses implémentations n'ont pas adopté ce comportement depuis 2013, et comme les navigateurs plus anciens doivent être pris en charge, spécifiez toujours une base.

Une fonction d'analyse plus stricte

Il est parfois utile d’avoir une manière plus stricte d’analyser les entiers.

Les expressions régulières peuvent aider :

Fonction filterInt(value) ( ​​​​if (/^[-+]?(\d+|Infinity)$/.test(value)) ( return Number(value) ) else ( return NaN ) ) console.log(filterInt( "421 ")) // 421 console.log(filterInt("-421")) // -421 console.log(filterInt("+421")) // 421 console.log(filterInt("Infinity")) // Infinity console.log(filterInt("421e+0")) // NaN console.log(filterInt("421hop")) // NaN console.log(filterInt("hop1.61803398875")) // Console NaN .log (filterInt("1.61803398875")) // NaN

Caractéristiques

spécification	Statut	Commentaire
ECMAScript 1ère édition (ECMA-262)	Standard	Définition initiale.
ECMAScript 5.1 (ECMA-262)	Standard
ECMAScript 2015 (6e édition, ECMA-262) La définition de « parseInt » dans cette spécification.	Standard
Dernière version d'ECMAScript (ECMA-262) La définition de « parseInt » dans cette spécification.	Brouillon

Compatibilité du navigateur

Le tableau de compatibilité sur cette page est généré à partir de données structurées. Si vous souhaitez contribuer aux données, veuillez consulter https://github.com/mdn/browser-compat-data et envoyez-nous une pull request.

Mettre à jour les données de compatibilité sur GitHub

	Bureau						Mobile						Serveur
	Chrome	Bord	Firefox	Internet Explorer	Opéra	Safari	Vue Web Android	Chrome pour Android	Firefox pour Android	Opéra pour Android	Safari sur iOS	Internet Samsung	Noeud.js
analyserInt	Chrome Prise en charge complète 1	Prise en charge complète de Edge 12	Firefox Prise en charge complète 1	IE Prise en charge complète 3	Opera Prise en charge complète Oui	Safari Prise en charge complète Oui	WebView Android Prise en charge complète 1	Chrome Android Prise en charge complète 18	Firefox Android Prise en charge complète 4		Safari iOS Prise en charge complète Oui	Samsung Internet Android Prise en charge complète 1.0	nodejs Prise en charge complète Oui
Les chaînes de zéro non significatif sont analysées en décimal et non en octal.	Chrome Prise en charge complète 23	Prise en charge complète de Edge 12	Firefox Prise en charge complète 21	IE Prise en charge complète 9	Opera Prise en charge complète Oui	Safari Prise en charge complète 6	WebView Android Prise en charge complète 4.4	Chrome Android Prise en charge complète 25	Firefox Android Prise en charge complète 21	Opera Android Prise en charge complète Oui	Safari iOS Prise en charge complète 6	Samsung Internet Android Prise en charge complète Oui	nodejs Prise en charge complète Oui

Bonjour chers lecteurs. Aujourd'hui, j'écrirai comment il est converti en javascript chaîne en nombre. Cela se fait à l'aide de la fonction Number, je vais maintenant montrer son utilisation avec un exemple.
Je suggère également de regarder la version vidéo de cet article :

Un peu sur les types de données

Comme vous le savez, javascript a des types de données numériques et chaînes. Essayons de créer deux variables dans lesquelles nous stockerons les nombres, puis afficherons le résultat à l'écran.

Var a = 5 ; variable b = 12 ; document.write(a + b);

Quel sera le résultat ? 17, c'est ce que le navigateur nous a montré. Il s’agit donc de données numériques, le navigateur les a donc additionnées avec succès. Créons maintenant deux autres variables, dans lesquelles nous mettrons les mêmes valeurs, mais entre guillemets. Permettez-moi de vous rappeler que toutes les lignes en javascript sont écrites entre guillemets.

Var c = "5" ; vard = "12" ; document.write("
" + c + d);

Maintenant, le navigateur considère nos données comme des chaînes et si nous les ajoutons, alors deux lignes seront simplement ajoutées et nous obtiendrons 512, ce qui n'est pas le résultat correct si des nombres ont été ajoutés, mais est correct si nous mettons deux lignes ensemble.

Comment convertir une chaîne en nombre en javascript ?

Tout est simple ici, créons les deux variables suivantes, dans lesquelles nous écrirons la même valeur spécifiée par les variables c et d , mais en les passant via la méthode Number :

Var e = Nombre(c); var f = Nombre(d); document.write(e + f);

Si vous essayez maintenant d'afficher le résultat de cet ajout à l'écran, il affichera 17. En effet, notre méthode a fonctionné avec succès et a converti la chaîne en nombre. Je tiens à souligner que si vous l'écrivez comme ceci :

Document.write("
" + e + f);

Ensuite, 512 sera affiché à l'écran, car lors de l'ajout de chaînes et de nombres TOUJOURS le résultat est converti en chaîne. Si vous souhaitez ajouter un saut de ligne tout en conservant le résultat correct, vous pouvez tout écrire sur deux lignes ou sur une comme ceci :

Document.write("
" + (e + f));

Si vous mettez des nombres entre parenthèses, ils ne seront pas convertis en chaînes et conserveront leurs propriétés. Ceci est mon court article aujourd’hui. J'espère que javascript est devenu un peu plus clair pour vous.

JavaScript dispose de 2 fonctions intégrées pour convertir des chaînes en nombres : parseFloat() et parseInt() .

parseFloat() prend comme argument une chaîne à convertir en type numérique et renvoie un nombre flottant. Le numéro doit apparaître en début de ligne. S'il y a d'autres caractères dans la ligne après le numéro, ils sont coupés. La partie fractionnaire d'un nombre doit être écrite séparée par un point (une virgule n'est pas perçue comme un séparateur). Si parseFloat() ne peut pas convertir la chaîne, il renvoie NaN.

La fonction peut également traiter « le nombre n multiplié par 10 à la puissance x », qui en programmation s'écrit généralement avec la lettre E, par exemple : 0,5E6 ou 0,5E+6. Le degré peut également être négatif : 0,5E-6, ce qui est égal à 0,5*10^-6 ou 0,5/1000000.

ParseFloat(""3.78kg"") // 3.78 parseFloat(""kg33"") // NaN parseFloat(""0004.111"") // 4.111 parseFloat(""0x66"") // 0 parseFloat("". 5"") // 0,5 parseFloat(""-.5"") // -0,5 parseFloat(""0.5e6"") // 500000 parseFloat(""0.03E+2"") // 3 parseFloat(" "3E-4"") // 0,0003 parseFloat(""-3E-4"") // -0,0003

La fonction parseInt(string[, radix]) prend une chaîne comme premier argument, l'analyse et renvoie un entier (type entier). La fonction tente d'analyser le système numérique dans lequel le nombre dans la chaîne source est écrit (par exemple, décimal, octal ou hexadécimal - mais pas seulement). Vous pouvez également spécifier explicitement le système numérique en le passant comme deuxième base de paramètre. Le paramètre radix peut prendre n'importe quel nombre de 2 à 36 (dans les systèmes supérieurs à 10, les lettres de l'alphabet anglais sont utilisées, de A à Z).

La fonction ne traite pas les nombres comme 1.5e6 comme parseFloat() .

Merci de lire les exemples ci-dessous pour ne pas tomber sur les pièges cachés dans le fonctionnement de la fonction parseInt().

ParseInt(""25"") // 25 parseInt(""-25"") // -25 parseInt(""45.12"") // 45 parseInt(""045"",10) // 45 parseInt( ""70"",8) // 56 (70 en octal est 56 en décimal) parseInt(""070"") // 56 (IMPORTANT !!! zéro en premier obligera la fonction à analyser la chaîne comme un nombre octal ) parseInt(" "88"",8) // NaN (il n'y a pas de chiffre 8 dans le système octal) parseInt(""a1"") // NaN (IMPORTANT !!! La fonction par défaut ne traite pas le nombre comme hexadécimal s'il n'est pas ajouté aux premières lignes 0x) parseInt(""a1"",16) // 161 (le système numérique est explicitement spécifié ici) parseInt(""0xa1"") // 161 (format de nombre hexadécimal correct , vous n'avez pas besoin de spécifier le deuxième paramètre) parseInt( ""099"") // 0 (IMPORTANT !!! Le nombre est traité comme octal, mais contient des caractères invalides) parseInt(""0.5e6"") / / 0 (IMPORTANT !!! ne fonctionne pas comme parseFloat) parseInt("" ZZ"",36) // 1295 parseInt(""-FF"") // NaN parseInt(""-FF"",16) / /-255

Si vous analysez les entrées utilisateur à partir d'un champ de texte, utilisez toujours parseInt() avec un deuxième paramètre radix pour protéger votre code des résultats inattendus.