Dans cet article, nous examinerons de plus près les nombres, les opérateurs mathématiques, les façons de convertir un nombre en chaîne et vice versa, ainsi que de nombreux autres points importants.

fonction isFinite

La fonction isFinite permet de vérifier si un argument est un nombre fini.

En guise de réponse fonction donnée renvoie false si l'argument est Infinity , -Infinity , NaN , ou sera converti en l'une de ces valeurs numériques spéciales. Sinon, cette fonction renverra true .

EstFinite(73); // true isFinite(-1/0); // false isFinite(Infinity); // false isFinite(NaN); // false isFinite("Texte"); // FAUX

En plus de la fonction globale isFinite, JavaScript possède également la méthode Number.isFinite. Contrairement à isFinite, il ne force pas la conversion de l'argument en nombre.

EstFinite("73"); // vrai Number.isFinite("73"); // FAUX

fonction isNaN

La fonction isNaN sert à déterminer si un argument est un nombre ou peut être converti en un. Si tel est le cas, la fonction isNaN renvoie false. Sinon, il renvoie vrai.

EstNaN(NaN); //vrai estNaN("25px"); // vrai, parce que 20px n'est pas un nombre isNaN(25.5); //faux estNaN("25.5"); //faux estNaN(" "); //faux, car un espace ou plusieurs espaces sont convertis en 0 isNaN(null); //faux, car la valeur nulle est convertie en 0 isNaN(true); //faux, car true est converti en 1 isNaN(false); //faux, car la valeur fausse est convertie en 0

Si cette action doit être effectuée sans conversion de type, utilisez la méthode Number.isNaN. Cette méthode a été introduite dans le langage depuis ECMAScript 6.

Comment convertir explicitement une chaîne en nombre ?

Vous pouvez convertir explicitement une chaîne en nombre à l'aide des méthodes suivantes :

1. Utiliser opérateur unaire + Le à placer avant la valeur.

+"7.35" ; // 7.35 +"texte" ; // NaN

Cette méthode ignore les espaces au début et à la fin de la ligne, ainsi que \n (saut de ligne).

+"7.35" ; //7.35 +"7.35\n" ; //7.35

En utilisant Par ici notez qu'une chaîne vide ou une chaîne composée d'espaces et de \n est convertie en nombre 0. De plus, il convertit également le type de données null et les booléens en nombre.

Nul; //0 + vrai ; //1 +faux ; //0 +" " ; //0

2. Fonction parseInt . Cette fonction est conçue pour convertir argument d'un entier. Au lieu d'utiliser opérateur unaire +, cette méthode vous permet de convertir une chaîne en un nombre, dans lequel tous les caractères ne sont pas numériques. Il commence à convertir la chaîne, à partir du premier caractère. Et dès qu'elle rencontre un caractère qui n'est pas un caractère numérique, cette fonction arrête son travail et renvoie le nombre résultant.

ParseInt("18px"); //18 parseInt("33.3%"); //33

Cette fonction peut fonctionner avec différents systèmes numérotation (binaire, octale, décimale, hexadécimale). L'indication de la base du système de numération s'effectue au moyen de 2 arguments.

ParseInt("18px", 10); //18 parseInt("33.3%", 10); //33 parseInt("101",2); //5 parseint("B5",16); //181

En plus de la fonction parseInt, JavaScript possède la méthode Number.parseInt. Cette méthode n'est pas différente de la fonction parseInt et a été introduite dans JavaScript avec la spécification ECMASCRIPT 2015(6).

3. Fonction parseFloat . La fonction parseFloat est similaire à parseInt , sauf qu'elle vous permet de convertir l'argument en un nombre fractionnaire.

ParseFloat("33.3%"); //33.3

De plus, la fonction parseFloat, contrairement à parseInt, n'a pas 2 arguments, et donc elle essaie toujours de traiter la chaîne comme un nombre en notation décimale.

ParseFloat("3.14"); parseFloat("314e-2"); parseFloat("0.0314E+2");

En plus de la fonction parseFloat, JavaScript possède la méthode Number.parseFloat. Cette méthode n'est pas différente de la fonction parseFloat et a été introduite dans JavaScript avec la spécification ECMASCRIPT 2015(6).

Convertir un nombre en chaîne

Vous pouvez transformer un nombre en chaîne à l'aide de la méthode toString.

(12.8).toString(); //"12.8"

La méthode toString vous permet également de spécifier la base du système de numération, en tenant compte du fait que vous devez convertir explicitement le nombre en chaîne :

(255).toString(16); //"ff"

Comment vérifier si une variable est un nombre

Vous pouvez déterminer si la valeur d'une variable est un nombre en utilisant l'une des méthodes suivantes :

1. Utilisation des fonctions isNaN et isFinite :

// myVar est une variable if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( // myVar est un nombre ou peut être converti en lui );

En tant que fonction:

// fonction function isNumeric(value) ( ​​​​return !isNaN(parseFloat(value)) && isFinite(parseFloat(value)); ) // utilisation var myVar = "12px"; console.log(isNumeric(myVar)); //vrai

Cette méthode vous permet de déterminer si la valeur spécifiée est un nombre ou peut être convertie en celui-ci. Cette variante ne compte pas une chaîne vide, une chaîne d'espaces, null , Infinity , -Infinity , true et false comme un nombre.

2. Utilisation type d'opérateur et les fonctions isFinite, isNaN :

// fonction qui vérifie si la valeur est un nombre function isNumber(value) ( ​​​​return typeof value === "number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Cette fonction détermine si la valeur spécifiée est de type Nombre, et aussi si elle appartient à l'un des valeurs spéciales Infini, -Infini et NaN. Si c'est le cas, alors cette fonction renvoie vrai.

3. Utilisation de la méthode ECMAScript 6 Number.isInteger(value). Cette méthode vous permet de déterminer si la valeur spécifiée est un entier.

Number.isInteger("20"); //faux, car cette méthode ne traduit pas la chaîne en nombre Number.isInteger(20); // vrai, parce que valeur donnée est un nombre

Nombres pairs et impairs

Vous pouvez vérifier si un nombre est pair ou impair en fonctions suivantes:

// Fonction pour vérifier si un nombre est pair function isEven(n) ( return n % 2 == 0; ) // Fonction pour vérifier si un nombre est impair function isOdd(n) ( return Math.abs(n % 2) == 1 ; )

Mais avant d'effectuer une telle vérification, il est souhaitable de s'assurer que la valeur spécifiée est un nombre :

valeur=20 ; if (Number.isInteger(value)) ( if (isEven(value)) ( console.log("Number " + value.toString() + " - even"); ) )

Nombres premiers en Javascript

Prenons un exemple dans lequel nous affichons des nombres premiers de 2 à 100 en utilisant Javascript.

// Une fonction qui vérifie si un nombre est premier function isPrime(value) ( ​​​​if (isNaN(value) || !isFinite(value) || value%1 || value< 2) return false; var max=Math.floor(Math.sqrt(value)); for (var i = 2; i< = max; i++) { if (value%i==0) { return false; } } return true; } // создать массив, который будет содержать простые числа от 2 до 100 var primaryNumber = ; for (var i = 2; i <= 100; i++) { if(isPrime(i)) primaryNumber.push(i); } // вывести в консоль простые числа от 2 до 100 console.log(primaryNumber);

Arrondir un nombre en Javascript

Il existe différentes façons d'arrondir un nombre fractionnaire à une valeur entière en JavaScript.

1. Utiliser les méthodes Math.floor , Math.ceil et Math.round spécialement conçues pour cela. La méthode Math.floor arrondit un nombre fractionnaire à l'entier le plus proche, c'est-à-dire supprime simplement la partie fractionnaire. Math.ceil arrondit un nombre fractionnaire à l'entier supérieur le plus proche. Math.round arrondit un nombre vers le haut ou vers le bas en fonction de la valeur de la partie fractionnaire. Si fraction supérieur ou égal à 0,5, puis vers le haut, sinon la torsion est vers le bas.

Console.log(Math.floor(7.9)); //7 console.log(Math.ceil(7.2)); //8 console.log(Math.round(7.5)); //8

2. Utilisation de la méthode toFixed(precision). Cette méthode arrondit la partie fractionnaire d'un nombre à la précision spécifiée. Le résultat de l'arrondi est renvoyé sous forme de chaîne.

Console.log(7.987.toFixed(2)); //"7.99"

S'il n'y a pas assez de décimales pour former la précision spécifiée du nombre, il est rempli de zéros.

Console.log(7.987.toFixed(5)); //"7.98700"

3. Via la méthode toPrecision(precision). Cette méthode représente un nombre avec la précision spécifiée. En même temps, il peut arrondir non seulement la fraction, mais aussi toute la partie du nombre. Le nombre résultant peut être représenté par cette méthode en fonction du résultat en un point fixe ou sous forme exponentielle.

Console.log((1001).toPrecision(2)); //"1.0e+3" console.log((1001).toPrecision(5)); //"1001.0" console.log((12.4).toPrecision(1)); //"1e+1" console.log((12.4).toPrecision(2)); //"12" console.log((12.4).toPrecision(3)); //"12.4" console.log((12.4).toPrecision(5)); //"12.400"

4. Utilisation des opérateurs logiques NOT ou OR.

//via la double négation logique console.log(~~7.9); //7 // en utilisant le OU logique avec zéro : console.log(7.9^0); //7

Entier et partie fractionnaire d'un nombre

Vous pouvez obtenir la partie entière d'un nombre en utilisant les méthodes Math.floor() et parseInt() :

Console.log(Math.floor(7.21)); // 7 console.log(parseInt(7.21)); // 7

Vous pouvez obtenir la partie fractionnaire d'un nombre à l'aide de l'opérateur de pourcentage (%). Cet opérateur renvoie le reste qui sera obtenu en divisant le premier nombre par le second. Dans ce cas, 1 doit être utilisé comme 2e chiffre.

Console.log(7.21%1); // 0.20999999999999996 // précis à 2 décimales console.log((7.21%1).toFixed(2)); // "0.21"

De plus, la partie fractionnaire peut également être obtenue à l'aide de calculs :

var nombre = 7,21 ; var fractionNumber = nombre - Math.floor(Math.abs(nombre)); console.log(fractionNumber); // 0.20999999999999996

Le nombre est-il divisible

Vous pouvez déterminer si un nombre est divisible de manière égale à l'aide de l'opérateur de pourcentage :

varnumber = 9 ; // si le reste de la division de nombre par 3 est 0, alors oui, sinon non if (nombre%3==0) ( console.log ("Le nombre " + nombre + " est divisible par 3"); ) else ( console.log("Le nombre " + le nombre + " n'est pas divisible par 3"); )

Formatage des nombres

En JavaScript, la méthode toLocaleString() vous permet de formater la sortie d'un nombre en fonction des paramètres régionaux (paramètres de langue du système d'exploitation).

Par exemple, formatons un nombre en fonction des normes régionales installées par défaut dans le système :

var numéro = 345,46 ; console.log(number.toLocaleString()); //"345,46"

Par exemple, formatons un nombre conformément aux normes régionales de la Russie (ru) :

Console.log((108.1).toLocaleString("ru-RU")); //"108.1"

Cette méthode peut également être utilisée pour formater un nombre en tant que devise :

Console.log((2540.125).toLocaleString("ru-RU",(style:"devise", devise:"RUB"))); //"2,540.13 ₽" console.log((89.3).toLocaleString("ru-RU",(style:"currency", currency:"USD"))); //"$89.30" console.log((2301.99).toLocaleString("ru-RU",(style:"currency", currency:"EUR"))); //"2 301,99 €"

Représenter un nombre en pourcentage :

Console.log((0.45).toLocaleString("ru-RU",(style:"percent"))); //"45 %"

Divisez le nombre en chiffres (propriété useGrouping) :

Console.log((125452.32).toLocaleString("ru-RU",(useGrouping:true))); //"125 452.32"

Imprimer un nombre avec un certain nombre de chiffres (2) après la virgule :

Console.log((1240.4564).toLocaleString("ru-RU",(minimumFractionDigits:2, maximumFractionDigits:2))); //"1240.46"

Comparaison des nombres

Les opérateurs suivants sont utilisés pour comparer des nombres en JavaScript : == (égal à), != (différent de), > (supérieur à),< (меньше), >= (supérieur ou égal),<= (меньше или равно).

Par exemple, comparons deux nombres :

Console.log(2>3); //faux console.log(5>=3); //vrai

Lors de la comparaison de nombres avec une partie fractionnaire, il est nécessaire de prendre en compte les erreurs pouvant survenir lors de ces calculs.

Par exemple, en JavaScript, la somme des nombres (0,2 + 0,4) n'est pas égale à 0,6 :

Console.log((0.2+0.4)==0.6); //FAUX

Des erreurs se produisent parce que tous les calculs sont informatiques ou autres appareil électronique produit dans le système à 2 chiffres. Ceux. avant d'effectuer toute action, l'ordinateur doit d'abord convertir les nombres présentés dans l'expression au système à 2 nombres. Mais aucun nombre décimal fractionnaire ne peut être représenté exactement dans le 2e système de numération.

Par exemple, le nombre 0,25 10 est converti en binaire exactement.

0,125 × 2 = 0,25 | 0 0,25 × 2 = 0,5 | 0 0,5 × 2 = 1 | 1 0,125 10 = 0,001 2

Par exemple, le nombre 0,2 10 ne peut être converti dans le système 2 qu'avec une certaine précision :

0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 ... 0,2 10 = 0,001100110011... 2

Par conséquent, ces erreurs affecteront le calcul de la somme de deux nombres et les résultats de la comparaison. Ceux. il s'avère qu'en fait JavaScript verra cette entrée comme suit :

0.6000000000000001==0.6

Lors du calcul ou de l'affichage de nombres avec une partie fractionnaire, vous devez toujours spécifier la précision avec laquelle cela doit être fait.

Par exemple, comparez des nombres jusqu'à 2 décimales à l'aide des méthodes toFixed() et toPrecision() :

//méthode toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //méthode toPrecision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //vrai

Opérations mathématiques de base

JavaScript a les opérateurs mathématiques suivants : + (addition), - (soustraction), * (multiplier), / (division), % (reste de la division), ++ (augmenter la valeur de 1), -- (diminuer la valeur de 1 ).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, soit 6:3=2 => 6-3*2 => rest(0) 5%2 //1, soit 5:2=2(.5) => 5-2*2 => rest(1) 7.3%2 //1.3, soit 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //le signe du résultat de l'opération % est égal au signe de la première valeur -9%2.5 //-1.5, soit 9:2.5=3(.6) => 9-2.5*3 => rest(1.5) -9%-2.5 //-1.5, soit 9:2.5=3(.6) => 9-2.5*3 => rest(1.5) -2%5 //-2, soit 2:5=0(.4) => 2-5*0 => reste(2) x = 3 ; journal de la console (x++); //affiche 3, puis définit y sur 4 console.log(x); //4x = 3 ; journal de la console(++x); //définit 4 et affiche x = 5 ; journal de la console (x--); //sorties 5, y définit alors 4 console.log(x); //4x = 5 ; journal de la console (--x); //sets to 4 and outputs De plus, il existe des opérateurs combinés en JavaScript : x+=y (x=x+y), x-=y (x=x-y), x*=y (x=x*y), x/= y (x=x/y), x%=y (x=x%y). x=3 ; y=6 ; x+=y ; journal de la console(x); //9x = 3 ; y=6 ; x-=y ; journal de la console(x); //-3 x = 3 ; y=6 ; x*=y ; journal de la console(x); //18 x = 3 ; y=6 ; x/=y ; journal de la console(x); //0,5 x = 3 ; y=6 ; x%=y ; journal de la console(x); //3

Bonjour. Aujourd'hui, dans la colonne sur Javascript, nous verrons comment définir le nombre de décimales dans les nombres à virgule flottante en javascript. Par exemple, vous devez laisser 3 décimales lors de la sortie, ou seulement deux.

Tâche : javascript nombre de décimales

Nous sommes donc confrontés à une tâche : il y a un résultat de calcul dans lequel il y a des nombres avant la virgule et après la virgule. Décimal. Disons que le résultat est comme ceci 1538.9891200153. Mais lorsque vous sortez, vous devriez obtenir un nombre qui reflète le montant, où avant la virgule est le nombre de billets et après - kopecks.

Il existe plusieurs façons de résoudre ce problème.

Solution 1 : nombre de décimales en javascript avec la méthode toFixed

toFixed est une méthode intégrée javascript qui s'applique à n'importe quel nombre, elle prend la précision d'arrondi (c'est-à-dire le nombre de décimales) comme paramètre.

Varnum=1538.9891200153 ; num_str=num.toFixed(); //num_str=1538 ; num_str=num.toFixed(2); //num_str=1538.98 ; num_str=num.toFixed(5); //num_str=1538.98912 ;

Le paramètre de précision dans cette fonction doit être au moins 0 (ne prend pas de valeurs négatives) et au plus 20.

Vous pouvez également vous passer d'une variable, comme ceci :

Num_str=(1538.9891200153).toFixed(2); //num_str=1538.98 ;

Solution 2 : nombre de décimales en javascript avec la méthode toPrecision

Cette solution est basée sur le même méthode javascript. Particularité de cette méthode est que le paramètre pris en entrée n'indique pas la précision (le nombre de décimales), mais le nombre total de caractères (avant et après la virgule).

Varnum=1538.9891200153 ; num_str=num.toPrecision(5); //num_str=1538.9 ; num_str=num.toPrecision(7); //num_str=1538.989 ;

Solution sans décimales : javascript nombre de décimales

Si les décimales doivent être complètement supprimées, c'est-à-dire que vous devez arrondir un nombre fractionnaire à un entier, vous pouvez utiliser les fonctions de la classe Math : round, ceil et floor.
Arrondi - arrondi vers le haut ou vers le bas (selon le nombre). Si la valeur après la virgule est supérieure à la moitié, elle sera arrondie vers le haut, si elle est inférieure, elle sera arrondie vers le bas. Autrement dit, si 0,51 - il deviendra 1, si 0,49 - 0.

Ceil - de l'anglais. le plafond s'arrondit toujours.

Étage - de l'anglais. Le sexe arrondit toujours à l'inférieur.

Varnum = 1538,9891200153 ; num_str=math.round(num); //num_str=1539 ; num_str=Math.floor(num); //num_str=1538 ; num_str=Math.ceil(num); //num_str=1539 ;

C'est tout. J'espère que cette note vous a aidé à résoudre votre problème. Si quelque chose n'a pas fonctionné, posez des questions en utilisant le bouton vert "Poser une question à un spécialiste" ou dans les commentaires.

Très souvent, les calculs en JavaScript ne donnent pas exactement les résultats que l'on souhaite. Bien sûr, nous pouvons faire n'importe quoi avec les nombres - arrondir vers le haut ou vers le bas, définir des plages, couper les nombres inutiles à un certain nombre de décimales, tout dépend de ce que vous voulez faire avec ce nombre à l'avenir.

Pourquoi l'arrondi est-il nécessaire ?

L'un des aspects curieux de JavaScript est qu'il ne stocke pas réellement d'entiers, nous travaillons tout de suite avec des nombres à virgule flottante. Ceci, combiné au fait que de nombreuses valeurs fractionnaires ne peuvent pas être exprimées avec un nombre fini de décimales, en JavaScript nous pouvons obtenir des résultats comme celui-ci :

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
À des fins pratiques, cette inexactitude n'a pas d'importance, dans notre cas, nous parlons d'une erreur dans les quintillions d'actions, cependant, cela peut décevoir quelqu'un. Nous pouvons également obtenir des résultats étranges lorsque nous travaillons avec des nombres qui représentent des devises, des pourcentages ou des tailles de fichiers. Pour corriger ces imprécisions, il suffit de pouvoir arrondir les résultats, et il suffit de régler la précision décimale.

Arrondir les nombres a une utilisation pratique, nous pouvons manipuler un nombre dans une certaine plage, par exemple nous voulons arrondir une valeur au nombre entier le plus proche au lieu de travailler uniquement avec la partie décimale.

Arrondir les décimales

Pour rogner un nombre décimal, utilisez toFixed ou la méthode toPrecision. Les deux prennent un seul argument, qui détermine, respectivement, combien de chiffres significatifs (c'est-à-dire le nombre total de chiffres utilisés dans le nombre) ou de décimales (le nombre après la virgule) le résultat doit inclure :

1. Si l'argument n'est pas défini pour toFixed(), alors il sera par défaut à zéro, ce qui signifie 0 décimales, l'argument a une valeur maximale de 20.
2. Si aucun argument n'est donné à toPrecision, le nombre n'est pas modifié

soit randNum = 6,25 ; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" randNum = 87,335 ; randNum.toFixed(2); > "87.33" randNum = 87.337 ; randNum.toPrecision(3); > "87.3"
Les méthodes toFixed() et toPrecision() renvoient une représentation sous forme de chaîne du résultat, pas un nombre. Cela signifie que lors de la somme de la valeur arrondie avec randNum , les chaînes seront concaténées, pas les nombres ajoutés :

Soit randNum = 6,25 ; laissez arrondi = randNum.toFixed(); // "6" console.log(randNum + arrondi); > "6.256"
Si vous voulez que le résultat soit de type numérique, vous devrez utiliser parseFloat :

Soit randNum = 6,25 ; laissez arrondi = parseFloat(randNum.toFixed(1)); journal de la console (arrondi); > 6.3
A noter que 5 valeurs sont arrondies sauf dans de rares cas.

Les méthodes toFixed() et toPrecision() sont utiles, car elles peuvent non seulement couper la partie décimale, mais également remplir les décimales, ce qui est pratique lorsque vous travaillez avec des devises :

Soit wholeNum = 1 let dollarsCents = wholeNum.toFixed(2); console.log(dollarsCents); > "1.00"
Notez que toPrecision renverra le résultat en notation exponentielle si le nombre d'entiers est supérieur à la précision elle-même :

Soit num = 123,435 num.toPrecision(2); > "1.2e+2"

Comment éviter les erreurs d'arrondi avec les décimales

Dans certains cas, toFixed et toPrecision arrondiront la valeur 5 vers le bas et vers le haut :

Soit numTest = 1.005 ; numTest.toFixed(2); > "1.00"
Le résultat du calcul ci-dessus aurait dû être 1,01 et non 1. Si vous voulez éviter ce genre d'erreur, nous pouvons utiliser la solution suggérée par Jack L Moore, qui utilise des nombres exponentiels pour le calcul :

Function round(value, decimals) ( return Number(Math.round(value+"e"+decimals)+"e-"+decimals); )
Maintenant:

Rond(1.005,2); > 1.01
Si vous souhaitez une solution plus robuste que celle présentée ci-dessus, vous pouvez vous rendre sur MDN.

Arrondi machine epsilon

Une méthode alternative pour arrondir les nombres décimaux a été introduite dans ES6. L'arrondi machine epsilon fournit une marge d'erreur raisonnable lors de la comparaison de deux nombres à virgule flottante. Sans arrondi, les comparaisons peuvent produire des résultats semblables à ceux-ci :

0,1 + 0,2 === 0,3 > faux
Nous utilisons Math.EPSILON dans notre fonction pour obtenir la comparaison correcte :

Fonction epsEqu(x, y) ( return Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
La fonction prend deux arguments : le premier est le calcul en cours, le second est le résultat attendu. Il renvoie une comparaison des deux :

EpsEqu(0.1 + 0.2, 0.3) > vrai
Tous les navigateurs modernes prennent déjà en charge les fonctions mathématiques ES6, mais si vous voulez une prise en charge dans des navigateurs comme IE 11, utilisez polyfills .

Détourage fractionnaire

Toutes les méthodes présentées ci-dessus sont capables d'arrondir à des nombres décimaux. Pour couper simplement un nombre à deux décimales, vous devez d'abord le multiplier par 100, puis diviser le résultat par 100 :

Function truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3.1416) > 3.14
Si vous souhaitez adapter la méthode à n'importe quel nombre de décimales, vous pouvez utiliser la double négation au niveau du bit :

Function truncated(num, decimalPlaces) ( let numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Maintenant:

Soit randInt = 35,874993 ; tronqué(randInt,3); > 35.874

Arrondir au nombre le plus proche

Pour arrondir un nombre décimal vers le haut ou vers le bas au nombre le plus proche, selon ce dont nous sommes le plus proche, utilisez Math.round() :

Math.round(4.3) > 4 Math.round(4.5) > 5
Notez que "la moitié de la valeur", 0,5 est arrondie par les règles mathématiques.

Arrondir au nombre entier le plus proche

Si vous voulez toujours arrondir, utilisez Math.floor :

Math.floor(42.23); > 42 Math.floor(36.93); > 36
Notez que l'arrondi à l'inférieur fonctionne pour tous les nombres, y compris les nombres négatifs. Imaginez un gratte-ciel avec un nombre infini d'étages, y compris les étages inférieurs (représentant des nombres négatifs). Si vous êtes dans un ascenseur au niveau inférieur entre 2 et 3 (qui est une valeur de -2,5), Math.floor vous amènera à -3 :

Math.floor(-2.5); > -3
Mais si vous voulez éviter ce genre de situation, utilisez Math.trunc , qui est pris en charge par tous les navigateurs modernes (sauf IE/Edge) :

Math.trunc(-41.43); > -41
Sur MDN, vous trouverez un polyfill qui fournira un support pour Math.trunc dans les navigateurs et IE/Edge.

Arrondir au nombre entier le plus proche

D'autre part, si vous devez toujours arrondir, utilisez Math.ceil. Encore une fois, rappelez-vous de l'ascenseur infini : Math.ceil montera toujours, que le nombre soit négatif ou non :

Math.ceil(42.23); > 43 Math. plafond(36.93); > 37 Math.plafond(-36.93); > -36

Arrondissez vers le haut/vers le bas si nécessaire

Si nous voulons arrondir au multiple de 5 le plus proche, le moyen le plus simple est de créer une fonction qui divise un nombre par 5, l'arrondit, puis le multiplie par le même montant :

Fonction roundTo5(num) ( return Math.round(num/5)*5; )
Maintenant:

RoundTo5(11); > 10
Si vous souhaitez arrondir à des multiples de votre valeur, nous utilisons une fonction plus générale, en passant la valeur initiale et un multiple :

Function roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )
Maintenant:

Soit nombreinitial = 11 ; soit multiple = 10 ; roundToMultiple(initialNumber, multiple); > 10 ;

Fixer un nombre dans une plage

Il existe de nombreux cas où nous souhaitons obtenir une valeur x comprise dans une plage. Par exemple, nous pourrions vouloir une valeur de 1 à 100, mais nous nous sommes retrouvés avec une valeur de 123. Pour résoudre ce problème, nous pouvons utiliser min (renvoie le plus petit d'un ensemble de nombres) et max (renvoie le plus grand de n'importe quel ensemble de nombres). Dans notre exemple, la plage va de 1 à 100 :

Laissez lowBound = 1 ; laissez highBound = 100 ; laissez numInput = 123 ; let clamped = Math.max(lowBound, Math.min(numInput, highBound)); journal de la console (serré); > 100 ;
Encore une fois, nous pouvons réutiliser l'opération et l'envelopper dans une fonction, en utilisant la solution suggérée par Daniel X. Moore :

Number.prototype.clamp = function(min, max) ( return Math.min(Math.max(this, min), max); );
Maintenant:

NumInput.clamp(lowBound, highBound); > 100 ;

Arrondi gaussien

L'arrondi gaussien, également connu sous le nom d'arrondi du banquier, est que l'arrondi pour ce cas est au nombre pair le plus proche. Cette méthode d'arrondi fonctionne sans erreur statistique. La meilleure décision il a été suggéré par Tim Down :

Fonction gaussRound(num, decimalPlaces) ( let d = decimalPlaces || 0, m = Math.pow(10, d), n = +(d ? num * m: num).toFixed(8), i = Math.floor (n), f = n - je, e = 1e-8, r = (f > 0,5 - e && f< 0.5 + e) ? ((i % 2 == 0) ? i: i + 1) : Math.round(n); return d ? r / m: r; }
Maintenant:

GaussRound(2.5) > 2 gaussRound(3.5) > 4 gaussRound(2.57,1) > 2.6
Point décimal en CSS :

Étant donné que JavaScript est souvent utilisé pour créer des transformations positionnelles pour les éléments HTML, vous vous demandez peut-être ce qui se passe si nous générons des valeurs décimales pour nos éléments :

#box (largeur : 63,667731993px ; )
La bonne nouvelle est que les navigateurs modernes respecteront les valeurs décimales dans le modèle de boîte, y compris les unités de pourcentage ou de pixel.

Tri

Très souvent, nous devons trier certains éléments, par exemple, nous avons un tableau d'enregistrements de jeu, alors qu'ils doivent être organisés par ordre décroissant du rang des joueurs. Malheureusement, la méthode standard sort() a des limitations surprenantes : elle fonctionne bien avec les mots anglais courants, mais s'arrête immédiatement lorsqu'elle rencontre des nombres, des caractères uniques ou des mots en majuscules.

Trier par ordre alphabétique

Il semblerait que trier un tableau par ordre alphabétique devrait être la tâche la plus simple :

Soit fruit = ["courge musquée", "abricot", "cantaloup"] ; tri des fruits(); > "abricot", "courge musquée", "cantaloup"]
Cependant, on se heurte à un problème dès qu'un des éléments est en majuscule :

Soit fruit = ["courge musquée", "abricot", "cantalope"] ; tri des fruits(); > "Cantaloup", "abricot", "courge musquée"]
En effet, par défaut, le trieur compare le premier caractère représenté en Unicode . Unicode est un code unique pour n'importe quel caractère, quelle que soit la plate-forme, quel que soit le programme, quelle que soit la langue. Par exemple, lorsque vous regardez la table des codes, le caractère "a" a la valeur U+0061 (hexadécimal 0x61), tandis que le caractère "C" a le code U+0043 (0x43), qui vient avant le caractère dans l'Unicode tableau "a".

Pour trier un tableau qui peut contenir des premières lettres à casse mixte, nous devons soit convertir temporairement tous les éléments en minuscules, soit définir notre propre ordre de tri à l'aide de la méthode localeCompare() avec quelques arguments. En règle générale, pour un tel cas, il est préférable de créer immédiatement une fonction à usage multiple :

Function alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("sensitivity": "base")); )); ) let fruit = ["courge musquée ", "abricot", "cantaloup"] ; alphaSort(fruits) >
Si vous souhaitez obtenir un tableau trié par ordre alphabétique inverse, échangez simplement les positions de a et b dans la fonction :

Function alphaSort(arr) ( arr.sort(function (a, b) ( return b.localeCompare(a, "en", ("sensitivity": "base")); )); ) let fruit = ["courge musquée ", "abricot", "cantaloup"] ; alphaSort(fruit) > ["Cantaloup", "courge musquée", "abricot"]
Ici, il convient de noter que localeCompare est utilisé avec des arguments, nous devons également nous rappeler qu'il est pris en charge par IE11+, pour les anciennes versions d'IE, nous pouvons l'utiliser sans arguments, et en minuscule :

Function caseSort(arr) ( arr.sort(function (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) let fruit = ["courge musquée", "abricot", "Cantaloup"]; caseSort(fruit) > ["abricot", "courge musquée", "cantaloup"]

Tri numérique

Tout cela ne s'applique pas à l'exemple dont nous avons parlé ci-dessus concernant le tableau des enregistrements de jeu. Avec certains tableaux numériques, le tri fonctionne très bien, mais à un moment donné, le résultat peut être imprévisible :

Soit highScores = ; trier(); >
Le fait est que la méthode sort() effectue une comparaison lexicographique : ce qui signifie que les nombres seront convertis en une chaîne et les comparaisons se feront à nouveau en faisant correspondre le premier caractère de cette chaîne dans l'ordre des caractères de la table Unicode. Par conséquent, nous devons à nouveau définir notre ordre de tri :

Soit highScores = ; highScores.sort(function(a,b) ( return a - b; )); >
Encore une fois, pour trier les nombres dans ordre inverse, échangez les positions de a et b dans la fonction.

Trier une structure de type JSON

Et enfin, si nous avons une structure de données de type JSON représentée sous la forme d'un tableau d'enregistrements de jeu :

Let scores = [( "name": "Daniel", "score": 21768 ), ( "name": "Michael", "score": 33579 ), ( "name": "Alison", "score": 38395 )] ;
Dans ES6+, vous pouvez utiliser les fonctions fléchées :

Scores.sort((a, b) => b.score - a.score));
Pour les navigateurs plus anciens qui n'ont pas cette prise en charge :

Scores.sort(function(a, b) ( return a.score - b.score ));
Comme vous pouvez le voir, le tri en JavaScript est une chose plutôt non évidente, j'espère que ces exemples vous faciliteront la vie d'une manière ou d'une autre.

Utilisation des fonctions avancées

L'exponentiation est une opération définie à l'origine comme le résultat de la multiplication d'un nombre naturel par lui-même, la racine carrée de a est le nombre qui donne a au carré. On pourrait utiliser ces fonctions constamment dans la vie de tous les jours dans les cours de mathématiques, y compris lors du calcul de surfaces, de volumes, ou encore dans la modélisation physique.

En JavaScript, la fonction de puissance est représentée par Math.pow(), dans le nouveau standard ES7 a été introduit nouvel opérateur exponentiation - " * * ".

Exponentiation

Pour élever un nombre à la puissance n, utilisez la fonction Math.pow(), où le premier argument est le nombre à élever à la puissance, et le second argument est l'exposant :

Math.pow(3,2) > 9
Cette notation signifie 3 au carré, ou 3 × 3, ce qui donne un résultat de 9. Un autre exemple pourrait bien sûr être donné :

Math.pow(5,3); > 125
Autrement dit, 5 au cube, ou 5 × 5 × 5, est égal à 125.

ECMAScript 7 est la prochaine version de JavaScript, en principe, nous pouvons utiliser le nouvel opérateur d'exponentiation proposé - * *, cette forme d'écriture peut être plus descriptive :

3 ** 2 > 9
Sur ce moment la prise en charge de cet opérateur est plutôt limitée, son utilisation n'est donc pas recommandée.

La fonction d'alimentation peut être utile dans une variété de situations. Un exemple simple, calculant le nombre de secondes dans une heure : Math.pow(60,2).

Racine carrée et cubique

Math.sqrt() et Math.cbrt() sont l'opposé de Math.pow(). Comme on s'en souvient, la racine carrée de a est le nombre qui donne a au carré.

Math.sqrt(9) > 3
En même temps, la racine cubique de a est le nombre qui donne a au cube.

Math.cbrt(125) > 5
Math.cbrt() a été introduit très récemment dans la spécification JavaScript et n'est donc supporté que par les navigateurs modernes : Chrome 38+, Firefox et Opera 25+ et Safari 7.1+. Vous remarquerez que Internet Explorer n'est pas sur cette liste, cependant vous pouvez trouver un polyfill sur MDN.

Exemples

Bien sûr, nous pouvons également utiliser des valeurs non entières dans l'une de ces fonctions :

Math.pow(1.25, 2); > 1.5625 Math.cbrt(56.57) > 3.8387991760286138
Notez que cela fonctionne aussi bien lorsque vous utilisez des valeurs d'argument négatives :

Math.pow(-5,2) > 25 Math.pow(10,-2) > 0.01
Cependant, pour la racine carrée, cela ne fonctionnera pas :

Math.sqrt(-9) > NaN
De l'analyse mathématique, nous savons que le nombre imaginaire est compris comme les racines carrées des nombres négatifs. Et cela pourrait nous conduire à une autre technique des nombres complexes, mais c'est une autre histoire.

Vous pouvez utiliser des valeurs fractionnaires dans Math.pow() pour trouver les racines carrées et cubiques des nombres. La racine carrée utilise un exposant de 0,5 :

Math.pow(5, 0.5); // = Math.sqrt(5) = 5 ** (1/2) > 2.23606797749979
Cependant, en raison des aléas de la virgule flottante, vous ne pouvez pas exactement deviner le résultat correct :

Math.pow(2.23606797749979.2) > 5.000000000000001
Dans de telles situations, vous devrez recourir à la suppression des signes du nombre ou à l'arrondi à une certaine valeur.

Certains, inexplicablement en JavaScript, confondent la fonction Math.pow() avec Math.exp() , qui est une fonction exponentielle pour les nombres en général. Remarque : en anglais, « exposant » est traduit par « exposant », c'est donc plus pertinent pour les anglophones, bien qu'il existe des noms alternatifs pour l'exposant, tels que index, puissance.

Constantes mathématiques

Travailler avec les mathématiques en JavaScript est facilité par un certain nombre de constantes intégrées. Ces constantes sont des propriétés de l'objet Math. Il convient de noter que les constantes sont écrites en majuscules et non en notation CamelCase.

Math.abs, parseInt, parseFloat

Travailler avec des nombres en JavaScript peut être beaucoup plus compliqué que vous ne le pensez. Les valeurs obtenues ne se situent pas toujours dans les plages attendues, parfois le résultat peut ne pas être du tout ce que nous attendions.

Math.abs()

La méthode Math.abs() renvoie la valeur absolue d'un nombre, ce qui nous rappelle l'analogue mathématique modulo une fonction.

Soit newVal = -57.64 ; Math.abs(newVal); > 57,64
Math.abs(0) renvoie toujours zéro, mais si nous mettons un signe moins devant la fonction -Math.abs(NUM), nous aurons toujours une valeur négative.

Math.abs(0); > -0

parseInt()

Nous savons que JavaScript comprend que "15" est une chaîne, pas un nombre, et, par exemple, lors de l'analyse de propriétés CSS à l'aide de JavaScript ou de l'obtention d'une valeur à partir d'un tableau non préparé, nos résultats peuvent s'avérer imprévisibles. Nous pourrions obtenir une chaîne représentée par "17px" en entrée, et ce n'est pas rare pour nous. La question est de savoir comment convertir cette chaîne en valeur réelle et l'utiliser dans d'autres calculs.

Syntaxe : parseInt(string, radix);

La fonction parseInt convertit le premier argument qui lui est transmis en un type de chaîne, l'interprète et renvoie une valeur entière ou NaN. Le résultat (s'il n'est pas NaN) est un entier et est le premier argument (chaîne) traité comme un nombre dans le système de nombres spécifié (base). Par exemple, la base 10 indique la conversion à partir du décimal, 8 à partir de l'octal, 16 à partir de l'hexadécimal, etc. Si la base est supérieure à 10, les lettres sont utilisées pour désigner les nombres supérieurs à 9. Par exemple, les nombres hexadécimaux (base 16) utilisent les lettres A à F.

Prenons un exemple de travail avec des propriétés CSS, où, relativement parlant, nous pouvons obtenir la valeur suivante :

Soit elem = document.body ; laissez centerPoint = window.getComputedStyle(elem).transformOrigin; > "454px 2087.19px"
On peut séparer les valeurs par des espaces :

Soit centres = centerPoint.split(" "); > ["454px", "2087.19px"]
Cependant, chaque élément est toujours une chaîne, nous pouvons nous en débarrasser en utilisant notre fonction :

Soit centerX = parseInt(centers, 10); > 454 let centerY = parseInt(centers, 10); > 2087
Comme vous pouvez le voir, comme deuxième argument, nous spécifions le système de numération dans lequel le nombre sera converti, ce paramètre est facultatif, mais il est recommandé de l'utiliser si vous ne savez pas quelle chaîne sera entrée.

parseFloat()

Dans l'exemple ci-dessus, vous avez peut-être remarqué que parseInt supprime la partie fractionnaire. Dans notre cas, parseFloat peut fonctionner avec des nombres à virgule flottante. Encore une fois, cela peut être utile dans l'analyse CSS et d'autres tâches, en particulier lorsqu'il s'agit de pourcentages en virgule flottante.

Syntaxe : parseFloat(chaîne)

LetFP = "33.33333%" ; console.log(parseFloat(FP)); > 33.33333
Notez qu'il n'y a pas de deuxième argument dans la syntaxe parseFloat.

Nous comprenons que parseInt() et parseFloat() sont extrêmement fonctionnalités utiles, il est important de garder à l'esprit qu'il y a forcément des erreurs, vous devez donc vérifier la plage des valeurs attendues et éventuellement analyser le résultat pour vous assurer que les valeurs que vous obtenez sont correctes.
Envoyer anonymement

Arrondi mathématique JavaScript à deux décimales (9)

J'ai la syntaxe JavaScript suivante :

Vardiscount = Math.round(100 - (prix / prix catalogue) * 100);

Ceci arrondit à un nombre entier. Comment puis-je renvoyer un résultat avec deux décimales ?

Voici un exemple de travail

varvalue=200.2365455 ; result=Math.round(value*100)/100 //le résultat sera 200.24

Pour gérer l'arrondi à n'importe quel nombre de décimales, une fonction avec 2 lignes de code suffira pour la plupart des besoins. Voici un exemple de code pour le jeu.

var testNum = 134,9567654 ; var décPL = 2 ; var testRes = roundDec(testNum,decPl); alert (testNum + " arrondi à " + decPl + " les décimales sont " + testRes); function roundDec(nbr,dec_places)( var mult = Math.pow(10,dec_places); return Math.round(nbr * mult) / mult; )

La solution la meilleure et la plus simple que j'ai trouvée est

Function round(value, decimals) ( return Number(Math.round(value+"e"+decimals)+"e-"+decimals); ) round(1.005, 2); // 1.01

Une légère variation sur la réponse acceptée. toFixed(2) renvoie une chaîne et vous obtiendrez toujours deux décimales. Il peut être nul. Si vous souhaitez supprimer les null(s) à la fin, procédez comme suit :

Var remise = + ((prix / prix catalogue).toFixed(2));

Edité : Je viens de découvrir ce qui semble être un bogue dans Firefox 35.0.1, ce qui signifie que ce qui précède pourrait donner à NaN certaines valeurs.
j'ai changé mon code en

Vardiscount = Math.round(price / listprice * 100) / 100 ;

Cela donne un nombre avec une précision de deux décimales. Si vous avez besoin de trois, vous multiplierez et diviserez par 1000, et ainsi de suite.
OP veut toujours deux décimales, mais si toFixed() est cassé dans Firefox, il faut d'abord le réparer.
Voir https://bugzilla.mozilla.org/show_bug.cgi?id=1134388

Pour obtenir le résultat avec 2 décimales, vous pouvez procéder comme suit :

Vardiscount = Math.round((100 - (prix / prix catalogue) * 100) * 100) / 100 ;

La valeur à arrondir est multipliée par 100 pour conserver les deux premiers chiffres, puis on divise par 100 pour obtenir le résultat réel.

je pense que La meilleure façon Celui que j'ai vu est multiplié par 10 par le nombre de chiffres, puis faites Math.round, puis enfin divisez par 10 par le nombre de chiffres. Ici fonction simple, que j'utilise en tapuscrit :

Function roundToXDigits(value : nombre, chiffres : nombre) ( value = value * Math.pow(10, digits); value = Math.round(value); value = value / Math.pow(10, digits); return value; )

Ou javascript simple :

Fonction roundToXDigits(value, digits) ( if(!digits)( digits = 2; ) value = value * Math.pow(10, digits); value = Math.round(value); value = value / Math.pow(10 , chiffres); valeur de retour; )

NOTE. - Voir Edit 4 si la précision à 3 chiffres est importante.

Vardiscount = (prix / prix catalogue).toFixed(2);

toFixed arrondit vers le haut ou vers le bas pour vous en fonction des valeurs supérieures à 2 décimales.

Changement. Comme mentionné par d'autres, cela convertira le résultat en une chaîne. Pour éviter cela:

Vardiscount = +((prix / prix catalogue).toFixed(2));

Modifier 2- Comme mentionné dans les commentaires, cette fonction ne s'exécute pas avec une certaine précision, par exemple dans le cas de 1.005, elle renverra 1.00 au lieu de 1.01. Si la précision est si importante, j'ai trouvé cette réponse : https://.com/a/32605063/1726511 qui semble bien fonctionner avec tous les tests que j'ai essayés.

Une modification mineure est nécessaire, mais la fonction dans la réponse ci-dessus renvoie des nombres entiers lorsqu'elle arrondit à un, donc par exemple 99.004 renverra 99 au lieu de 99.00, ce qui n'est pas idéal pour afficher les prix.

Modifier 3- Il semble que toFixed sur le retour STILL réel bousillait certains chiffres, cette édition finale semble fonctionner. Bon sang tant de réparations !

Vardiscount = roundTo((price / listprice), 2); function roundTo(n, digits) ( if (digits === undefined) ( digits = 0; ) var multiplicator = Math.pow(10, digits); n = parseFloat((n * multiplicator).toFixed(11)); var test =(Math.round(n) / multiplicateur); return +(test.toFixed(digits)); )

Modifier 4- Vous me tuez. L'édition 3 échoue sur les nombres négatifs sans creuser pourquoi il est plus facile de simplement rendre un nombre négatif positif avant de faire l'arrondi, puis de le rejeter avant de renvoyer le résultat.

Fonction roundTo(n, chiffres) ( var négatif = faux ; si (chiffres === indéfini) ( chiffres = 0 ; ) si(n< 0) { negative = true; n = n * -1; } var multiplicator = Math.pow(10, digits); n = parseFloat((n * multiplicator).toFixed(11)); n = (Math.round(n) / multiplicator).toFixed(2); if(negative) { n = (n * -1).toFixed(2); } return n; }

Le moyen le plus rapide- plus rapide que toFixed() :

DEUX DÉCALYLES

x = .123456 résultat = Math.round(x * 100) / 100 // résultat .12

TROIS DÉCIMALES

x = .123456 résultat = Math.round(x * 1000) / 1000 // résultat .123

Function round(num,dec) ( num = Math.round(num+"e"+dec) return Number(num+"e-"+dec) ) //Arrondi à la décimale de votre choix : round(1.3453,2)

Bonjour les amateurs de JavaScript. Vous avez déjà remarqué que cette langue est très extraordinaire et se distingue dans chaque section avec ses propres caractéristiques et inhabituelles solutions techniques. Par conséquent, la publication d'aujourd'hui est consacrée au sujet : "Arrondi JavaScript".

Après avoir lu l'article actuel, vous découvrirez pourquoi il est nécessaire d'arrondir les nombres, quelles méthodes et propriétés en js remplissent cette fonction, et ce qui distingue la division par 0. Sans changer mes principes, je joindrai des exemples aux points clés de la matériel et décrire chaque action en détail. Commençons maintenant à apprendre !

Remarques importantes sur les nombres

Tout d'abord, rappelez-vous que dans js toutes sortes de nombres (fractionnaires et entiers) sont de type nombre. De plus, ils sont tous en 64 bits, car ils sont stockés au format « double précision », également connu sous le nom de norme IEEE-754.

Les variables numériques sont créées de la manière habituelle :

var engourdi = 35 ; // entier naturel

vardrob = 0,93 ; //représentation décimale

var numb16 = 0xFF ; //système de numération hexadécimal

Prend également en charge d'autres représentations numériques. Ainsi, vous pouvez toujours créer des nombres à virgule flottante (ils sont parfois appelés "nombres au format scientifique").

Ajout du support pour une méthode très intéressante toLocaleString(), qui formate tous les paramètres numériques selon les spécifications prescrites dans ECMA 402. De ce fait, les grands nombres, les numéros de téléphone, les devises et même les pourcentages sont bien affichés dans la boîte de dialogue.

varnum = 714000,80 ;

alert(num.toLocaleString());

Pour travailler avec des éléments de type Number, un objet global entier a été fourni avec un tas de divers fonctions mathématiques, dont le nom Mathématiques.

De plus, il existe d'autres méthodes qui arrondissent les valeurs numériques à des nombres entiers, aux dixièmes, centièmes, etc. Considérons-les tous plus en détail.

Grand et puissant Math

L'objet Math global comprend une grande variété de fonctions mathématiques et trigonométriques. C'est un objet très nécessaire et aide souvent les développeurs lorsqu'ils travaillent avec des données numériques.

Sur d'autres plates-formes, il existe des analogies avec Math. Par exemple, dans les langages populaires tels que Java et C#, Math est une classe qui prend en charge toutes les mêmes fonctions standard. Donc, comme vous pouvez le voir, cet outil est vraiment génial et puissant.

Maintenant, je veux passer en revue les méthodes d'arrondi spécifiques et en parler en détail.

Math.étage()

je vais commencer par Mathématiques.sol. Faites attention au nom de la méthode. Logiquement, il devient clair que nous parlonsà propos de l'arrondi, et la traduction littérale du mot "plancher" signifie "plancher", alors cet outil arrondira les valeurs traitées vers le bas.

Il est également possible que le nombre traité à l'aide de cette fonction reste le même. En effet, les arrondis sont effectués selon une inégalité non stricte (<=). Таким образом, при отработке этой строчки кода:

alert(Math.plancher(4.5));

la réponse sera le numéro 4.

Math. plafond()

Encore une fois, regardez le titre (de cette façon, le matériau est absorbé plus rapidement). Si quelqu'un ne sait pas, alors "ceil" signifie "plafond". Cela signifie que les données numériques seront arrondies à l'aide d'une inégalité non stricte (>=).

alert(Math.ceil(4.5));

Comme vous l'avez peut-être deviné, la réponse sera le chiffre 5.

tour de maths()

Cette méthode arrondit un nombre fractionnaire à l'entier le plus proche. Ainsi, si la partie fractionnaire est comprise entre 0 et 0,5 inclus, l'arrondi se produit à une valeur inférieure. Et si la partie fractionnaire est comprise entre 0,5 inclus et l'entier suivant, elle est arrondie à un entier supérieur.

alert(Math.round(4.5));

J'espère que tout le monde a pensé ou dit que la bonne réponse est 5.

Quelques méthodes supplémentaires

JavaScript a également 2 autres méthodes qui traitent des représentations numériques arrondies. Cependant, ils sont quelque peu différents.

On parle d'outils tels que toFixed() Et toPrecision(). Ils sont responsables non seulement de l'arrondi, mais de sa précision par rapport à certains signes. Creusons plus profondément.

toFixed()

À l'aide de ce mécanisme, vous pouvez spécifier le nombre de décimales auxquelles la valeur doit être arrondie. La méthode renvoie le résultat sous forme de chaîne. Ci-dessous, j'ai joint une variante avec trois différentes options. Analysez les réponses reçues.

varnum = 5656,9393 ;

document.writeln(num.toFixed()); // 5657

document.writeln(num.toFixed(2)); // 5656.94

document.writeln(num.toFixed(7)); // 5656.9393000

Comme vous pouvez le voir, si vous ne spécifiez pas d'argument, alors toFixed ()) arrondira la valeur fractionnaire à l'ensemble Nombres. La troisième ligne est arrondie jusqu'à 2 caractères, et dans le quatrième, trois autres 0 ont été ajoutés à cause du paramètre "7".

toPrecision()

Cette méthode fonctionne un peu différemment. À la place de l'argument, vous pouvez laisser un espace vide et définir un paramètre. Cependant, ce dernier arrondira les nombres au nombre de chiffres spécifié, quelle que soit la virgule. Voici les résultats du programme réécrit à partir de l'exemple précédent :

varnum = 5656,9393 ;

document.writeln(num.toPrecision()); // 5656.9393

document.writeln(num.toPrecision(2)); // 5.7e+3

document.writeln(num.toPrecision(7)); // 5656.939

La fonction de division par 0 en js

Comme vous le savez depuis les cours de mathématiques, vous ne pouvez pas diviser par zéro. Cette règle a été prise comme base par la plupart des créateurs de langages de programmation. Par conséquent, lors de la division par zéro, tous les programmes produisent une erreur.

Cependant, JavaScript excellait également ici. Ainsi, lors de l'exécution d'une telle opération, aucun rapport de bug ne se produit... car une telle opération renvoie "Infini"!

Pourquoi donc? Comme on le sait dans les mêmes sciences mathématiques, plus le diviseur est petit, plus le résultat est plus. C'est pourquoi les créateurs de ce langage basé sur des prototypes ont décidé d'abandonner les modèles et de suivre leur propre chemin.

Pour ceux qui sont nouveaux dans la signification de l'Infini, j'ai expliqué ses caractéristiques ci-dessous.

Infini - signifie infini et correspond pleinement au signe mathématique ∞.

Peut être négatif. Toutes les règles standard pour travailler avec les opérateurs arithmétiques sont également conservées.

alerte(12/0); // Infini

alerte(12.34/0); // Infini

alerte(-3/0); // -Infini

Là-dessus, peut-être, je terminerai. Si vous avez aimé le post, assurez-vous de vous abonner à mon blog. N'hésitez pas à créer des liens vers des articles intéressants et à les partager avec vos amis. Bye Bye!