Cet article vous apporte des connaissances pertinentes sur JavaScript, qui présentent principalement le contenu pertinent sur les types de nombres. Il existe deux types de nombres en JavaScript : les types Number et BigInt. Examinons-les ensemble. J'espère que cela vous sera utile. aide.
[Recommandations associées : didacticiel vidéo javascript, front-end Web]
Il existe deux types de nombres en JavaScript :
Le type Number , qui est un type numérique au sens conventionnel du terme, est stocké au format IEEE-754 64 bits et est un « nombre à virgule flottante double précision ». Jusqu'à présent, tous les nombres avec lesquels nous sommes entrés en contact sont des nombres. du type Number ;
Le type BigInt représente des entiers de n'importe quelle longueur. Normalement, nous ne les utilisons que s'ils représentent des nombres autres que 2 53 à -2 53. Nous présenterons ces types de données professionnels en détail dans les chapitres suivants ;
La façon d'écrire des nombres est très simple, mais JavaScrpt dispose de nombreux sucres syntaxiques pratiques et rapides à utiliser. L'apprentissage de ces sucres syntaxiques améliorera non seulement notre capacité de lecture de code, mais améliorera également le sens de haut niveau de notre code.
Les nombres décimaux sont les plus simples, et nous les utiliserons plus ou moins dans presque tous les articles. Par exemple, nous créons une variable et stockons 100 milliards :
soit dixmilliards = 10000000000 ;
Bien que l'opération soit très simple, il y a un problème : il est difficile de compter combien de 0 suivent 1 Si nous écrivons un code de transfert, un mauvais 0 peut conduire à la faillite.
À ce stade, nous pouvons utiliser _ comme délimiteur, comme suit :
soit dix milliards = 10_000_000_000 ;
Le code ci-dessus peut clairement compter le nombre de 0 , ce qui est évidemment la solution optimale !
_ trait de soulignement ici est un sucre syntaxique de JavaScript , qui sera ignoré par le moteur lors de l'exécution. Les deux méthodes d'écriture ci-dessus ont le même effet, mais l'expérience de lecture est très différente.
Circuit cérébral Qingqi
Certaines chaussures pour enfants doivent demander, j'ai toujours été en groupe de 4 0 depuis que je suis enfant, pourquoi dois-je grouper 3 0 ? On peut donc l’écrire de la manière suivante sans aucun problème :
soit dix milliards = 100_0000_0000 ;
Ou cela pourrait s'écrire ainsi :
soit dix milliards = 1_0000_0000_00 ;
Ce que je veux exprimer ici, c'est que quelle que soit la méthode de division que vous utilisez, cela n'affectera pas la taille du nombre lui-même. Trouvez la méthode la plus puissante !
Bien que l'utilisation _ puisse diviser élégamment de nombreux 0 , dans la vraie vie, nous ne l'écrivons généralement pas de cette façon. Par exemple, nous écrivons souvent 10000000000 sous la forme "10 milliards", de sorte que de nombreux 0 puissent être omis, réduisant ainsi la possibilité de créer. erreurs.
JavaScript fournit également un moyen d'omettre 0 Nous pouvons utiliser la lettre e suivie d'un chiffre pour représenter le nombre 0 Par exemple :
soit dixmilliards = 1e10;//10 milliards, 1 suivi de 10 0sconsole.log(3.14e9);//3140000000, suivi de 7 0, veuillez regarder en bas si vous avez des questions.
La compréhension du code ci-dessus est très simple. e10 peut être compris comme 1_0000_0000_00 0 qui vaut 1 suivi de 10 , on peut donc penser :
1e10 === 1 * 1_0000_0000_00;//e10 signifie 1 suivi de 10 03.14e9 === 3.14 * 1_000_000_000;//e9 signifie 1 suivi de 9 0s
On peut également utiliser cette méthode pour représenter de très petits nombres, comme 1 nanomètre :
soit nm = 0,000000001 ; //Unité (mètre)
Comme il y a trop 0 , on peut aussi utiliser _ :
soit nm = 0,000_000_001 ;
Bien sûr, vous pouvez également utiliser e pour omettre tous 0 , comme suit :
soit nm = 1e-9;//9 0s à gauche de 1, y compris celui avant la virgule décimale
En d'autres termes, e-9 signifie 1 -9 , ce qui correspond à 1/1000_000_000 , donc l'équation suivante est vraie :
1e-9 === 1/1_000_000_000;3.14e-8 === 3.14/1_000_000_00 ;
L'hexadécimal est un format couramment utilisé en programmation, comme la couleur, l'encodage, etc. Nous pouvons ajouter 0x avant les nombres ordinaires pour représenter les nombres hexadécimaux :
soit hex = 0xff;//255, non sensible à la casse, 0xFF est le même
Les nombres binaires commencent par 0b :
laissez bin = 0b1011;//11
Les nombres octaux commencent par 0o :
soit oct = 0o777;//511
Cette méthode d'écriture simple ne prend en charge que ces trois types spéciaux. Comme pour les autres nombres de base, vous pouvez utiliser des fonctions spéciales pour les générer ( parseInt ).
La méthode toString peut convertir le nombre en une forme de chaîne correspondant à base .
Donnez une châtaigne :
soit num = 996 ; console.log(num.toString(8));//Convertir en chaîne octale console.log(num.toString(16));//Convertir en chaîne hexadécimale console.log(num.toString( 32));// Convertir en 32 chaînes hexadécimales
Les résultats de l'exécution du code sont les suivants :
La plage de base peut aller de 2 à 36 Si elle n'est pas renseignée, la valeur par défaut est 10 .
Notez que si vous utilisez des nombres pour appeler directement la méthode toString , vous devez dans certains cas en appliquer deux . par exemple :
console.log(123.toString(8));//Erreur, erreur de syntaxe console.log(123..toString(8));//Correct, 173
Il y a deux . après le nombre, car en JavaScript le premier . après le nombre est considéré comme le point décimal et le deuxième point est le .
S'il s'agit d'un nombre décimal, ce problème n'existe pas. Par exemple :
console.log(3.14.toString(8));
Ou bien, on peut utiliser des parenthèses pour éviter d'utiliser deux points, par exemple :
console.log((123).toString(8));//'173
L'arrondi est l'une des opérations les plus courantes sur les nombres et comprend généralement :
Arrondir à l'inférieur, Math.floor(num)
console.log(Math.floor(3.14));//3 console.log(Math.floor(9.99));//9 console.log(Math.floor(-3.14));//-4 console.log(Math.floor(-9.99));//-10
Ne suivez pas le principe de l'arrondi et prenez directement l'entier le plus proche inférieur ou égal à la valeur actuelle.
Arrondir, Math.ceil(num)
console.log(Math.ceil(3.14));//4 console.log(Math.ceil(9.99));//10 console.log(Math.ceil(-3.14));//-3 console.log(Math.ceil(-9.99));//-9
Ne suivez pas le principe de l'arrondi et prenez directement l'entier le plus proche supérieur ou égal au nombre actuel.
Arrondir à l'entier le plus proche, Math.round(num)
console.log(Math.round(3.14));//3 console.log(Math.round(9.99));//10 console.log(Math.round(-3.14));//-3 console.log(Math.round(-9.99));//-10
Suivant le principe de l'arrondi, l'entier le plus proche du nombre actuel est pris.
Supprimer les décimales, Math.trunc(num)
console.log(Math.trunc(3.14));//3 console.log(Math.trunc(9.99));//9 console.log(Math.trunc(-3.14));//-3 console.log(Math.trunc(-9.99));//-9
Supprimez directement les nombres après la virgule et arrondissez aux chiffres entiers. Le navigateur IE ne prend pas en charge cette méthode
Comparez les quatre méthodes ci-dessus :
| Math.sol | Math.ceil | Math.tour | Math.trunc | |
|---|---|---|---|---|
| 3.14 | 3 | 4 | 3 | 3 |
| 9,99 | 9 | 10 | 10 | 9 |
| -3.14 | -4 | -3 | -3 | -3 |
| -9,99 | -10 | -9 | -10 | -9 |
La méthode ci-dessus arrondit simplement la décimale en un nombre entier. Dans certains cas, nous avons besoin de décimales avec une précision spécifique. Par exemple, que devons-nous faire si nous prenons les 4 derniers chiffres de pi ?
Il existe deux méthodes :
multiplication mathématique et comptage de divisions
soit pi = 3.1415926;console.log(Math.round(pi * 10000) / 10000);//3.1416
Le code ci-dessus multiplie d'abord pi par 10000 , puis l'arrondit, puis le divise par 10000 , obtenant ainsi un résultat qui répond aux exigences de précision. Cependant, cela semble idiot et JavaScript nous offre un moyen plus simple.
àFixe(n)
soit pi = 3.1415926;console.log(pi.toFixed(4));//3.1416
Le code ci- + pi.toFixed(4) ne semble avoir aucun problème avec la sortie. En fait, toFixed renvoie une chaîne si nous avons besoin d'un type numérique, nous pouvons le convertir.
De plus, si la mantisse décimale n'est pas assez longue, toFixed ajoutera '0' à la fin :
soit num = 3.1;console.log(num.toFixed(9));
Les résultats de l'exécution du code sont les suivants : 
Cela prouve également que la valeur de retour de toFixed est une chaîne, sinon 0 sera omis.
Les représentations en virgule flottante sont toujours biaisées dans de nombreux cas
À l'intérieur de l'ordinateur, les nombres à virgule flottante sont représentés conformément à IEEE-754 , où les nombres à virgule flottante simple précision sont de 32 bits et les nombres à virgule flottante double précision sont de 64 bits. Dans un nombre à virgule flottante double précision, 1 bit est utilisé pour représenter le signe, 52 bits sont utilisés pour stocker les chiffres significatifs et 11 bits sont utilisés pour stocker la position de la virgule décimale.
Même si 64 bits peuvent déjà représenter de très grands nombres, il existe toujours la possibilité de franchir la frontière, par exemple :
soit bigNum = 1e999;console.log(bigNum);//Infinity
Le nombre qui dépasse la valeur maximale deviendra Infinity (infini), perdant ainsi la taille du nombre d'origine, ce qui est une sorte d'écart.
Il existe un autre type de déviation que nous devons apprendre :
console.log(0.1+0.2 === 0.3);//falseconsole.log(0.1 + 0.2);
Les résultats de l'exécution du code sont les suivants :
C'est vrai, le résultat de 0.1 + 0.2 n'est pas 0.3 , mais un tas de 0 suivis d'un 4 .
Ce type d'écart est très fatal, en particulier dans les scénarios de travail dans les centres commerciaux et les banques. Même un très petit écart entraînera une perte de richesse infinie dans les scénarios de chiffre d'affaires élevé.
Un jour, j’ai entendu l’histoire d’un employé de banque qui avait volé des millions de dollars en déduisant les salaires des ouvriers. Le salaire de chaque employé n’était que de 20 cents !
Je pense que si cela m'arrivait, je ne pourrais certainement pas le trouver, c'est pourquoi il est si important d'être précis à tout moment.
Je ne sais pas si cette histoire est vraie ou non~~
Prenons notre système décimal commun comme exemple. Nous savons tous qu'il y a deux choses étranges dans les décimales, l'une est appelée décimales répétitives infinies et l'autre est appelée décimales infinies non répétitives. Par exemple, 1/3 est une répétition infinie. décimal 0.3333333(3) et pi C'est un nombre décimal infini et non répétitif. Infini signifie que la taille du nombre ne peut pas être clairement décrite numériquement et que ce que nous pouvons écrire est inexact.
Il existe également des nombres en boucle infinie en binaire. La différence est qu'en décimal, un nombre comme 0.1 qui semble très simple, est un nombre décimal en boucle infinie en binaire.
Par exemple:
soit x = 0,1;console.log(x.toFixed(20));
Les résultats de l'exécution du code sont les suivants :
Ne trouvez-vous pas que c'est incroyable ? Nous avons simplement créé une variable et lui avons attribué la valeur 0.1 , puis avons pris 20 décimales, mais nous avons obtenu un résultat incroyable.
Si nous changeons l'angle, il sera peut-être plus facile de comprendre ce phénomène. Dans le système décimal, tout nombre entier divisé par 10 ou 10 puissances entières est un nombre normal et précis, comme 1/10 ou 996/1000 . Cependant, si vous divisez par 3 , vous obtiendrez un résultat en boucle, tel que 1/3 .
Cette description est également valable si elle est convertie en binaire.
En binaire, tout entier divisé par 2 ou une puissance entière de 2 est un nombre exact normal. Cependant, si vous le divisez par 10 , vous obtiendrez une boucle infinie de nombres binaires.
Par conséquent, nous pouvons conclure que les nombres binaires ne peuvent pas représenter avec précision 0.1 et 0.2 tout comme les nombres décimaux ne peuvent pas décrire 1/3 .
Avis:
Ce type d'écart de données n'est pas un défaut de JavaScript, c'est le même résultat pour PHP, Java, C, Perl et Ruby.
Arrondi
Lors de l'affichage d'une décimale infiniment récurrente, on peut utiliser directement la méthode toFixed pour arrondir la décimale. Cette méthode renvoie directement une chaîne, ce qui est très pratique pour afficher les prix.
0.3.toFixed(2);//0.30
Utiliser de petites unités
Une autre façon est d'utiliser des unités plus petites pour calculer les prix et les distances, par exemple en utilisant des centimes au lieu du yuan pour calculer le prix total. En fait, de nombreux sites de trading le font. Cependant, cette méthode ne fait que réduire le nombre d’occurrences de décimales et il n’existe aucun moyen d’éviter complètement l’apparition de décimales.
Il existe deux valeurs spéciales dans les nombres JavaScript : Infinity et NaN .
Comment juger si un nombre est un nombre normal ?
Nous pouvons utiliser deux méthodes :
estFinite(val)
Cette fonction convertira le paramètre val en un type numérique, puis déterminera si le nombre est fini et retournera true lorsque le nombre n'est pas NaN , Infinity ou -Infinity .
console.log(isFinite(NaN));//falseconsole.log(isFinite(Infinity));//falseconsole.log(isFinite(3));//trueconsole.log(isFinite('12'));// vrai Les résultats de l'exécution du code sont les suivants :
Puisqu'une chaîne qui ne peut pas être convertie en nombre sera convertie en NaN , nous pouvons utiliser la méthode isFinite pour déterminer si la chaîne est une chaîne numérique :
console.log(isFinite('xxxx'));//falseconsole.log(isFinite('Infinite'));//falseconsole.log(isFinite(' '));//true, la chaîne vide est convertie en 0Les résultats de l'exécution du code sont les suivants :
estNaN(val)
Renvoie true lorsque val est NaN ou une autre valeur qui ne peut pas être convertie en nombre.
console.log(isNaN(NaN));//trueconsole.log(isNaN('Infinite'));//true Résultats de l'exécution du code :
Pourquoi utiliser la fonction isNaN au lieu de la lire directement ?
Par exemple:
console.log(NaN === NaN);//false
Les résultats de l'exécution du code sont les suivants :
En effet, NaN n’est égal à aucun nombre, y compris lui-même.
Object.is(a,b) peut déterminer si les paramètres a et b sont égaux, il renvoie true , sinon il renvoie false .
Peut être comparé à NaN
console.log(Object.is(NaN,NaN));//true
Résultats de l'exécution du code :
0 et -0
console.log(Object.is(0,-0));//false
Résultats de l'exécution du code :
Dans l’ordinateur, le positif et le négatif sont représentés par 0 et 1 En raison de signes différents, 0 et -0 sont en réalité différents et sont exprimés de différentes manières.
autre
Les autres situations de comparaison sont exactement les mêmes que a === b .
parseInt et parseFloat peuvent convertir des chaînes en nombres Contrairement à + et Number , leurs restrictions sont plus souples. Par exemple, utiliser + et Number pour une chaîne comme "100￥" renverra inévitablement NaN , mais parseInt et parseFloat peuvent le gérer facilement.
Par exemple:
console.log(+"100￥");console.log(parseInt("100￥"));console.log(parseFloat("12.5￥"));Résultats de l'exécution du code :
parseInt et parseFloat lisent les nombres d'une chaîne jusqu'à ce qu'ils ne puissent plus être lus. Les deux sont particulièrement adaptés au traitement de chaînes commençant par des nombres tels que "99px" et "11.4em" , mais NaN est renvoyé pour les chaînes commençant par d'autres caractères.
console.log(parseInt('ff2000'));//NaN Cependant, nous avons constaté ff2000 est en fait une chaîne numérique hexadécimale. parseInt peut également gérer cette situation, mais doit ajouter un paramètre hexadécimal.
Par exemple:
console.log(parseInt('FF2000',16));
//16719872
console.log(parseInt('0xFF2000',16));
//16719872
console.log(parseInt('nnnnnn',36));
//1430456963Résultats de l'exécution du code :
L'objet Math intégré contient de nombreuses constantes et méthodes que nous utilisons souvent. Voici quelques exemples de celles couramment utilisées :
Math.PI
Pi Π est une constante non cyclique infinie, on peut utiliser Math.PI à la place :
console.log(Math.PI);
Math.random()
Générez un nombre aléatoire dans l'intervalle [0,1) :
console.log(Math.random());console.log(Math.random());
Si nous avons besoin d’un nombre aléatoire dans une plage spécifique, nous pouvons le multiplier par une valeur spécifique puis l’arrondir.
Math.pow(a,b)
Calculez a b , par exemple :
console.log(Math.pow(2,3));//8
Math.max()/Math.min()
Choisissez une valeur maximale/minimale parmi un nombre quelconque d'arguments :
console.log(Math.max(1,2,3,4,5));//5console.log(Math.min(1,2,3,4,5));//1
