Spôsoby zaokrúhľovania v Javascript. Jednoduché pravidlá zaokrúhľovania v Javascript. Študujeme metódy a aplikujeme v praxi parsefloat javascript 2 desatinné znamenie

Javascript-matematika, zaokrúhľovanie až dve desatinné miesta (9)

Mám nasledujúci JavaScript Syntax:

Var zľavy \u003d math.round (100 - (cena / listPrice) * 100);

Toto je zaokrúhlené na celé číslo. Ako môžem vrátiť výsledok s dvoma desatinnými znakmi?

Tu je pracovný príklad

Hodnota VAR \u003d 200.2365455; Výsledok \u003d Math.round (hodnota * 100) / 100 // Výsledok bude 200,24

Na spracovanie zaokrúhľovania na ľubovoľný počet desatinných miest pre väčšinu potrieb bude dostatok funkcie s 2 kódovými riadkami. Tu je príklad kód pre hru.

Var testnum \u003d 134,9567654; Var bodu \u003d 2; VAR Testres \u003d ROUNDDEC (Testnum, Deskpl); Upozornenie (Testnum + "zaokrúhlené na" + decpl + "desatinné miesta je" + testres); Funkcia ROUNDDDEC (NBR, DEC_PLACESS) (var mult \u003d math.pow (10, dec_places); RETURN MATHY.ROUND (NBR * MULT) / MULT;)

Najlepšie a jednoduché riešenie, ktoré som našiel, je

Funkčné kolo (číslo návratu (math.round (hodnota + E "+ desatinály) +" E - "+ Desimanti);) kolo (1,005, 2); // 1.01

Malé variácie prijatej odpovede. TOFIXED (2) Vracia reťazec a vždy dostanete dve desatinné značky. To môže byť nuly. Ak chcete potlačiť konečné nula (y), urobte to:

Var zľavy \u003d + ((cena / listy) .tofixed (2));

Upravené: Práve som zistil, že sa zdá chyba vo Firefoxe 35.0.1, čo znamená, že vyššie uvedené môže dať Nan niektoré hodnoty.
Zmenil som svoj kód

Var zľava \u003d math.round (cena / listPrice * 100) / 100;

To dáva číslo s presnosťou dvoch desatinných miest. Ak potrebujete tri, budete znásobiť a rozdeliť 1000, a tak ďalej.
OP chce vždy dve desatinné vybitie, ale ak je tofixed () rozbité v Firefoxe, musíte ju najprv opraviť.
Pozri https://bugzilla.mozilla.org/show_bug.cgi?id\u003d1134388.

Ak chcete získať výsledok s dvomi desatinnými znakmi, môžete vykonať nasledovné:

Var zľavy \u003d math.round ((100 - (cena / listPrice) * 100) * 100) / 100;

Hodnota, ktorá musí byť zaokrúhlená, sa vynásobí 100 na uloženie prvých dvoch číslic, potom rozdelíme na 100, aby sme získali skutočný výsledok.

Myslím, že najlepší spôsob, ako som videl, sa vynásobí 10 na počet čísel, potom matematiku a potom nakoniec rozdeliť 10 podľa počtu čísel. Tu je jednoduchá funkcia, ktorú používam v textoch písania

Funkcia RoundtoxDigits (hodnota: Číslo, číslice: Číslo) (hodnota \u003d hodnota * Math.POW (10, číslice); hodnota \u003d Math.round (hodnota); hodnota \u003d hodnota / Math.POW (10, číslice); návratová hodnota; )

Alebo jednoduchý JavaScript:

Funkcia ROUNDOXDIGDIGITY (hodnota, číslice) (ak sú (! Číslice) (číslice \u003d 2;) Hodnota \u003d hodnota * Math.POW (10, číslice); hodnota \u003d Math.round (hodnota); hodnota \u003d hodnota / Math.POW (10 , číslice); návratová hodnota;)

POZNÁMKA. - Pozri Upraviť 4 Ak je dôležitá 3-miestna presnosť.

Var zľavy \u003d (cena / listy) .tofixed (2);

tfixed je zaokrúhlený nahor alebo nadol pre vás v závislosti od hodnôt presahujúcich 2 desatinné značky.

Zmeniť. Ako už bolo spomenuté inými, konvertuje výsledok v reťazci. Aby sa tomu zabránilo:

Var zľavy \u003d + ((cena / listy) .tofixed (2));

Úprava 2. - Ako sa uvádza v pripomienkach, táto funkcia sa nevykonáva s určitou presnosťou, napríklad v prípade 1,005 sa vráti 1,00 namiesto 1,01. Ak je presnosť dôležitá pre takáto rozsah, našiel som túto odpoveď: https: //.com/a/32605063/1726511 Čo sa zdá, že dobre funguje so všetkými testmi, ktoré som sa snažil.

Jedna menšia modifikácia vyžaduje, ale odpoveď uvedená vyššie sa vracia celé čísla, keď je zaokrúhlené na jednu, preto sa napríklad 99.004 vráti 99 namiesto 99,00, čo nie je dokonalé pre displej cien.

Upraviť 3. - Zdá sa, že Tfixed na skutočnom návrate stále skrútených čísel, to je konečné editácie. Geez toľko reparácií!

Zľava VAR \u003d ROUNDTOUS ((Cena / ListPrice), 2); FUNKCIA COLNOTOU (n, číslice) (ak (číslice \u003d\u003d\u003d nedefinované) (číslice \u003d 0;) var multiplikátor \u003d matematika (10, číslice); n \u003d parsefloat ((n * multiplikátor) .Tofixed (11)); var testu \u003d (math.round (n) / multiplikátor); návrat + (test.Tofixed (číslice));)

Upraviť 4. "Ty ma zabijú." Edit 3 zlyhá na záporných číslach, bez kopania, prečo je jednoduchšie jednoducho urobiť záporné číslo pozitívne pred tým, než sa zaokrúhľuje, a potom ho vráťte späť pred vrátením výsledku.

Funkcia COLNOTOU (N, číslice) (var negatívne \u003d false; ak (číslice \u003d\u003d\u003d nedefinované) (číslice \u003d 0;) ak (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; }

Najrýchlejší spôsob - Rýchlejšie ako TOFIXED ():

Dve dekolelice

x \u003d .123456 Výsledok \u003d Math.round (x * 100) / 100 // výsledok .12

Tri dejeionions

X \u003d .123456 Výsledok \u003d Math.round (x * 1000) / 1000 // výsledok .123

Funkcia ROUND (NUM, DEC) (NUM \u003d MATHY.ROUND (NUM + E "+ DEC) Číslo návratu (NUM +" E - "+ DEC)) // Kolo na desatinné číslo vášho výberu: ROUND (1.3453.2)

V tomto článku sa podrobne zvážte čísla, matematických operátorov, metód transformácie čísla v reťazci a naopak, ako aj mnoho ďalších dôležitých bodov.

Funkcia Isfinite

Funkcia Isfinite vám umožňuje skontrolovať, či argument je konečné číslo.

Ako odpoveď, táto funkcia vráti false, ak je argument nekonečno, -Infinity, NAN alebo sa zobrazí jednej z týchto špeciálnych číselných hodnôt. V opačnom prípade táto funkcia vráti hodnotu TRUE.

Isfinit (73); // pravda Isfinite (-1/0); // FALSE ISFINITE (INFINITY); // FALSE ISFINITE (NAN); // false isfinit ("text"); // FALSE

Okrem globálnej funkcie Isfinite v JavaScript je ďalšia metóda čísla. Na rozdiel od Isfinite, nevykonáva nútený argument na číslo.

Isfinite ("73"); // pravdivé číslo.Isfinite ("73"); // FALSE

Funkcia Isnan

Funkcia ISNAN je navrhnutá tak, aby určila, či je argument číslo alebo môže byť premenený na ňu. Ak áno, funkcia Isnan sa vráti false. V opačnom prípade sa vráti TRUE.

Isnan (Nan); // pravý isnan ("25px"); // pravda, pretože 20px nie je číslo Isnan (25.5); // FALSE ISNAN ("25,5"); // FALSE ISNAN (""); // false, pretože Priestor alebo nielen medzery sa konvertujú na 0 isnan (null); // false, pretože Nullová hodnota sa prevedie na 0 Isnan (TRUE); // false, pretože Skutočná hodnota sa konvertuje na 1 Isnan (FALSE); // false, pretože FALSKÁ HODNOTA PREVÁDZA na 0

Ak je potrebné vykonať túto akciu bez toho, aby sa dosiahol typ, potom použite metódu NUMBER.ISNAN. Táto metóda bola zavedená do jazyka, počnúc Ecmascriptom 6.

Ako výslovne previesť riadok na číslo?

Je jasne prináša riadok na číslo nasledujúcimi spôsobmi:

1. použitie prevádzkovateľ +.ktoré musia byť umiestnené pred hodnotou.

+ "7.35"; // 7,35 + "text"; // nan.

Táto metóda zanedbáva medzery na začiatku a konci reťazca, ako aj n (preklad riadkov).

+ "7.35"; //7.35 + "7,35 n"; //7.35

Pomocou tejto metódy je potrebné venovať pozornosť tomu, že prázdny reťazec alebo reťazec pozostávajúci z priestorov a n je preložený do čísla 0. Okrem toho konvertuje aj null typ údajov a logické hodnoty číslo.

Nulový; // 0 + true; // 1 + false; // 0 + ""; // 0.

2. Funkcia Parseint. Táto funkcia je určená na konverziu. argument pre celé číslo. Na rozdiel od používania prevádzkovateľ +., táto metóda vám umožňuje previesť reťazec na číslo, v ktorom nie všetky znaky sú digitálne. Začína konvertovať reťazec od prvého symbolu. A hneď ako sa stretne s symbolom, ktorý nie je digitálny, táto funkcia zastaví jeho prevádzku a vráti výsledné číslo.

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

Táto funkcia môže pracovať s rôznymi číselnými systémami (binárne, okthal, desatinné, hexadecimálne). Poznámka Základňa číselného systému sa vykonáva pomocou 2 argumentov.

Parseint ("18px", 10); // 18 parseint ("33,3%", 10); // 33 parseint ("101", 2); // 5 parseint ("B5", 16); // 181.

Okrem funkcie Parseint v JavaScript je tu číslo čísla.Parseint. Táto metóda sa nelíši od funkcie Parseint a bola zavedená v JavaScript s špecifikáciou ECMAScript 2015 (6).

3. Funkcia parsefloat. Funkcia parsefloat je podobná Parseint, s výnimkou transformácie argumentu na frakčné číslo.

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

Okrem toho, funkcia Parsefloat, na rozdiel od Parseint, nemá 2 argumenty, a preto sa vždy snaží zvážiť reťazec ako číslo v desatinnom čísle systému.

Parsefloat ("3.14"); ParseFloat ("314E-2"); Parsefloat ("0,0314E + 2");

Okrem funkcie Parsefloat v JavaScript je metódou čísel.Parsefloat. Táto metóda sa nelíši od funkcie Parsefloat a bola zavedená v JavaScript s špecifikáciou ECMAScript 2015 (6).

Transformácia čísla v reťazci

Číslo môžete otáčať v reťazci pomocou metódy TOSTRING.

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

Metóda Tostring vám tiež umožňuje zadať základ číselného systému, s ktorým je potrebné výslovne priniesť číslo do riadku:

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

Ako skontrolovať, či číslo premenného

Ak chcete zistiť, či hodnota hodnoty môže byť variabilná pomocou jednej z nasledujúcich metód:

1. Použitie funkcií ISNAN a ISFINITE:

// MYVAR - premenná, ak (! Isnan (Parsefloat (Myvar)) && Isfinite (Parsefloat (MYVAR)) (// MYVAR je číslo alebo je možné ho poskytnúť);

Vo forme funkcie:

// Functions isnumerameric (Return! Isnan (Parsefloat (hodnota)) && Isfinite (Parsefloat (hodnota));) // Použitie VAR MYVAR \u003d "12PX"; Console.log (isnumemerický (MYVAR)); // pravda.

Táto metóda vám umožňuje určiť, či je zadaná hodnota alebo môže byť daná. Táto možnosť nepovažuje prázdny reťazec, reťazec medzier, hodnoty , nekonečno, -Infinity, true a false.

2. Použitie operátora typu a Isfinitov, Isnan:

// funkcia, ktorá kontroluje, či je hodnota číslo funkcie isnumber (hodnota) (RETURN TYPEOF VALUE \u003d\u003d\u003d "(! LANG: číslo" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Táto funkcia určuje, či je zadaná hodnota typ čísla a či nepatrí do jednej zo špeciálnych hodnôt nekonečno, -Infinity a Nan. Esley je tak, potom táto funkcia sa vracia true.

3. Pomocou metódy ECMAScript 6 Number.Integer (hodnota). Táto metóda umožňuje určiť, či je zadaná hodnota celé číslo.

Number.Isinteger ("20"); // false, pretože Táto metóda neprekladá reťazec na počet NUMBERT.ISINTEREGER (20); // pravda, pretože Táto hodnota je číslo

Aj nepárne čísla

Skontrolujte, či sa číslo používa alebo nepárne nasledujúcimi funkciami:

// Funkcia pre kontrolu čísla na čítanie funkcie ISEVEN (N) (RETURN N% 2 \u003d\u003d 0;) // Funkcia pre kontrolu čísla ISODD ISODD ISODD (N) (návrat Math.ABS (N% 2) \u003d\u003d 1;)

Ale pred vykonaním takejto kontroly sa odporúča, aby ste sa uistili, že zadaná hodnota je číslo:

Hodnota \u003d 20; Ak (číslo.Isinteger (hodnota)) (ak (ISEVEN (hodnota)) (Console.log ("číslo" + hodnota.ToString () + "- tenký");)

Jednoduché čísla v Javascript

Zvážte príklad, v ktorom sa odstránia jednoduché čísla od 2 do 100 s Javascriptom.

// Funkcia, ktorá kontroluje, či je číslo jednoduchá funkcia ISPRIME (hodnota) (ak (Isnan (hodnota) || Isfinit (hodnota) || hodnota% 1 || hodnota< 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);

Číslo zaokrúhľovania v Javascript

Zavrieť frakčné číslo na celú hodnotu v Javascript rôznymi spôsobmi.

1. Použitie Math.floor, Math.CEIL a Math.round metódy špeciálne navrhnuté na to. Metóda Math.floor Colls Frakčné číslo na najbližší celok, t.j. Jednoducho zlikvidujte frakčnú časť. Math.CEIL Curls frakčné číslo na najbližšieho celku. Math.round zaokrúhľuje číslo nahor alebo nadol v závislosti od hodnoty frakčnej časti. Ak je frakčná časť väčšia alebo rovná 0,5, potom sa vykoná inak vylepšením.

Konzoly.log (math.floor (7.9)); // 7 Console.log (Math.CEIL (7.2)); // 8 Console.log (math.round (7.5)); //osem

2. Použitie metódy Tfixed. Táto metóda zaokrúhľuje frakčnú časť čísla k danej presnosti. Výsledok zaokrúhľovania sa vracia ako reťazec.

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

Ak sa známky po správe za vytvorenie špecifikovanej presnosti počtu chýba, dopĺňajú nuly.

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

3. Prostredníctvom metódy topRecision. Táto metóda predstavuje číslo s uvedenou presnosťou. Zároveň môže zaokrúhliť nielen frakčné, ale aj celú časť čísla. Získané číslo, tento spôsob môže byť reprezentovaný v závislosti od výsledku s pevnou čiarkou alebo exponenciálnou formou.

Konzola.log ((1001) .toprecision (2)); //"1.0E+3 "Console.log ((1001) .topreCision (5)); //"1001.0 "Console.log ((12.4) .topreCision (1)); // "1e + 1" konzola.log ((12.4) .topreCision (2)); // "12" Console.log ((12.4) .topreCision (3)); //"12.4 "Console.log ((12.4) .topreCision (5)); // "12,400"

4. Používanie logických operátorov nie alebo alebo.

// dvojitým logickým zamietnutím Console.log (~ ~ 7,9); // 7 // Prostredníctvom logického alebo s nulou: konzola.log (7,9 ^ 0); // 7.

Celej a frakčnej časti čísla

Môžete získať celú časť čísla pomocou metódy Math.floor () a Parseint ():

Konzoly.log (math.floor (7.21)); // 7 Console.log (Parseint (7.21)); // 7.

Môžete získať frakčnú časť čísla, ktorú môžete použiť percentuálny prevádzkovateľ (%). Tento operátor vráti zvyšok, ktorý sa získa z rozdelenia prvého čísla na druhú. V tomto prípade je potrebné použiť 1 ako 2 čísla.

Console.log (7,21% 1); // 0.20999999999999996 // s presnosťou 2 znakmi po konzumácii bodkočiarky ((7,21% 1) .Tofixed (2)); // "0,21"

Okrem toho môže byť frakčná časť tiež získaná výpočtom:

Číslo VAR \u003d 7,21; var frakcienumber \u003d číslo - math.floor (math.abs (číslo)); Console.log (FracineSnumber); // 0.20999999999999996.

Či je číslo rozdelené

Ak chcete zistiť, či počet cieľov možno nájsť pomocou operátora percenta:

Číslo varu \u003d 9; // Ak je zvyšok z rozdelenia počtu číslo 3 0, potom áno, inak nie je (číslo% 3 \u003d\u003d 0) (Console.log ("číslo" + číslo + "je rozdelené do 3" );) Inak (konzola. Denník ("číslo" + číslo + "nie je rozdelené do 3");)

Čísla formátovania

V jazyku JavaScript naformátujte výstupný výstup v súlade s regionálnymi normami (Nastavenia operačného systému jazyka) umožňuje metódu toliecalestringu ().

Napríklad vykonajte formátovanie čísla v súlade s regionálnymi normami, ktoré sú nainštalované v predvolenom systéme:

Číslo VAR \u003d 345,46; Konzola.log (číslo.tolOcalestring ()); // "345.46"

Napríklad plníme formátovanie čísla v súlade s regionálnymi normami Ruska (RU):

Console.log ((108.1) .TolOcalestring ("RU-RU"); // "108.1"

Túto metódu možno použiť aj na formátovanie čísla vo forme meny:

Console.log ((2540.125) .TolOcalestring ("RU-RU", (štýl: "Mena", mena: "RUB"))); // "2 540,13 ₽" Console.log ((89.3) .TolOcalestring ("RU-RU", (štýl: "Mena", mena: "USD"))); // "$ 89.30" Console.log ((2301.99) .TolOcalestring ("RU-RU", (štýl: "Mena", mena: "EUR")); // "2 301,99 €"

Poznať záujem o formu záujmu:

Console.log ((0,45) .TolOcleString ("RU-RU", (štýl: "percento")); // "45%"

Vyčistite číslo na absolutóriu (UhlíkGrouping Nehnuteľnosti):

Console.log ((125452,32) .TolOcalestring ("RU-RU", (používanieskuping: TRUE)); // "125 452.32"

Displej s určitým počtom číslic (2) po čiaste:

Console.log ((1240.4564) .TolOcalestring ("RU-RU", (minimálnefrakčnéDigity: 2, maximumfrakcieDigity: 2)); // "1 240.46"

Porovnanie čísel

Na porovnanie čísel v JavaScript sa používajú nasledovní operátori: \u003d\u003d (rovný),! \u003d (Nie je rovnaké),\u003e (viac),< (меньше), >\u003d (viac alebo rovné),<= (меньше или равно).

Napríklad porovnávame dve čísla:

Konzola.log (2\u003e 3); // false console.log (5\u003e \u003d 3); // pravda.

Pri porovnávaní čísel s frakčnou časťou je potrebné zvážiť chyby, ktoré sa môžu vyskytnúť počas týchto výpočtov.

Napríklad v JavaScript sa suma čísla (0,2 + 0,4) rovná 0,6:

Konzola.log ((0,2 + 0,4) \u003d\u003d 0,6); // FALSE

Chyby sa vyskytujú, pretože všetky výpočty počítača alebo iné elektronické zariadenie produkuje v 2 číslicovom systéme. Tí. Pred vykonaním niektorých akcií musí počítač najprv konvertovať číslo do výrazu v 2 číslového systému. Nie je však v 2 číselnom systéme reprezentovať žiadne frakčné desatinné číslo.

Napríklad číslo 0,25 10 až binárneho systému je presne premenené.

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

Napríklad číslo 0,2 10 môže byť prevedené na 2 systém len s definitívnou presnosťou:

0,2 x 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 x 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 x 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

V dôsledku toho tieto chyby ovplyvnia výpočet súčtu dvoch čísel a porovnávacích výsledkov. Tí. Ukazuje sa, že skutočne JavaScript bude vidieť túto položku nasledovne:

0.6000000000000001==0.6

Pri výpočte alebo mapovaní čísel s frakčnou časťou, mali by ste vždy uviesť presnosť, s ktorou sa musí vykonať.

Napríklad porovnávať čísla až 2 desatinné miesta pomocou TOFIXED () a topRecision () Metódy:

// TOFIXED () Metóda Console.LOG ((0,2 + 0,4) .TOFIXED (2) \u003d\u003d (0,6) .TOFIXED (2)); // True // TopRecision () Metóda Console.log ((0,2 + 0,4) .toprecision (2) \u003d\u003d (0,6) .toprecision (2)); // pravda.

Hlavné matematické operácie

JavaScript existuje nasledovné matematické operátory: + (add), - (odčítanie), * (násobenie), / (divízia),% (zvyšok z rozdelenia), ++ (priblíženie na 1), - (Znížiť hodnotu na 1).

6 + 3 // 9 6-3 // 3 6 * 3 // 18 6/3 // 2 6% 3 // 0, t.j. 6: 3 \u003d 2 \u003d\u003e 6-3 * 2 \u003d\u003e OST (0) 5% 2 // 1, t.j. 5: 2 \u003d 2 (.5) \u003d\u003e 5-2 * 2 \u003d\u003e OST (1) 7,3% 2 //1.3, t.j. 7.3: 2 \u003d 3 (.65) \u003d\u003e 7.3-2 * 3 \u003d\u003e OST (1.3) // Znamenie výsledku prevádzky% sa rovná znameniu prvej hodnoty -9% 2,5 //-1,5 , tj 9: 2,5 \u003d 3 (.6) \u003d\u003e 9-2,5 * 3 \u003d\u003e OST (1,5) -9% -2,5 //-1,5, t.j. 9: 2,5 \u003d 3 (.6) \u003d\u003e 9-2,5 * 3 \u003d\u003e OST (1,5) -2% 5 // - 2, t.j. 2: 5 \u003d 0 (.4) \u003d\u003e 2-5 * 0 \u003d\u003e OST (2) X \u003d 3; Konzola.log (x ++); // Zobrazí 3, už už nastaví 4 Console.log (X); // 4 x \u003d 3; Konzola.log (++ x); // Sets 4 a zobrazí X \u003d 5; Konzola.log (x--); // Zobrazí 5, už potom nastaví 4 Console.log (X); // 4 x \u003d 5; Konzola.log (- x); // Sets 4 a zobrazuje kombinované operátory v Javascripte navyše: 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; Konzola.log (x); // 9 x \u003d 3; y \u003d 6; X- \u003d Y; Konzola.log (x); // - 3 x \u003d 3; y \u003d 6; x * \u003d y; Konzola.log (x); // 18 x \u003d 3; y \u003d 6; x / \u003d y; Konzola.log (x); //0,5 x \u003d 3; y \u003d 6; x% \u003d y; Konzola.log (x); // 3.

Ahoj. Dnes, v stĺpci JavaScript, budeme sa pozrieť na to, ako nastaviť na JavaScript Počet mozgových čísel v číslach plávajúceho bodu. Napríklad, musíte ponechať 3 desatinné znamenie pri zobrazení, alebo len dva.

Úloha: JavaScript Počet bodkočiariek

Takže, čelíme s úlohou: Existuje výsledok výpočtov, v ktorých existujú čísla pred bodkočiarkou, a po čiaste. Desatinné. Predpokladajme, že výsledok sa ukázal na tento 1538.9891200153. Ale keď by mal byť výstup číslo, ktoré odrážajú množstvo, kde je množstvo bankoviek až do čiarky a po kopeckoch.

Existuje niekoľko spôsobov, ako vyriešiť túto úlohu.

Riešenie 1: JavaScript Počet bodkočiariek s Tfixed Metóda

tOFIXED je vložená v javascript metóde, ktorá sa aplikuje na ľubovoľné číslo, presnosť zaberá zaokrúhľovanie presnosti (to znamená, že počet postáv morskej časti).

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;

Parameter presnosti v tejto funkcii by mal byť aspoň 0 (neberie negatívne hodnoty) a nie viac ako 20.

Môžete tiež urobiť bez premennej, napríklad takto:

Num_str \u003d (1538,9891200153) .Tofixed (2); //Num_str\u003d1538.98;

Riešenie 2: JavaScript Počet bodkočiarky s metódou topRecision

Toto riešenie je založené na rovnakej vstavanej metóde JavaScript. Charakteristickým znakom tejto metódy je, že parameter odobratý do vstupu naznačuje presnosť (počet bodkočiariek), ale celkový počet znakov (oboje do čiarky, ako aj po ňom).

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

Riešenie bez značiek po čiaste: JavaScript Počet bodkočiariek

Ak je potrebné úplne zložiť desatinné príznaky, to znamená, že je potrebné zaokrúhliť frakčné číslo do celku, potom môžete použiť funkcie matematiky: okrúhle, strop a podlahu.
Okrúhle kolá vo veľkej alebo menšej strane (v závislosti od čísla). Ak je hodnota po polkolónoch viac ako polovica, potom zakyduje na celú stranu, ak je menej - na menšie. To znamená, že ak bude 0,51 - bude 1, ak 0,49 - 0.

Ceil - z angličtiny. Strop je vždy zaokrúhlený do najväčšej strany.

Poschodie - z angličtiny. Paul kolíky vždy na menšej strane.

Var num \u003d 1538.9891200153; num_str \u003d math.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;

To je všetko. Dúfam, že táto poznámka pomohla vyriešiť úlohu. Ak niečo zlyhalo - pýtajte sa otázky pomocou zeleného tlačidla "Požiadajte o otázku špecialistom", alebo v komentároch.

Dobrý deň, milenci javascript-a. Už ste si všimli, že tento jazyk je veľmi výnimočný av každej sekcii vyniká pre svoje zvláštnosti a nezvyčajné technické riešenia. Preto je dnešná publikácia venovaná téme: zaokrúhľovanie JavaScript.

Po prečítaní aktuálneho článku zistíte, prečo je nutné zaokrúhliť čísla, aké metódy a vlastnosti v JS vykonávať túto funkciu, ako aj rozdelenie 0. Bez zmeny zásad, budem pripojiť príklady k kľúčovým bodom materiál a písať každú akciu podrobne. Teraz sa začneme učiť!

Dôležité poznámky o číslach

Začať, pamätajte, že v JS všetky druhy čísel (frakčné a celé číslo) odkazujú na typ Číslo. Okrem toho všetky z nich sú 64-bit, pretože sú uložené vo formáte "Double Precision", ktorý je tiež známy pod štandardom IEEE-754.

Vytvorené numerické premenné s obvyklým spôsobom:

var numb \u003d 35; // prirodzené číslo

var drob \u003d 0,93; // desatinné zastúpenie

var numb16 \u003d 0xff; // 16-bohatý systém

Podporuje iné číselné zobrazenia. Takže môžete tiež vytvoriť čísla s plávajúcim bodom (niekedy sa nazývajú "čísla vo vedeckom formáte").

V objavenej podpore pre veľmi zaujímavú metódu tolokalestring ()Ktoré formáty všetky číselné parametre podľa špecifikácií predpísaných v ECMA 402. Vďaka tomuto veľkému počtu sa v dialógovom okne krásne zobrazia telefónne čísla, meny a dokonca aj percentá.

var num \u003d 714000,80;

upozornenie (num.tolcalestring ());

Pracovať s prvkami typu číslo, celý globálny objekt s partiou všetkých druhov matematických funkcií, ktorých meno Matematika..

Okrem toho existujú aj iné metódy, ktoré vykonávajú zaokrúhlenie číselných hodnôt na čísla, až do desiatych, stotín atď. Zvážte ich celé.

Veľká a mocná matematika

Globálny matematický objekt zahŕňa obrovské množstvo rôznych matematických a trigonometrických funkcií. Toto je veľmi potrebné objekt a často znižuje vývojárov pri práci s digitálnymi údajmi.

Na iných platformách, existujú analógie matematika. Napríklad v populárnych jazykoch, ako je Java a C #, matematika je trieda, ktorá podporuje všetky rovnaké štandardné funkcie. Takže, ako vidíte tento nástroj je naozaj skvelý a mocný.

Teraz chcem prejsť špecifickými metódami zodpovednými za zaokrúhľovanie a podrobne o nich povedať.

Math.floor ()

Začnem S. Matematika.podlaha. Venujte pozornosť názvu metódy. Logicky to je jasné, že keďže hovoríme o zaokrúhľovaní a doslovný preklad slova "podlaha" znamená "podlahu", potom tento nástroj zaokrúhľuje spracované hodnoty do menšieho priameho.

Možná možnosť je možná aj, keď zostáva spracované číslo pomocou tejto funkcie rovnaké. Všetko, pretože zaokrúhľovanie sa vykonáva na neurvovej nerovnosti (<=). Таким образом, при отработке этой строчки кода:

upozornenie (Math.floor (4.5));

odpoveď bude číslo 4.

Math.CEIL ()

Znova sa pozrite na meno (v takomto spôsobe, materiál sa rýchlo vstrebáva). Ak niekto nevie, "CEIL" znamená "strop". Znamená to, že zaokrúhlenie číselných údajov sa vykonajú na väčšine stranou s použitím nenesovej hodnoty (\u003e \u003d).

upozornenie (Math.CEIL (4.5));

Ako ste už uhádli, odpoveď bude číslo 5.

Math.round ()

Táto metóda zavrhuje frakčné číslo na najbližší celok. Takže, ak je frakčná časť v rozsahu od 0 do 0,5 inkluzívne, zaokrúhlenie sa vyskytuje na menšiu hodnotu. A ak je frakčná časť v rozsahu od inclusive 0,5 a až do ďalšieho celé číslo, je zaokrúhlené na väčšie.

upozornenie (Math.round (4.5));

Dúfam, že si všetci mysleli alebo povedali správnu odpoveď - 5.

Niektoré ďalšie metódy

JavaScript má tiež iné 2 metódy, ktoré sa zaoberajú zaokrúhľovaním číselných reprezentácií. Avšak, oni sú trochu iné.

Bude to o takýchto nástrojoch tOFIXED () a topRecision (). Odpovedajú nielen na zaokrúhľovanie, ale pre jeho presnosť na určité príznaky. Poďme bojovať.

tOFIXED ()

S týmto mechanizmom môžete špecifikovať, koľko značiek po tom, čo čiarka musí zaokrúhliť hodnotu. Metóda vráti výsledok ako reťazec. Nižšie som pripojil možnosť s tromi rôznymi možnosťami. Analyzujte prijaté odpovede.

var num \u003d 5656,9393;

dokument.writeln (num.tofixed ()); // 5657.

dokument.writeln (num.Tofixed (2)); // 5656.94

dokument.writeln (NUM.TOFIXED (7)); // 5656.9393000

Ako možno vidieť, ak nešpecifikujete argument, potom TOFIXED ()) Kolo Frakčné hodnotu do celého čísla. V treťom riadku dokončené zaokrúhľovanie až 2 znakya vo štvrtom - kvôli parametrovi "7" boli zaoberané tri ďalšie 0.

topRecision ()

Táto metóda pôsobí trochu inak. Na mieste argumentu môžete zanechať prázdne miesto a nastavte parameter. Avšak, ten druhý bude zaokrúhliť čísla pred zadaným počtom čísel, nevenuje pozornosť čiarke. Tu sú výsledky programu prepísané z minulosti z príkladu:

var num \u003d 5656,9393;

dokument.writeln (num.topreCision ()); // 5656.9393

dokument.wriTeln (num.topreCision (2)); // 5.7E + 3

dokument.writeln (num.topreCision (7)); // 5656.939

Súbor rozdelenia na 0 v Js

Ako je známe z lekcií v matematike, nie je možné rozdeliť na nulu. Toto pravidlo trvalo ako základ tvorcov programovacích jazykov. Preto pri delí sa na nulu, všetky programy vydávajú chybu.

Javascript sa však tu rozlíšil. Takže počas realizácie takejto operácie nevyskytujú žiadne chyby správy ... pretože takáto operácia sa vracia "Nekonečno"!

Prečo tak? Ako je známe z rovnakých matematických vied, tým menšie je delič, výsledkom je väčší počet. Preto tvorcovia tohto prototypu orientovaného jazyka sa rozhodli opustiť šablóny a ísť si vlastným spôsobom.

Pre tých, ktorí sa najprv stretávajú s nekonečnou hodnotou, nižšie som vysvetlil jeho vlastnosti.

Infinity - znamená nekonečno a úplne zodpovedá matematickému znameniu ∞.

Môže byť negatívny. Uložia sa aj všetky štandardné pravidlá pre prácu s aritmetickými operátormi.

aLERT (12/0); // nekonečno

upozornenie (12,34 / 0); // nekonečno

aLERT (-3 / 0); // -Infinity.

Na tomto, možno a dokončite. Ak sa vám páči publikácia, potom sa uistite, že sa prihlásite na môj blog. Nezaraďte si odkaz na zaujímavé články a zdieľajte ich s priateľmi. BYE BYE!

Výpočty často dávajú výsledky, ktoré nezodpovedajú limitom požadovaných rozsahov. V dôsledku toho musíte cvičiť Zaokrúhlenie Javascriptu až do určitej hodnoty.

Prečo okrúhle čísla?

JavaScript nekladá celé čísla, pretože ich hodnoty sú prezentované vo forme plávajúceho čísla bodu. Mnohé frakcie nemôže byť reprezentované číslom s určitým konečným počtom bodkočiariek, takže JavaScript môže generovať výsledky, ako napríklad:

0.1 * 0.2; > 0.020000000000000004

V praxi to nebude mať význam, pretože príde na chybu v 2 quinylonne. To však môže ovplyvniť výsledok pri práci s číslami, ktoré predstavujú hodnoty ventilu, percento alebo veľkosť súboru. Preto musíte urobiť alebo až do určitého desatinného znaku.

Zaokrúhlenie desatinných čísel

Na "Trim" sa používajú desatinné číslo, TOFIXED () alebo TOPECIONE (). Obaja si jeden argument, ktorý určuje počet významných a známok po správe, ktorá musí byť zahrnutá do výsledku:

• ak pre Tfixed () nie je definovaný argument, predvolená hodnota je 0, to znamená, že po čiaste nie sú žiadne príznaky; Maximálna hodnota argumentu je 20;
• ak pre TopRecision () Argument nie je špecifikovaný, počet sa nezmení.

var Randnum \u003d 6,25; randnum.tofixed (); \u003e "6" math.pi.topreCision (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"

Poznámka

A TOFIXED () a TOPRECISION vráti zaoblené malé množstvo reprezentácie a nie číslo. To znamená, že pridanie roundted na Randnum bude mať za následok kontinecovaný reťazec, a nie jedno číslo:

console.log (RandNum + zaoblené); \u003e "6.256"

Ak potrebujete získať zaokrúhľovanie Javascriptu na stotiny, použite ParseFloat ():

var Randnum \u003d 6,25; varted \u003d parsefloat (randnum.tofixed (1)); Konzola.log (zaoblené); \u003e 6.3.

tOFIXED () a topRecision () sú tiež užitočné metódy na skrátenie veľkého počtu bodkočiariek. Je vhodné pri práci s číslami, ktoré predstavujú peňažné jednotky:

var wholenum \u003d 1 var dollscents \u003d wholenum.Tofixed (2); Console.log (dollscents); \u003e "1.00"

Upozorňujeme, že ak existuje viac značiek ako zadaný parameter presnosti, TOPRECISION vydá výsledok vo vedeckom formáte:

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

Ako sa vyhnúť chybám pri zaokrúhľovaní desatinných frakcií

V niektorých prípadoch sa vykonáva Tfixed a TopRecision Zaokrúhlenie JavaScriptu 5 na menšiu stranu, nie až do viac:

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

Výsledok vyššie uvedeného príkladu by mal byť 1.01, a nie 1. Ak sa chcete vyhnúť tejto chybe, odporúčam používať exponenciálne čísla:

funkčné kolo (číslo návratu (math.round (hodnota + e "+ desatinály) +" E - "+ Desimanti);)

Aplikácia:

kolo (1.005,2); \u003e 1.01

Ak potrebujete ešte spoľahlivejšie riešenie ako zaokrúhľovanie, je k dispozícii MDN..

Zaokrúhľovanie s epsilonom

Alternatívny spôsob JavaScript zaokrúhlenie až desiaty bol zavedený v ES6 ( tiež známy ako JavaScript 2015). « Stroj EPSILON»Poskytuje rozumnú hranicu chýb pri porovnávaní dvoch plávajúcich bodkkolov. Bez zaokrúhľovania môžu porovnávať výsledky ako nasledovne:

0,1 + 0.2 \u003d\u003d\u003d 0.3\u003e FALSE

Math.epsilon môže byť použitý vo funkcii na získanie správneho porovnania:

funkcia EPECHEST (X, Y) (RETURN MATHY.ABS (X - Y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

Funkcia má dva argumenty: Jeden obsahuje výpočty, druhý očakávaný (zaoblený) výsledok. Vracia porovnanie týchto dvoch parametrov:

ePECTHEST (0.1 + 0.2, 0,3)\u003e TRUE

Všetky moderné prehliadače podporujú ES6 Matematické funkcie. Ale ak potrebujete poskytnúť podporu v starých prehliadačoch, musíte použiť PolyFilla.

Skrátenie desatinných čísel

Všetky metódy prezentované skôr JavaScript zaokrúhlenie až desiaty. Na orezanie kladného počtu až dvoch miest po čiarke, vynásobte ho na 100, žľabu znova a potom získaný výsledok je rozdelený do 100, potrebujete:

funkcia Skrátená (NUM) (návrat Math.TRUNC (Num * 100) / 100;) Skrátené (3.1416)\u003e 3.14

Ak sa vyžaduje viac flexibilnejšie, môžete použiť rozbitý operátor:

funkcia Skrátená (VAR NumpowerConverter \u003d Math.POW (10, DecondPlaces); návrat ~ ~ (num * numpowerconverter) / numpowerconverter;)

Použitím:

var randint \u003d 35.874993; Skrátené (randint, 3); \u003e 35.874.

Zaokrúhlenie na najbližšie číslo

Vykonávať Zaokrúhlenie javascriptu do celkuPoužíva sa math.round ():

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

Poznač si to " polovičné hodnoty", Ako je .5, zaokrúhlené hore."

Zaokrúhlenie nadol na najbližšie celé číslo

Ak chcete zaokrúhliť v menšej strane, použite metódu Math.floor ():

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

Zaokrúhlenie "nadol" má jeden smer pre všetky čísla, vrátane negatívneho. To môže byť reprezentované ako mrakodrap s nekonečným počtom podláh, vrátane pod úrovňou nadácie ( reprezentujúce negatívne čísla). Ak ste vo výťahu medzi suterénnou podlahou 2 a 3 ( Čo zodpovedá hodnote -2,5), Math.floor vás dodá do podlahy -3:

Math.floor (-2,5); \u003e -3.

Ak sa chcete vyhnúť, použite javascript matematiku zaokrúhľovania pomocou Math.TRUNC () podporované vo všetkých moderných prehliadačoch (okrem IE / EDGE.):

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

MDN tiež poskytuje polyFLIPT TROKOVÝCH RÁMCOV NA PODPORU MATHY.TRUGHTU v starom prehliadačoch a.

Zaokrúhlenie až do najbližšieho celého čísla

Ak chcete zaokrúhliť desatinné čísla hore, použite Math.CEIL. Akcia tejto metódy môže byť tiež reprezentovaná ako nekonečný výťah: Math.CEIL je vždy šťastný "hore", bez ohľadu na to, či je číslo negatívne alebo pozitívne:

Math.CEIL (42.23); \u003e 43 Math.CEIL (36.93); \u003e 37 Math.CEIL (-36.93); -36

Zaokrúhlenie na najbližšie viacnásobné číslo

Ak potrebujete zaokrúhliť hodnotu na najbližšie číslo, viacnásobné 5, vytvorte funkciu, ktorá rozdeľuje číslo na 5, zaokrúhľuje a potom násobí výsledok v rovnakej hodnote:

fUNKCIA CYBERTOTO5 (NUM) (RETURN MATHY.ROUND (NUM / 5) * 5;)

Použitím:

rola5 (11); \u003e 10.

Ak chcete vykonať zaokrúhľovanie JavaScriptu až dva znaky, môžete prenášať funkcie ako počiatočné číslo a multiplicitu:

funkcia RoundTomultiple (Num, Viacnásobné) (návrat Math.round (Num / Multiple) * Viacnásobný;)

Ak chcete použiť funkciu, zapnite zaoblené číslo a multiplicitu vo svojom volaní:

varternumber \u003d 11; var viac \u003d 10; Roundtomultiple (inicialnumber, viacnásobný); \u003e 10;

Zaokrúhliť hodnoty len vo veľkom alebo menšom smere, vymeňte v okrúhlej funkcii na strope alebo podlahu.

Väzba na rozsah

Niekedy potrebujete získať hodnotu X, ktorá by mala byť v určitom rozsahu. Potrebujete napríklad hodnotu od 1 do 100, ale získame hodnotu 123. Ak chcete upevniť, môžete použiť min () ( vráti najmenšie čísla) a max ( vracia maximálne povolené číslo).

Použitím:

var lowbound \u003d 1; variť \u003d 100; var numinput \u003d 123; var upnuté \u003d math.max (lowbound, math.min (numinput, hojnosť)); Konzola.log (upnutý); \u003e 100;

Môžete vytvoriť funkciu alebo číslo triedy rozšírenia.