Syntaxe JavaScript parseInt : exemples d'utilisation. Utilisation de la méthode parseInt

La fonction parseInt() 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 chaîne La valeur à analyser. Si l'argument chaîne n'est pas une chaîne, il est alors converti en chaîne (à l'aide de l'opération abstraite ToString). Les espaces au début de l'argument de chaîne sont ignorés. base 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 mentionnée ci-dessus. Le descriptif

ci-dessous explique plus en détail ce qui se passe lorsque cet argument n'est pas fourni. Valeur de retour

Un nombre entier analysé à partir de la chaîne donnée. Si le premier caractère ne peut pas être converti en nombre, NaN est renvoyé.

Description

La fonction parseInt convertit son premier argument en chaîne, l'analyse et renvoie un entier ou NaN . Si ce n'est pas NaN , la valeur renvoyée sera l'entier qui est le premier argument pris comme nombre dans la base (base) spécifiée. Par exemple, une base de 10 indique qu'il faut convertir un nombre décimal, 8 octal, 16 hexadécimal, etc. Pour les radicaux supérieurs à 10, les lettres de l'alphabet 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.

Étant donné que certains nombres incluent le caractère e dans leur représentation sous forme de chaîne (par exemple 6.022e23 ), l'utilisation de parseInt pour tronquer les valeurs numériques produira des résultats inattendus lorsqu'elle sera utilisée sur des nombres très grands ou très petits. parseInt ne doit pas être utilisé comme substitut à Math.floor() .

• Si la base est indéfinie ou 0 (ou absente), JavaScript suppose ce qui suit :
• Si la chaîne d'entrée commence par "0", la base est huit (octal) ou 10 (décimal). La base exacte choisie dépend de la mise en œuvre. ECMAScript 5 spécifie que 10 (décimal) est utilisé, mais tous les navigateurs ne le prennent pas encore en charge. Pour cette raison, spécifiez toujours une base lorsque vous utilisez parseInt .
• 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 .

À des fins arithmétiques, la valeur NaN n’est un nombre dans aucune 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, les résultats de l'opération seront également NaN .

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

Exemples utilisant parseInt

15 :

ParseInt("0xF", 16); parseInt("F", 16); parseInt("17", 8); parseInt(021, 8); parseInt("015", 10); // parseInt(015, 10); renverra 15 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);

Ce qui suit les exemples renvoient tous NaN :

ParseInt("Bonjour", 8); // Pas du tout un nombre parseInt("546", 2); // Chiffres ne sont pas valable pour les représentations binaires

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

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-être avoir un résultat octal, ou il peut avoir un résultat décimal. Spécifiez toujours une base pour éviter ce comportement peu fiable.

ParseInt("0e0"); // 0 parseInt("08"); // 0, "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 valeurs int. Les expressions régulières peuvent aider :

Var filterInt = function(value) ( ​​​​if (/^(-|\+)?(\d+|Infinity)$/.test(value)) return Number(value); 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")); // NaN console.log(filterInt("1.61803398875")); // NaN

Caractéristiques Commentaires sur l'état de la spécification

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

Serveur mobile de bureau Chrome Edge Firefox Internet Explorer Opera Safari Android webview Chrome pour Android Edge Mobile Firefox pour Android Opera pour Android Safari sur iOS Samsung Internet Node.jsanalyserInt Les chaînes de zéro non significatif sont analysées en décimal et non en octal.

Chrome Prise en charge complète Oui

Edge Prise en charge complète Oui

Firefox Prise en charge complète 1

IE Prise en charge complète Oui

Opera Prise en charge complète Oui

Safari Prise en charge complète Oui

WebView Android Prise en charge complète Oui

Firefox Android Prise en charge complète 4

Safari iOS Prise en charge complète Oui

nodejs Prise en charge complète Oui

Chrome Prise en charge complète 23

Edge Prise en charge complète Oui

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 Oui

Edge Mobile Prise en charge complète Oui

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

Reconnaître un nombre dans une chaîne et être sûr que l'algorithme utilise la valeur d'une variable dont le type est un nombre est nécessaire dans presque tous les algorithmes. Méthode JavaScript parseInt résout ce problème et vous permet de reconnaître des valeurs numériques dans systèmes populaires Compte.

Syntaxe Méthode parseInt

La méthode prend deux paramètres dont le second est facultatif. Le résultat du travail est toujours un nombre. Si le premier paramètre (chaîne) ne contient pas de caractères du système numérique au début, alors le résultat sera NaN.

Les chiffres hexadécimaux comprennent les lettres « a », « b », « c », « d », « e » et « f ». Signe nombre octal est le premier « 0 » et la paire hexadécimale principale est « 0x ». Mais la transformation ne sera pas toujours effectuée correctement, même si elle est indiquée correctement syntaxiquement.

La fonction d'analyse des nombres est une opération populaire. Dans le très cas simple La méthode et l'invite parseInt de JavaScript vous permettent de filtrer la saisie des valeurs numériques correctes pour prendre des décisions rapides.

Note. La fonction promt() saisit ce que le visiteur a tapé dans le champ de saisie, et non le « résultat » des boutons Ok ou Annuler. C'est pourquoi, pour obtenir des valeurs rapides, vous pouvez suivre le contenu des entrées du visiteur à la volée et accepter la bonne décision.

Utilisation de la méthode parseInt

La programmation Internet a ses propres spécificités et a une forte influence sur les idées de programmation en général. La fusion de petites données en un seul « mot » volumineux est un paramètre dont les principales qualités sont :

• compacité;
• reconnaissance rapide.

Dans de nombreux cas, les plus grands « fans » de ce facteur CSS et HTML ont commencé à écrire un nombre, puis immédiatement, sans espace, sans unité de mesure ni signe de ponctuation. Autrement dit, composez des séquences symboliques strictes.

Les expressions régulières en général, pour ceux qui ne sont pas initiés aux mystères de l'analyse syntaxique, sont du code Morse, dans lequel un fouillis de points et de tirets est « divisé » en presque tous les caractères de l'ensemble traditionnel de huit bits. De plus, tout ce qui n'est pas inclus dans partie visible table de symboles, vous pouvez facilement l'écrire avec des codes, c'est-à-dire des chiffres et des lettres - c'est la méthode JavaScript parseInt.

De nombreux paramètres de certains Fonctionnalités CSS n'autorisez pas les espaces et ne fonctionnent que lorsqu'ils sont écrits selon une norme exacte.

Le langage XML, malgré toute son ouverture, ne permet pas de libertés lors du codage des informations paramétriques.

Exemples de demande d'analyse informations numériques Il y en a beaucoup qui peuvent être cités en dehors de JavaScript, mais cela n'a pas d'importance. Signification Méthode JavaScript parseInt dépend du rôle joué par les informations numériques et de la manière dont elles sont représentées dans une grande variété d'applications.

Signification de l’analyse numérique

L’analyse des informations est une procédure symbolique, mais la programmation d’aujourd’hui est toujours le même traitement d’informations numériques qu’il y a trente ans. Dans le passé, il n'y avait pas de JavaScript & parseInt. Mais c'est de l'expérience du passé que sont nées les connaissances sur le traitement de l'information numérique, le potentiel de expressions régulières et d'autres idées similaires.

DANS certaine période temps, les langages de programmation ont pris des « libertés » mots-clés, a « débloqué » l’alphabet cyrillique et a permis au développeur de traiter des données faiblement formalisées. Mais cette période fut courte, et avec l’intérêt croissant pour la programmation orientée objet, un « trou noir » s’est formé entre-temps :

• comment faire ;
• ce qu'il faut faire.

Un langage de programmation moderne en général (bien que la signification du langage JavaScript soit difficile à évaluer en général) est obligé de séparer l'outil de travail du sujet du travail. L'outil doit être précis et rapide, et le sujet du travail peut être aussi vaste que souhaité et pratiquement informel. Mais le résultat du programme devient de plus en plus significatif à chaque instant.

Développer des objets sans JavaScript parseInt est une perte injustifiée d'efforts, de temps et de code. Les méthodes de l'objet doivent fonctionner comme sur des roulettes, rapidement et avec précision. Mais le sujet du fonctionnement d'un objet est l'information, le résultat du fonctionnement d'un objet est aussi l'information. Et ici il n'est pas du tout nécessaire d'entendre par objet Notion Javascript, PHP ou Python... sont des options et des styles privés pour coder des objets réels.

Dernière mise à jour : 11/1/2015

Il est souvent nécessaire de transformer une donnée en une autre. Par exemple:

Numéro de variable 1 = "46" ; var numéro2 = "4" ; var résultat = numéro1 + numéro2 ; console.log(résultat); //464

Les deux variables représentent des chaînes, ou plus précisément des représentations sous forme de chaînes de nombres. Et à la fin, nous n'obtiendrons pas le nombre 50, mais la chaîne 464. Mais ce serait bien s'ils pouvaient aussi être additionnés, soustraits et généralement travaillés comme avec des nombres ordinaires.

Dans ce cas, nous pouvons utiliser des opérations de conversion. Pour convertir une chaîne en nombre, utilisez la fonction parseInt() :

Numéro de variable 1 = "46" ; var numéro2 = "4" ; var résultat = parseInt(numéro1) + parseInt(numéro2); console.log(résultat); // 50

Pour convertir des chaînes en nombres fractionnaires la fonction parseFloat() est utilisée :

Var numéro1 = "46.07" ; var numéro2 = "4,98" ; var résultat = parseFloat(numéro1) + parseFloat(numéro2); console.log(résultat); //51.05

Dans ce cas, la ligne peut avoir un contenu mixte, par exemple « 123hello », c'est-à-dire que dans ce cas il y a des chiffres, mais aussi des caractères normaux. Mais la méthode parseInt() tentera quand même d'effectuer la conversion :

Var num1 = "123bonjour"; var num2 = parseInt(num1); console.log(num2); // 123

Si la méthode ne parvient pas à convertir, elle renvoie NaN (Not a Number), ce qui indique que la chaîne ne représente pas un nombre et ne peut pas être convertie.

En utilisant fonction spéciale isNaN() peut vérifier si une chaîne représente un nombre. Si la chaîne n'est pas un nombre, alors la fonction renvoie vrai, si c'est un nombre, alors faux :

Var num1 = "javascript" ; var num2 = "22" ; var résultat = isNaN(num1); console.log(résultat); // true - num1 n'est pas un nombre result = isNaN(num2); console.log(résultat); // faux - num2 est un nombre

Ci-dessus, nous avons examiné la conversion de chaînes en nombres dans le système décimal. Cependant, nous pouvons convertir les nombres dans n’importe quel système. Par défaut, l'interpréteur JavaScript devine lui-même dans quel système numérique nous voulons convertir la chaîne (généralement le système décimal est sélectionné). Mais nous pouvons utiliser le deuxième paramètre pour indiquer explicitement que nous voulons convertir la chaîne en nombre dans un système spécifique. Par exemple, la conversion en un nombre dans système binaire:

Var num1 = "110" ; var num2 = parseInt(num1, 2); console.log(num2); // 6

Le résultat est 6, puisque 110 en binaire équivaut à 6 en décimal.

Maintenant, écrivons petit programme, dans lequel nous utilisons des opérations avec des variables :

JavaScript var strSum = prompt("Entrez le montant du dépôt", 1000); var strPercent = invite("Entrée taux d'intérêt

", 10); var sum = parseInt(strSum); var pourcentage = parseInt(strPercent); sum = somme + somme * pourcentage / 100; alert("Une fois les intérêts calculés, le montant du dépôt sera : " + somme);

La fonction prompt() affiche une boîte de dialogue dans le navigateur vous demandant de saisir une valeur. Le deuxième argument de cette fonction spécifie la valeur qui sera utilisée par défaut.

Cependant, la fonction prompt() renvoie une chaîne. Par conséquent, nous devons convertir cette chaîne en nombre afin d’y effectuer des opérations.

Après avoir ouvert la page dans le navigateur, nous verrons une invite pour saisir le montant du dépôt :

La fonction parseInt() prend une chaîne comme argument et renvoie un entier selon la base spécifiée.

Syntaxe parseInt( chaîne, base); Paramètres chaîne La valeur à interpréter. Si la valeur du paramètre chaîne n'est pas un type chaîne, elle est convertie en un type (à l'aide de l'opération abstraite ToString). Les espaces en début de ligne ne sont pas comptés. base Un entier compris entre 2 et 36 qui représente la base du système numérique cordes décrit ci-dessus. La plupart des utilisateurs utilisent le système de nombres décimaux et spécifient 10. Spécifiez toujours ce paramètre pour éliminer les erreurs de lecture et garantir une exécution correcte et des résultats prévisibles. Lorsque la base du système de numérotation n'est pas précisée, différentes implémentations

peut renvoyer des résultats différents. Valeur de retour

Un entier obtenu en analysant (analyse et interprétation) la chaîne transmise. Si le premier caractère ne peut pas être converti en nombre, NaN est renvoyé.

Description La fonction parseInt convertit le premier argument qui lui est passé en type de chaîne , l'interprète et renvoie une valeur entière ou NaN. Le résultat (sinon NaN) est un entier et constitue le premier argument (chaîne), traité comme un nombre dans la base spécifiée. Par exemple, la base 10 indique la conversion du décimal, 8 de l'octal, 16 de l'hexadécimal, etc. Si la base est supérieure à 10, alors les lettres sont utilisées pour représenter les nombres supérieurs à 9. Par exemple, pour nombres hexadécimaux

(base 16) les lettres A à F sont utilisées. Si la fonction parseInt rencontre un caractère qui n'est pas un nombre dans le système numérique spécifié, elle ignore ce caractère ainsi que tous les caractères suivants (même s'ils sont valides) et renvoie un entier converti à partir de la partie de la chaîne précédant ce caractère. parseInt garnitures partie fractionnaire

Nombres. Les espaces en début et en fin de ligne sont autorisés. Étant donné que certains nombres incluent le caractère e dans leur représentation sous forme de chaîne (par exemple, 6.022e23 ), l'utilisation de parseInt pour tronquer les valeurs numériques peut entraîner des résultats inattendus

, lorsque de très petites ou très grandes quantités sont utilisées. parseInt ne doit pas être utilisé en remplacement de Math.floor() .

• Si la base est indéfinie ou 0 (ou non spécifiée), alors JavaScript suppose ce qui suit par défaut : Si la valeur La chaîne commence par "0x" ou "0X", la base est 16 et le reste de la chaîne est interprété.
• Si la valeur du paramètre d'entrée de chaîne commence par "0", la base est soit 8, soit 10, selon l'implémentation spécifique. La spécification ECMAScript 5 spécifie l'utilisation de 10 (décimal), mais cela n'est pas encore pris en charge par tous les navigateurs, vous devez donc toujours spécifier la base lorsque vous utilisez la fonction parseInt.
• Si la valeur du paramètre d'entrée de chaîne commence par un autre caractère, le système numérique est considéré comme décimal (base 10).

Si le premier caractère de la chaîne ne peut pas être converti en nombre, parseInt renvoie NaN .

D'un point de vue mathématique, la valeur NaN n'est un nombre dans aucun système numérique. Pour déterminer si parseInt renverra NaN comme résultat, vous pouvez appeler la fonction isNaN. Si NaN est impliqué dans opérations arithmétiques, le résultat sera également NaN .

Pour convertir un nombre en chaîne dans une base spécifiée, utilisez intValue.toString(radix) .

Exemples Exemple : Utilisation de parseInt

15 :

ParseInt("0xF", 16); parseInt("F", 16); parseInt("17", 8); parseInt(021, 8); parseInt("015", 10); //parseInt(015, 10); renverra 15 parseInt(15.99, 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("Bonjour", 8); // Pas un nombre parseInt("546", 2); // Numéro incorrect dans le système de numérotation 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);// Très

gros chiffres

ParseInt("0e0", 16);

devenir 4 parseInt (0.00000000000434 , 10 ) ;

// Les très petits nombres deviennent 4 L'exemple suivant renvoie 224 : Interprétation octale sans préciser le système numérique

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

ECMAScript 5 élimine l'interprétation octale

La spécification ECMAScript 5 ne permet plus à parseInt de traiter les chaînes commençant par 0 en octal. ECMAScript 5 proclame :

La fonction parseInt produit une valeur entière en interprétant le contenu de l'argument de chaîne selon la base spécifiée. L'espace en début de ligne est ignoré. Si la base est non spécifiée ou égale à 0, elle est supposée être 10, sauf lorsque la chaîne commence par des paires de caractères 0x ou 0X : alors la base est supposée être 16. Si la base est spécifiée comme 16, le numéro peut également commencer par des paires de caractères 0x ou 0X .

C'est là que ECMAScript 5 diverge de la spécification ECMAScript 3, qui décourageait mais n'interdisait pas l'interprétation octale.

Étant donné que le comportement décrit ci-dessus n'est pas disponible dans toutes les implémentations à partir de 2013 et que la prise en charge des navigateurs plus anciens est nécessaire, spécifiez toujours la base.

Fonction d'interprétation plus stricte

Parfois, une manière plus rigoureuse d'interpréter les valeurs entières est nécessaire. Les expressions régulières peuvent vous aider :

Var filterInt = function (value) ( ​​​​if (/^(\-|\+)?(+|Infinity)$/.test(value)) return Number(value); 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")); // NaN console.log(filterInt("1.61803398875")); // NaN

Spécification Commentaires sur l'état de la spécification

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 » se trouve dans cette spécification.	Standard
Dernière version d'ECMAScript (ECMA-262) La définition de « parseInt » se trouve dans cette spécification.	Brouillon

Prise en charge 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

Ordinateurs Serveur Mobile Chrome Edge Firefox Internet Explorer Opera Safari Android webview Chrome pour Android Edge Mobile Firefox pour Android Opera pour Android Safari sur iOS Samsung Internet Node.jsAssistance de base Les chaînes de zéro non significatif sont analysées en décimal et non en octal.

Chrome Prise en charge complète Oui

Edge Prise en charge complète Oui

Firefox Prise en charge complète 1

IE Prise en charge complète Oui

Opera Prise en charge complète Oui

Safari Prise en charge complète Oui

WebView Android Prise en charge complète Oui

Chrome Android Prise en charge complète Oui

Edge Mobile Prise en charge complète Oui

Prise en charge de Firefox Android Full 4

Opera Android Prise en charge complète Oui

Safari iOS Prise en charge complète Oui

Samsung Internet Android Prise en charge complète Oui

nodejs Prise en charge complète Oui

Chrome Prise en charge complète 23

Edge Prise en charge complète Oui

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

Prise en charge complète de WebView Android 4.4

Chrome Android Prise en charge complète Oui

Edge Mobile Prise en charge complète Oui

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

La fonction ParseInt est conçue pour convertir une chaîne en nombre en JavaScript. La méthode prend une valeur de chaîne comme argument et la convertit en nombre sans décimales, ou produit une valeur NaN. ParseInt prend deux arguments. Le deuxième paramètre spécifie le système numérique à utiliser lors de la conversion d'une valeur de chaîne en nombre.

Un exemple simple utilisant la notation décimale ressemble à ceci :

varx = "1" ; console.log(x, type de x); //1 ligne x = parseInt(x, 10); console.log(x, type de x); //1 numéro Exemple de code en ligne

Si aucun argument n'est transmis pour une valeur décimale de base, la valeur par défaut (décimale de base) sera utilisée. Vous pouvez également définir la valeur sur 2 pour indiquer à la fonction d'utiliser la notation binaire. Une valeur de 8 indique à ParseInt d'utiliser l'octal et une valeur de 16 indique à ParseInt d'utiliser l'hexadécimal. Pour les systèmes numériques dont la base est supérieure à 10, les lettres de l'alphabet sont utilisées à la place des nombres supérieurs à 9.

Avant de convertir une chaîne en nombre en JavaScript, regardons un exemple de conversion nombre binaireà un entier dans le système décimal :

variable x = 10 ; x = parseInt(x, 2); console.log(x); //2 Exemple de code en ligne

La variable x prend la valeur 10. En binaire, la valeur 10 (c'est-à-dire « un, zéro ») équivaut à 2 en décimal. Nous avons transmis ParseInt 10 à la fonction et spécifié binaire comme système numérique. La fonction a renvoyé la valeur 2, qui est un entier équivalent à « un, zéro ».

Que se passe-t-il si nous transmettons un nombre décimal avec une ou plusieurs décimales à la fonction ParseInt ? Voyons:

variable x = 3,14 ; x = parseInt(x, 10); console.log(x); //3 Exemple de code en ligne

La fonction ParseInt acceptée valeur numérique avec des décimales et l'a ramené à un nombre entier. Mais que se passe-t-il si vous devez convertir une chaîne en nombre en JavaScript ? Voici un exemple :

var x = "Hola le monde !"; x = parseInt(x, 10); console.log(x); //NaN ... ou Not a Number Online, exemple de code

Si ParseInt reçoit un argument qui ne peut pas être facilement converti en valeur numérique, alors la valeur de retour sera NaN (ou pas un nombre). Si une fonction reçoit une combinaison de valeurs de chaîne numériques et alphabétiques, elle convertira les caractères numériques en entiers et ignorera le reste :

var x = "123UnoDosTres";

Explorez les cours JavaScript

x = parseInt(x, 10); console.log(x); //123 Exemple de code en ligne

Ce sont les principes de base de l'utilisation de la fonction ParseInt. Il ne faut pas oublier que l'objectif principal de ParseInt est la traduction JavaScript d'une chaîne en nombre (sans décimales). Vous pouvez également spécifier le système numérique à utiliser. Si une fonction reçoit une valeur qui ne peut pas être convertie en nombre, ParseInt renvoie NaN.

Plus d’informations sur la fonction JavaScript ParseInt peuvent être trouvées ici.

La traduction de l'article « Utilisation de la méthode JavaScript ParseInt » a été préparée par l'équipe sympathique du projet.

Bon Mauvais