Méthodes arrondies dans JavaScript. Règles d'arrondi simples en JavaScript. Nous étudions les méthodes et appliquerons dans la pratique Paysfloat JavaScript 2 signe décimal

Javascript-mathématiques, arrondir jusqu'à deux décimales (9)

J'ai la syntaxe JavaScript suivante:

VAR Discount \u003d Math.Round (100 - (prix / listprice) * 100);

Ceci est arrondi à un entier. Comment puis-je retourner le résultat avec deux signes décimaux?

Voici un exemple de travail

Valeur var \u003d 200.2365455; Résultat \u003d Math.Round (valeur * 100) / 100 // résultat sera 200.24

Pour le traitement de l'arrondissement à un certain nombre de décimales pour la plupart des besoins, il y aura suffisamment de fonction avec 2 lignes de code. Voici un exemple de code pour le jeu.

Var testnum \u003d 134.9567654; Var décpl \u003d 2; Var TestRes \u003d RoundDec (Testnum, Décpl); Alerte (testnum + "arrondi sur" + décimal + "décimal est" + TESTRES); Fonction RoundDec (NBR, Dec_places) (var mul \u003d math.pow (10, déc_places); renvoyer math.round (NBR * MUT) / MULT;)

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

Fonction ronde (numéro de retour (Math.Round (Value + E »+ Décimales) +« E - »+ Décimales);) rond (1.005, 2); // 1.01

Petite variation de la réponse acceptée. Tofixed (2) renvoie la chaîne et vous obtiendrez toujours deux signes décimaux. Ça peut être des zéros. Si vous voulez supprimer le ou les derniers zéro (s), faites-le simplement:

Remise VAR \u003d + ((prix / listprice) .tofixed (2));

Edité: Je viens de constater que cela semble une erreur dans Firefox 35.0.1, ce qui signifie que ce qui précède peut donner des valeurs de Nan.
J'ai changé mon code sur

VAR Discount \u003d Math.Round (prix / listprice * 100) / 100;

Cela donne un numéro avec une précision de deux décimales. Si vous en avez besoin trois, vous vous multipliez et divisez 1000, et ainsi de suite.
OP veut toujours deux décharges décimales, mais si Tofixed () est cassé dans Firefox, vous devez d'abord le réparer.
Voir https://bugzilla.mozilla.org/show_bug.cgi?id\u003d1134388.

Pour obtenir un résultat avec deux signes décimaux, vous pouvez procéder comme suit:

VAR Discount \u003d Math.Round (((100 - (prix / listprice) * 100) * 100) / 100;

La valeur qui doit être arrondie est multipliée par 100 pour enregistrer les deux premiers chiffres, puis nous divisons à 100 pour obtenir le résultat réel.

Je pense que la meilleure façon de voir est multipliée par 10 par nombre de nombres, puis faites de maths, puis divisez enfin 10 par nombre de chiffres. Voici une fonction simple que j'utilise dans des textes dactylographiés:

Fonction RoundToxDigits (valeur: Nombre, chiffres: numéro) (valeur \u003d valeur * math.pow (10, chiffres); valeur \u003d maths.round (valeur); valeur \u003d valeur / maths.pow (10, chiffres); valeur de retour; )

Ou simple JavaScript:

Fonction RoundToxDigits (valeur, chiffres) (si (! Chiffres) (chiffres \u003d 2;) valeur \u003d valeur * math.pow (10, chiffres); valeur \u003d maths.round (valeur); valeur \u003d valeur / maths.pow (10 , chiffres); valeur de retour;)

REMARQUE. - Voir Edition 4 si une précision à 3 chiffres est importante.

Remise VAR \u003d (prix / listprice) .tofixed (2);

tOFIXED est arrondi ou en bas pour vous en fonction des valeurs supérieures à 2 signes décimaux.

Changer. Comme mentionné par d'autres, il convertit le résultat dans la chaîne. Pour éviter cela:

Remise VAR \u003d + ((prix / listprice) .tofixed (2));

Modification 2. - Comme mentionné dans les commentaires, cette fonction n'est pas effectuée avec une certaine précision, par exemple, dans le cas de 1,005, elle retournera 1,00 au lieu de 1,01. Si la précision est importante pour une telle mesure, j'ai trouvé cette réponse: https: //.com/a/32605063/1726511 Qu'est-ce qui semble fonctionner bien avec tous les tests que j'ai essayés.

Une modification mineure nécessite, mais la réponse indiquée ci-dessus renvoie des nombres entiers lorsqu'il est arrondi, par exemple, 99,004 reviendra 99 au lieu de 99,00, ce qui n'est pas parfait pour l'affichage des prix.

Éditer 3. - Il semble que TOFIXED sur le retour réel des nombres toujours tordus, c'est la dernière modification semble fonctionner. Geez tant de réparations!

Var Remise \u003d Roundto ((prix / listprice), 2); Fonction rond de (n, chiffres) (si (chiffres \u003d\u003d\u003d non définis) (chiffres \u003d 0;) var multiplicateur \u003d math.pow (10, chiffres); n \u003d parsefloat ((N * multiplicateur) .tofixed (11)); test var \u003d (maths.round (n) / multiplicateur); retour + (test.tofixed (chiffres));)

Éditer 4. "Vous me tuez." Modifier 3 échoue sur des nombres négatifs, sans creuser pourquoi il est plus facile de simplement faire un nombre négatif positif avant de faire arrondi, puis de le retourner avant de renvoyer le résultat.

Fonction rond sur (n, chiffres) (var négatif \u003d faux; si (chiffres \u003d\u003d\u003d non définis) (chiffres \u003d 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 toofixed ():

Deux décaliles

x \u003d .123456 résultat \u003d math.round (x * 100) / 100 // résultat .12

Trois décimalités

x \u003d .123456 résultat \u003d math.round (x * 1000) / 1000 // résultat .123

Fonction rond (num, déc) (Num \u003d Math.Round (num + e "+ déc) Numéro de retour (Num +" E - "+ déc)) // Tour à une décimale de votre choix: rond (1.3453.2)

Dans cet article, envisagez de détailler les chiffres, les opérateurs mathématiques, les méthodes de transformation du nombre dans la chaîne et inversement, ainsi que de nombreux autres points importants.

Fonction isminite

La fonction Iscinite vous permet de vérifier si l'argument est un nombre fini.

En réponse, cette fonction renvoie false si l'argument est l'infini, -infinity, NaN ou sera montré à l'une de ces valeurs numériques spéciales. Sinon, cette fonction retournera la valeur de vrai.

Isminite (73); // vrai isminite (-1/0); // faux isminite (infini); // faux isminite (NAN); // fausse isminite ("texte"); // Faux

En plus de la fonction Global Iscinite dans JavaScript, il existe une autre méthode. Contrairement à l'isminite, il n'effectue pas l'argument forcé au nombre.

Isminite ("73"); // TRUE NUMBER.FINITE ("73"); // Faux

Fonctionnalité isnan

La fonction ISNAN est conçue pour déterminer si l'argument est un nombre ou peut être transformé en elle. Si tel est le cas, la fonction ISNAN renvoie false. Sinon, cela revient vrai.

Isnan (nan); // vrai isnan ("25px"); // vrai, parce que 20px n'est pas un numéro isnan (25.5); // faux isnan ("25.5"); // faux isnan (""); // faux, parce que L'espace ou non seulement les espaces sont convertis en 0 isnan (NULL); // faux, parce que La valeur null est convertie à 0 isnan (vrai); // faux, parce que La vraie valeur est convertie en 1 isnan (faux); // faux, parce que La fausse valeur est convertie en 0

Si cette action doit être effectuée sans apporter le type, utilisez la méthode Number.isnan. Cette méthode a été introduite dans la langue, en commençant par ECMAScript 6.

Comment convertir explicitement une ligne au nombre?

Il est clairement apporté par une ligne au nombre de la manière suivante:

1. Utiliser opérateur unitaire +.qui doit être placé avant la valeur.

+ "7.35"; // 7.35 + "Texte"; // nan.

Cette méthode néglige les espaces au début et à la fin de la chaîne, ainsi que \\ n (traduction en ligne).

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

En utilisant cette méthode, il est nécessaire de faire attention au fait qu'une chaîne vide ou une chaîne constituée d'espaces et \\ n est traduite dans le nombre 0. De plus, elle convertit également le type de données NULL et les valeurs logiques à la numéro.

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

2. Fonction parseint. Cette fonctionnalité est destinée à la conversion. argument pour un entier. Contrairement à l'utilisation opérateur unitaire +., cette méthode vous permet de convertir une chaîne en un numéro dans lequel tous les caractères ne sont pas numériques. Il commence à convertir la chaîne à partir du premier symbole. Et dès qu'il rencontre un symbole qui n'est pas numérique, cette fonctionnalité arrête son fonctionnement et renvoie le nombre résultant.

Parseint ("18px"); // 18 parseint ("33,3%"); // 33.

Cette fonctionnalité peut fonctionner avec différents systèmes de nombres (binaire, octal, décimal, hexadécimal). Remarque La base du système numérique est effectuée 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 Paysint en JavaScript, il existe une méthode Number.Parseint. Cette méthode n'est pas différente de la fonction Paysint et a été introduite dans JavaScript avec la spécification Ecmascript 2015 (6).

3. Fonction parsefloat. La fonction Paysfloat est similaire à Paysint, à l'exception de la transformation de l'argument en nombre fractionnaire.

Parsefloat ("33,3%"); //33.3.

De plus, la fonction Paysfloat, contrairement à Paysint, n'a pas 2 arguments, et il essaie donc toujours de considérer la chaîne comme un nombre dans le système de nombres décimaux.

Parsefloat ("3.14"); Parsefloat ("314e-2"); Parsefloat ("0.0314e + 2");

En plus de la fonction Paysfloat en JavaScript, il existe une méthode Number.Parsefloat. Cette méthode n'est pas différente de la fonction Paysfloat et a été introduite dans JavaScript avec la spécification Ecmascript 2015 (6).

Transformation du nombre dans la chaîne

Vous pouvez activer le numéro dans la chaîne à l'aide de la méthode de totring.

(12.8) .Tostring (); //"12.8 "

La méthode de tostring vous permet également de spécifier la base du système de numéros avec lequel il est nécessaire d'apporter explicitement le numéro à la ligne:

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

Comment vérifier si un numéro de variable

Pour déterminer si la variable de valeur peut être variable à l'aide de l'une des méthodes suivantes:

1. Utilisation des fonctions ISNAN et ISFINITE:

// myvar - variable si (! Isnan (parsefloat (myvar)) && isminite (parsefloat (myvar)) (// myvar est un nombre ou peut lui être donné);

Sous la forme d'une fonction:

// fonction isnumeric (retour! Isnan (parsefloat (valeur)) && isminite (parsefloat (valeur));) // à l'aide de var myvar \u003d "12px"; Console.log (isnumeric (myvar)); // Vrai.

Cette méthode vous permet de déterminer si la valeur spécifiée est ou peut lui être donnée. Cette option ne considère pas une chaîne vide, une chaîne d'espaces, une valeur nulle, une infini, de l'ininité, true et false.

2. Utiliser le type d'opérateur et des fonctions islamique, ISNAN:

// une fonction qui vérifie si la valeur est le numéro de fonction iSnumber (valeur) (type de valeur de valeur \u003d\u003d\u003d "(! Lang: Number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Cette fonctionnalité détermine si la valeur spécifiée est le type de numéro et si elle n'appartient pas à l'une des valeurs spéciales Infinity, -INFINITY et NAN. Esley est tellement, alors cette fonction revient vrai.

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

Numéro.isInteger ("20"); // faux, parce que Cette méthode ne traduit pas la chaîne au nombre de chiffres.IsInteger (20); // vrai, parce que Cette valeur est le nombre

Nombre pair et impair

Vérifiez si le numéro est utilisé ou étrange par les fonctions suivantes:

// Fonction pour vérifier le numéro à lire la fonction ISEven (N) (retour N% 2 \u003d\u003d 0;) // Fonction pour vérifier le numéro à la fonction d'infirme ISODD (n) (N) (N% 2) \u003d\u003d 1;)

Mais avant de procéder à un tel chèque, il est conseillé de s'assurer que la valeur spécifiée est le nombre:

Valeur \u003d 20; Si (Numéro.ISInteger (valeur)) (ifeven (valeur (valeur)) (console.log ("numéro" + valeur.tostring () + "- mince");)););););

Numéros simples en JavaScript

Considérons un exemple dans lequel les nombres simples de 2 à 100 avec JavaScript sont supprimés.

// Fonction qui vérifie si le nombre est une fonction simple isprime (valeur) (si (ISNAN (valeur) ||! Isminke (valeur) || Valeur% 1 || Valeur< 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);

Numéro d'arrondi dans JavaScript

Tour d'un numéro fractionnaire à la valeur entière de JavaScript de différentes manières.

1. Utilisation des méthodes Math.Floor, Math.Ceuil et Math.Round Spécialement conçus pour cela. Math.Floor Methethy ronde nombre de fractionnements au verso le plus proche, c'est-à-dire Simplement jeter la partie fractionnée. Math.Ceuil se boucle un nombre fractionnaire au tout le plus proche. Math.Round arrondit le numéro vers le haut ou le bas en fonction de la valeur de la partie fractionnée. Si la partie fractionnée est supérieure ou égale à 0,5, alors augmente, sinon la peaufine est effectuée.

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

2. Utilisation de la méthode TOFIXED. Cette méthode arrondit la partie fractionnée du nombre à une précision donnée. Le résultat de l'arrondi retourne comme une chaîne.

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

Si les signes après la virgule pour la formation de la précision spécifiée du nombre de numéros manquent, il est complété par les zéros.

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

3. Par la méthode de toprecision. Cette méthode représente un nombre avec la précision indiquée. Dans le même temps, il peut arrondir non seulement des fractions, mais aussi une partie du nombre. Le numéro obtenu, cette méthode peut être représentée en fonction du résultat avec une virgule fixe ou sous forme exponentielle.

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

4. Utiliser des opérateurs logiques non ou ou.

// par double console de déni logique.log (~~ 7.9); // 7 // à travers l'utilisation de logique ou avec zéro: console.log (7,9 ^ 0); // 7.

Partie entière et fractionnelle du nombre

Vous pouvez obtenir une partie intégrante du numéro à l'aide de la méthode Math.Floor () et Paysint ():

Console.log (math.floor (7.21)); // 7 console.log (parseint (7.21)); // 7.

Vous pouvez obtenir une partie fractionnée du numéro que vous pouvez utiliser l'opérateur de pourcentage (%). Cet opérateur renvoie le résidu qui sera obtenu de diviser le premier numéro à la seconde. Dans ce cas, il est nécessaire d'utiliser 1 comme 2 chiffres.

Console.log (7,21% 1); // 0.209999999999999996 // avec une précision de 2 caractères après la console de semi-fluide.Log ((7,21% 1) .tofixed (2)); // "0.21"

De plus, la partie fractionnée peut également être obtenue en calculant:

Nombre de var \u003d 7.21; var fractionnumber \u003d nombre - math.floor (math.abs (numéro)); Console.log (fractionNumber); // 0.209999999999999996.

Si le nombre est divisé par

Pour déterminer si le nombre d'objectifs peut être trouvé à l'aide de l'opérateur pour cent:

Nombre de var \u003d 9; // Si le résidu de la division du numéro de numéro 3 est 0, alors oui, sinon il n'y a pas non si (numéro% 3 \u003d\u003d 0) (Console.log ("numéro" + numéro + "est divisé en 3" );) D'autre (console. Journal ("Le numéro" + numéro + "n'est pas divisé en 3");)

Numéros de formatage

Dans JavaScript, formatez la sortie de sortie conformément aux normes régionales (paramètres de langage du système d'exploitation) permet la méthode Tolocalestring ().

Par exemple, effectuez la mise en forme du numéro conformément aux normes régionales installées dans le système par défaut:

Numéro de var \u003d 345.46; Console.log (numéro.tolocalestring ()); // "345.46"

Par exemple, nous effectuerons la mise en forme du 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 sous la forme d'une devise:

Console.log ((2540.125) .tolocalestring ("ru-ru" (style: "monnaie", monnaie: "frotter"))); // "2 540,13 ₽" console.log (((89.3) .tolocalestring ("Ru-ru" (style: "monnaie", monnaie: "USD"))); // "89,30 $" console.log (((2301.99) .tolocalestring ("Ru-ru" (style: "monnaie", monnaie: "EUR"))); // "2 301,99 €"

Pose d'intérêt pour la forme d'intérêt:

Console.log ((0.45) .tolocaletring ("Ru-ru", (style: "Pourcentage"))); // "45%"

Éliminez le nombre sur la décharge (Propriété d'utilisationGrouping):

Console.log (((125452.32) .tolocalestring ("ru-ru", (UsageGrouping: True))); // "125 452,32"

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

Console.log (((1240.4564) .tolocalestring ("ru-ru" (minimumfractionDigits: 2, maximumfractionDigits: 2)); // "1 240.46"

Comparaison des nombres

Pour comparer les numéros en JavaScript, les opérateurs suivants sont utilisés: \u003d\u003d (égal),! \u003d (Non égal),\u003e (plus),< (меньше), >\u003d (plus ou égal),<= (меньше или равно).

Par exemple, nous comparons deux nombres:

Console.log (2\u003e 3); // fausse console.log (5\u003e \u003d 3); // Vrai.

Lors de la comparaison de nombres avec une partie fractionnée, 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) \u003d\u003d 0,6); // Faux

Les erreurs se produisent car tous les calculs de l'ordinateur ou d'autres périphériques électroniques produisent dans 2 numéros. Ceux. Avant d'effectuer certaines actions, l'ordinateur doit d'abord convertir le nombre dans l'expression dans 2 du système de numéros. Mais aucun nombre décimal fractionnaire ne peut être représenté dans un système de 2 numéros à coup sûr.

Par exemple, le nombre 0.25 10 au système binaire est converti avec précision.

0,125 × 2 \u003d 0,25 | 0 0,25 × 2 \u003d 0.5 | 0 0.5 × 2 \u003d 1 | 1 0.125 10 \u003d 0,001 2

Par exemple, le nombre 0.2 10 peut être converti en 2 système uniquement avec une précision définie:

0,2 × 2 \u003d 0,4 | 0 0,4 × 2 \u003d 0,8 | 0 0,8 × 2 \u003d 1.6 | 1 0,6 × 2 \u003d 1.2 | 1 0,2 × 2 \u003d 0,4 | 0 0,4 × 2 \u003d 0,8 | 0 0,8 × 2 \u003d 1.6 | 1 0,6 × 2 \u003d 1.2 | 1 0,2 × 2 \u003d 0,4 | 0 0,4 × 2 \u003d 0,8 | 0 0,8 × 2 \u003d 1.6 | 1 0,6 × 2 \u003d 1.2 | 1 ... 0.2 10 \u003d 0.001100110011 ... 2

En conséquence, ces erreurs affecteront le calcul de la somme de deux chiffres et des résultats de comparaison. Ceux. Il s'avère que réellement JavaScript sera vu cette entrée comme suit:

0.6000000000000001==0.6

Lors du calcul ou du mappage de numéros avec une partie fractionnée, vous devez toujours indiquer la précision avec laquelle elle doit être effectuée.

Par exemple, comparez les numéros jusqu'à 2 décimales utilisant des méthodes TOFIXED () et TOPRecision ():

// console de méthode toofixed ().log ((0,2 + 0,4) .tofixed (2) \u003d\u003d (0,6) .tofixed (2)); // véritable // toprecision () console de méthode.log ((0,2 + 0,4) .toprecision (2) \u003d\u003d (0,6) .Topision (2)); // Vrai.

Principales opérations mathématiques

Javascript existe les opérateurs mathématiques suivants: + (Ajout), - (Soustraction), * (multiplication), / (division),% (résidu de la division), ++ (zoomer sur 1), - (réduction de la valeur à 1).

6 + 3 // 9 6-3 // 3 6 * 3 // 18 6/3 // 2 6% 3 // 0, I.e. 6: 3 \u003d 2 \u003d\u003e 6-3 * 2 \u003d\u003e OST (0) 5% 2 // 1, I.e. 5: 2 \u003d 2 (.5) \u003d\u003e 5-2 * 2 \u003d\u003e OST (1) 7.3% 2 //1.3, I.e. 7.3: 2 \u003d 3 (0,65) \u003d\u003e 7.3-2 * 3 \u003d\u003e OST (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 , c'est à dire 9: 2.5 \u003d 3 (0,6) \u003d\u003e 9-2.5 * 3 \u003d\u003e OST (1,5) -9% -2.5 //-1.5, c'est-à-dire 9: 2.5 \u003d 3 (.6) \u003d\u003e 9-2.5 * 3 \u003d\u003e OST (1.5) -2% 5 // - 2, I.e. 2: 5 \u003d 0 (.4) \u003d\u003e 2-5 * 0 \u003d\u003e OST (2) x \u003d 3; Console.log (x ++); // affiche 3, déjà déjà définit 4 console.log (x); // 4 x \u003d 3; Console.log (++ x); // définit 4 et affiche x \u003d 5; Console.log (x--); // affiche 5, déjà définit 4 console.log (x); // 4 x \u003d 5; Console.log (- x); // définit 4 et affiche les opérateurs combinés en JavaScript en plus: x + \u003d y (x \u003d x + y), x- \u003d y (x \u003d xy), x * \u003d y (x \u003d x * y), x / \u003d y (x \u003d x / y), x% \u003d y (x \u003d x% y). x \u003d 3; y \u003d 6; x + \u003d y; Console.log (x); // 9 x \u003d 3; y \u003d 6; x- \u003d y; Console.log (x); // - 3 x \u003d 3; y \u003d 6; x * \u003d y; Console.log (x); // 18 x \u003d 3; y \u003d 6; x / \u003d y; Console.log (x); //0.5 x \u003d 3; y \u003d 6; x% \u003d y; Console.log (x); // 3.

Salut. Aujourd'hui, dans la colonne JavaScript, nous examinerons comment définir JavaScript le nombre de marches de la mer dans les numéros de points flottants. Par exemple, vous devez laisser 3 signe décimal lors de l'affichage, ou seulement deux.

Tâche: Nombre JavaScript de points-virgules

Nous sommes donc confrontés à la tâche: il y a un résultat de calculs dans lesquels il existe des chiffres avant les points-virgules et après la virgule. Décimal. Supposons que le résultat s'est avéré ce 1538.9891200153. Mais lorsque la sortie doit être le nombre reflétant le montant, où la quantité de billets de banque est à la hauteur de la virgule et après - kopecks.

Il existe plusieurs façons de résoudre cette tâche.

Solution 1: Nombre JavaScript de points-virgules avec la méthode Tofixed

tOFIXED est une méthode JavaScript intégrée à n'importe quel nombre, la précision adopte une arrondi de précision (c'est-à-dire le nombre de caractères de la navigation).

Var num \u003d 1538.9891200153; num_str \u003d num.tofixed (); // num_str \u003d 1538; num_str \u003d num.tofixed (2); //Num_str\u003d1538.98; num_str \u003d num.tofixed (5); //Num_str\u003d1538.98912;

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

Vous pouvez également faire sans variables, par exemple, comme celui-ci:

Num_str \u003d (1538.9891200153) .tofixed (2); //Num_str\u003d1538.98;

Solution 2: Nombre JavaScript de points-virgules avec la méthode de la toprecision

Cette solution est basée sur la même méthode JavaScript intégrée. Une caractéristique distinctive de cette méthode est que le paramètre pris à l'entrée indique non plus de précision (le nombre de points-virgules), mais le nombre total de caractères (à la fois à la virgule et après-vente).

Var num \u003d 1538.9891200153; num_str \u003d NUM.TOPOPISION (5); //Num_str\u003d1538.9; num_str \u003d NUM.TOPOPISION (7); //Num_str\u003d1538.989;

Solution sans signes après une virgule: Nombre JavaScript Nombre de points-virgules

Si les signes décimaux doivent être complètement pliés, c'est-à-dire qu'il est nécessaire de contourner le nombre de fractionnaires dans son ensemble, vous pouvez utiliser les fonctions des mathématiques: rond, plafond et plancher.
Rond - rondes d'un côté grand ou plus petit (selon le nombre). Si la valeur après la moitié des semi-jonces est supérieure à la moitié, alors tours sur tout le côté, s'il est moins petit. C'est-à-dire que 0,51 - sera 1, si 0,49 - 0.

CEIL - De l'anglais. Le plafond est toujours arrondi au plus gros côté.

Plancher - de l'anglais. Paul tourne toujours d'un côté plus petit.

Var num \u003d 1538.9891200153; num_str \u003d maths.Round (Num); // num_str \u003d 1539; num_str \u003d math.floor (num); // num_str \u003d 1538; num_str \u003d math.ceil (num); // num_str \u003d 1539;

C'est tout. J'espère que cette note vous a aidé à résoudre la tâche. Si quelque chose échouait - posez des questions à l'aide du bouton vert "Poser une question par un spécialiste", ou dans les commentaires.

Bonjour, Amants Javascript-A. Vous avez déjà remarqué que cette langue est très extraordinaire et dans chaque section se distingue par ses particularités et ses solutions techniques inhabituelles. Par conséquent, la publication d'aujourd'hui est dédiée au sujet: l'arrondi JavaScript.

Après avoir lu l'article actuel, vous découvrirez pourquoi il est nécessaire de contourner les chiffres, quelles méthodes et propriétés dans JS effectuent cette fonction, ainsi que la division de 0. sans changer vos principes, je vais joindre des exemples aux points clés de le matériau et écrivez chaque action en détail. Maintenant commençons à apprendre!

Notes importantes sur les nombres

Pour commencer, rappelez-vous que dans JS, toutes sortes de chiffres (fractionnaires et entier) font référence au type Nombre. De plus, tous sont 64 bits, car ils sont stockés dans le format "double précision", qui est également connu sous la norme IEEE-754.

Création de variables numériques de la manière habituelle:

var numb \u003d 35; // entier naturel

var drabb \u003d 0,93; // représentation décimale

var numb16 \u003d 0xFF; // Système 16-Richlery

Prend en charge d'autres vues numériques. Ainsi, vous pouvez également créer des chiffres avec un point flottant (ils sont parfois appelés «numéros en format scientifique»).

Dans Support apparu pour une méthode très intéressante tolocalestring ()qui formats tous les paramètres numériques selon les spécifications prescrites dans l'ECMA 402. En raison de ce nombre important, les numéros de téléphone, les devises et même les pourcentages sont magnifiquement affichés dans la boîte de dialogue.

var num \u003d 714000.80;

alerte (num.tolocalestring ());

Travailler avec des éléments de type de type, un objet global entier avec un tas de toutes sortes de fonctions mathématiques, dont le nom Math..

De plus, il existe d'autres méthodes qui effectuent des valeurs numériques arrondies aux entiers, jusqu'à des dixièmes, des centièmes, etc. Considérez-les d'autant plus.

Grands et puissants maths

L'objet Math Maths global comprend un grand nombre de diverses fonctions mathématiques et trigonométriques. Ceci est un objet très nécessaire et coupe souvent les développeurs lors de la collaboration avec des données numériques.

Sur d'autres plates-formes, il y a des analogies mathématiques. Par exemple, dans les langues populaires telles que Java et C #, Math est une classe qui prend en charge toutes les mêmes fonctions standard. Donc, comme vous le voyez, cet outil est vraiment génial et puissant.

Maintenant, je veux passer par les méthodes spécifiques responsables de l'arrondissement et en parler en détail.

Math.floor ()

Je vais commencer S. Math.Étage. Faites attention au nom de la méthode. Il devient logiquement clair que, puisque nous parlons de l'arrondi et la traduction littérale du mot "plancher" signifie "plancher", puis cet outil arrondit les valeurs traitées en une droite plus petite.

Une option est également possible lorsque le numéro traité à l'aide de cette fonction reste le même. Tous parce que l'arrondi est effectué sur l'inégalité non neurale (<=). Таким образом, при отработке этой строчки кода:

alerte (math.floor (4.5));

la réponse sera le numéro 4.

Math.ceil ()

Encore une fois, regardez le nom (dans une telle méthode, le matériau est rapidement absorbé). Si quelqu'un ne sait pas, "CEIL" signifie "plafond". Cela signifie que l'arrondissement des données numériques sera effectué de la manière la plus complète, à l'aide d'une non-inégalité (\u003e \u003d).

alerte (math.ceil (4.5));

Comme vous l'avez déjà deviné, la réponse sera le numéro 5.

Maths.round ()

Cette méthode arrondit un nombre fractionnaire au tout le plus proche. Donc, si la partie fractionnée est comprise entre 0 et 0,5 non inclusive, l'arrondi a une valeur inférieure. Et si la partie fractionnée est comprise entre 0,5 incluse et jusqu'au prochain entier, il est arrondi à un plus grand tout.

alerte (maths.round (4.5));

J'espère que tout le monde pensait ou dit la réponse correcte - 5.

Quelques méthodes supplémentaires

JavaScript dispose également d'autres méthodes qui sont engagées dans l'arrondissement des représentations numériques. Cependant, ils sont quelque peu différents.

Ce sera à propos de ces instruments que toofixed () et toprecision (). Ils répondent non seulement pour l'arrondi, mais pour sa précision à certains signes. Combatons plus profondément.

toofixed ()

Avec ce mécanisme, vous pouvez spécifier le nombre de signes après la virgule de la virgule de la valeur. La méthode renvoie le résultat en tant que chaîne. Ci-dessous j'ai joint une option avec trois options différentes. Analyser les réponses reçues.

var num \u003d 5656.9393;

document.writeln (Num.Tofixed ()); // 5657.

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

document.writeln (Num.Tofixed (7)); // 5656.9393000

Comme on peut le voir, si vous ne spécifiez pas l'argument, alors Tofixed ()) arrondit la valeur fractionnelle à part Nombres. Dans la troisième ligne terminée l'arrondi jusqu'à 2 caractèreset dans la quatrième - en raison du paramètre "7", trois autres ont été abordés.

toprecision ()

Cette méthode agit quelque peu différemment. Sur le lieu de l'argument, vous pouvez laisser un endroit vide et définir le paramètre. Cependant, ces derniers contenteront les chiffres avant le nombre spécifié de chiffres, ne faisant pas attention à la virgule. Voici les résultats du programme réécrit du passé de l'exemple:

var num \u003d 5656.9393;

document.writeln (Num.Toppision ()); // 5656.9393

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

document.writeln (Num.Topision (7)); // 5656.939

Fichier de division à 0 en JS

Comme on l'appelle des leçons en mathématiques, il est impossible de diviser à zéro. Cette règle a pris de base la plupart des créateurs de langages de programmation. Par conséquent, lors de la division sur zéro, tous les programmes donnent une erreur.

Cependant, Javascript s'est distingué ici. Donc, lors de l'exécution d'une telle opération, aucun message d'insecte ne se présente ... car une telle opération revient "Infini"!

Pourquoi alors? Comme on l'appelle des mêmes sciences mathématiques, plus le diviseur est petit, le résultat est un plus grand nombre. C'est pourquoi les créateurs de cette langue axée sur les prototypes ont décidé d'abandonner les modèles et d'aller leur propre chemin.

Pour ceux qui sont d'abord confrontés à la valeur Infinity, ci-dessous, j'ai expliqué ses caractéristiques.

Infinity - signifie infini et correspond complètement au signe mathématique.

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

alerte (12/0); // infini

alerte (12.34 / 0); // infini

alerte (-3 / 0); // -infinity.

À ce sujet, peut-être et finir. Si vous aimez la publication, assurez-vous de vous abonner à mon blog. Ne gèlez pas une référence à des articles intéressants et de les partager avec des amis. Bye Bye!

Souvent, les calculs donnent des résultats qui ne correspondent pas aux limites des plages souhaitées. En conséquence, vous devez faire de l'exercice Javascript arrondi jusqu'à une certaine valeur.

Pourquoi les chiffres ronds?

JavaScript ne stocke pas les entiers, car leurs valeurs sont présentées sous la forme d'un nombre de points flottants. De nombreuses fractions ne peuvent pas être représentées par un nombre avec un certain nombre de points-virgules finis. JavaScript peut donc générer des résultats, comme ce qui suit:

0.1 * 0.2; > 0.020000000000000004

En pratique, il n'aura aucune importance, car cela vient à l'erreur de la quinylonne. Mais cela peut affecter le résultat lorsque vous travaillez avec des chiffres représentant les valeurs de la vanne, le pourcentage ou la taille du fichier. Par conséquent, vous devez faire ou jusqu'à un certain signe décimal.

Arrondir les nombres décimaux

Pour "couper", un nombre décimal, des méthodes TOFIXED () ou TOPRÉCISION () sont utilisées. Ils prennent tous deux un argument qui détermine le nombre d'importants et des marques après la virgule, qui doit être incluse dans le résultat:

• si pour TOFIXED (), l'argument n'est pas défini, la valeur par défaut est 0, c'est-à-dire aucun signe après la virgule; La valeur maximale de l'argument est de 20;
• si pour TOPRÉCISION (), l'argument n'est pas spécifié, le nombre ne change pas.

var randnum \u003d 6,25; randnum.tofixed (); \u003e "6" math.pi.topision (1); \u003e "3" var randnum \u003d 87.335; Randnum.tofixed (2); \u003e "87.33" var randnum \u003d 87.337; Randnum.toprecision (3); \u003e "87.3"

Noter

Et Tofixed () et toprecision renvoient une représentation minuscule arrondie, et pas un nombre. Cela signifie que l'ajout d'une tenue de Randnum entraînera une chaîne concontelle et non un nombre:

console.log (randnum + arrondi); \u003e "6.256"

Si vous avez besoin d'arrondir JavaScript sur les centièmes, utilisez Paysfloat ():

var randnum \u003d 6.25; Var arrondi \u003d parsefloat (randnum.tofixed (1)); Console.log (arrondi); \u003e 6.3.

tofixed () et TOPRecision () sont également des méthodes utiles pour tronquer un grand nombre de points-virgules. Il est pratique lorsque vous travaillez avec des chiffres représentant des unités monétaires:

var wholenum \u003d 1 var oldanscents \u003d wholenum.tofixed (2); Console.log (dollars); \u003e "1,00"

Veuillez noter que s'il ya plus de signes que le paramètre de précision spécifié, TOPRecision émettra un résultat dans un format scientifique:

var num \u003d 123,435 num.topision (2); \u003e "1.2e + 2"

Comment éviter les erreurs lors de l'arrondissement des fractions décimales

Dans certains cas, toofixed et toprecision sont effectués JavaScript arrondi 5 à un côté plus petit, pas jusqu'à plus:

var numtest \u003d 1,005; numtest.tofixed (2); \u003e 1;

Le résultat de l'exemple ci-dessus doit être de 1,01, et non 1. Si vous souhaitez éviter cette erreur, je vous recommande d'utiliser des numéros exponentiels:

tour de fonctionnement (numéro de retour (Math.Round (Value + E »+ Décimales) +« E - »+ Décimales);)

Application:

rond (1.005.2); \u003e 1.01

Si vous avez besoin d'une solution encore plus fiable que l'arrondi, il est disponible sur MDN..

Arrondi avec epsilon

Méthode alternative JavaScript arrondi jusqu'à dixièmes a été introduit dans es6 ( Également appelé JavaScript 2015). « Machine Epsilon»Fournit une limite d'erreur raisonnable lors de la comparaison de deux points-virgules flottants. Sans arrondi, les comparaisons peuvent donner des résultats comme suit:

0,1 + 0,2 \u003d\u003d\u003d 0.3\u003e Faux

MATH.EPSILON peut être utilisé dans la fonction pour obtenir une comparaison correcte:

fonction du texte suivant (x, y) (retour math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

La fonction prend deux arguments: On contient des calculs, le deuxième résultat attendu (arrondi). Il renvoie une comparaison de ces deux paramètres:

sujeux (0,1 + 0,2, 0,3)\u003e vrai

Tous les navigateurs modernes prennent en charge les fonctions mathématiques ES6. Mais si vous devez fournir un soutien dans de vieux navigateurs, vous devez utiliser Polyfilla.

Troncature des nombres décimaux

Toutes les méthodes présentées précédemment effectuent JavaScript arrondi jusqu'à dixièmes. Pour couper un nombre positif de deux places à deux endroits après la virgule, multipliez-la à 100, à nouveau à nouveau, puis le résultat obtenu est divisé par 100, vous avez besoin:

fonction tronquée (num) (retour math.trunch (num * 100) / 100;) tronqué (3.1416)\u003e 3.14

Si quelque chose de plus flexible est requis, vous pouvez utiliser l'opérateur cassé:

fonction tronquée (Var NumPowerConverter \u003d math.pow (10, décimalplaces); retour ~~ (num * numpowerconverter) / NumpowerConverter;)

Utilisant:

var randint \u003d 35.874993; Tronqué (Randint, 3); \u003e 35.874.

Arrondir au nombre le plus proche

Implémenter JavaScript arrondi dans l'ensemble, Math.Round () est utilisé:

Math.Round (4.3)\u003e 4 Math.Round (4.5)\u003e 5

Noter que " demi-valeur", Telle que 0,5, arrondi.

Arrondir à l'entier le plus proche

Si vous voulez arrondir de manière petite, utilisez la méthode Math.Floor ():

Math.floor (42.23); \u003e 42 math.floor (36.93); \u003e 36.

L'arrondi "bas" a une direction pour tous les chiffres, y compris pour négatif. Cela peut être représenté comme un gratte-ciel avec un nombre infini d'étages, y compris au-dessous du niveau de fondation ( représentant des nombres négatifs). Si vous êtes dans l'ascenseur entre les planchers de sous-sol 2 et 3 ( ce qui correspond à la valeur -2.5), Math.floor vous livrera à l'étage -3:

Math.floor (-2.5); \u003e -3.

Si vous souhaitez éviter cela, utilisez JavaScript Math Rounding en utilisant Math.Trunc () pris en charge dans tous les navigateurs modernes (sauf C'est-à-dire):

Math.trunc (-41.43); \u003e -41

MDN fournit également polyfill de trois lignes pour fournir un support math.trunc dans des vieux navigateurs et c'est-à-dire.

Arrondir jusqu'au entier le plus proche

Si vous voulez arrondir des nombres décimaux, utilisez Math.Ceuil. L'action de cette méthode peut également être représentée comme un ascenseur sans fin: Math.Ceuil est toujours chanceux "up", que le nombre soit négatif ou positif:

Math.ceil (42.23); \u003e 43 mathsil (36.93); \u003e 37 mathsil (-36,93); -36

Arrondir au nombre multiple le plus proche

Si vous avez besoin d'arrondir la valeur au numéro le plus proche, plusieurs 5, créez une fonction qui divise le nombre à 5, autour de lui, puis multiplie le résultat de la même valeur:

fonction RoundTo5 (Num) (retour Math.Round (Num / 5) * 5;)

Utilisant:

rond-point5 (11); \u003e 10.

Si vous souhaitez exécuter JavaScript arrondi jusqu'à deux caractères, vous pouvez transmettre des fonctions comme numéro initial et multiplicité:

fonction RoundTomultiple (Num, multiple) (retour Math.Round (Num / Multiple) * Plusieurs;)

Pour utiliser la fonction, allumez le nombre arrondi et la multiplicité dans son appel:

var InitialNumber \u003d 11; var multiple \u003d 10; Ttomultiple (initialeNumber, multiple); \u003e 10;

Pour arrondir les valeurs uniquement dans une direction importante ou plus petite, remplacez-la dans la fonction ronde sur le plafond ou le sol.

Reliaison à la portée

Parfois, vous devez obtenir la valeur X, qui devrait être dans une certaine gamme. Par exemple, vous avez besoin d'une valeur de 1 à 100, mais nous obtenons la valeur 123. Pour le réparer, vous pouvez utiliser min () ( renvoie le plus petit chiffre) et max ( renvoie le nombre maximum autorisé).

Utilisant:

var Lowbound \u003d 1; var highbound \u003d 100; var numinput \u003d 123; var serrage \u003d math.max (math-math.min (Numinput, Highbound)); Console.log (serré); \u003e 100;

Vous pouvez créer une fonction ou un numéro de classe d'extension.