Ahoj milovníci JavaScriptu. Už ste si všimli, že tento jazyk je veľmi neobvyklý a v každej sekcii vyniká svojimi zvláštnosťami a neobvyklými technickými riešeniami. Preto je dnešný príspevok venovaný téme: „Zaokrúhľovanie JavaScriptu“.

Po prečítaní aktuálneho článku sa dozviete, prečo je potrebné zaokrúhľovať čísla, ktoré metódy a vlastnosti v js vykonávajú túto funkciu a ako vyniká delenie číslom 0. Bez toho, aby som zmenil svoje zásady, pripojím príklady ku kľúčovým bodom materiál a podrobne popíšte každú akciu. Teraz sa začnime učiť!

Dôležité poznámky k číslam

Najprv si uvedomte, že v js sú všetky druhy čísel (zlomky a celé čísla) typu Číslo... Navyše sú všetky 64-bitové, pretože sú uložené vo formáte „s dvojitou presnosťou“, ktorý je známy aj ako štandard IEEE-754.

Číselné premenné sa vytvárajú obvyklým spôsobom:

var numb = 35; // prirodzené číslo

var drob = 0,93; // desatinné zobrazenie

var numb16 = 0xFF; // sústava hexadecimálnych čísel

Podporuje aj ďalšie číselné zobrazenia. Stále však môžete vytvárať čísla s pohyblivou rádovou čiarkou (niekedy sa im hovorí aj „čísla vo vedeckom formáte“).

Existuje podpora pre veľmi zaujímavú metódu toLocaleString (), ktorý formátuje všetky číselné parametre podľa špecifikácií uvedených v ECMA 402. Vďaka tomu sa v dialógovom okne krásne zobrazujú veľké čísla, telefónne čísla, meny a dokonca percentá.

var num = 714000,80;

alert (num.toLocaleString ());

Na prácu s prvkami typu Number bol celý globálny objekt vybavený množstvom všetkých druhov matematických funkcií, ktorých názov je Matematika.

Okrem toho existujú aj ďalšie metódy, ktoré zaokrúhľujú číselné hodnoty na celé čísla, desatiny, stotiny atď. Pozrime sa na všetky podrobnejšie.

Skvelá a silná matematika

Globálny matematický objekt obsahuje širokú škálu matematických a trigonometrických funkcií. Jedná sa o veľmi užitočný objekt a často pomáha vývojárom pri práci s digitálnymi údajmi.

Na iných platformách existujú analógie pre matematiku. Napríklad v populárnych jazykoch ako Java a C #je Math trieda, ktorá podporuje všetky rovnaké štandardné funkcie. Ako vidíte, tento nástroj je skutočne skvelý a silný.

Teraz chcem prejsť konkrétnymi metódami zaokrúhľovania a podrobne o nich hovoriť.

Math.floor ()

Začnem s Matematika.poschodie... Dávajte pozor na názov metódy. Logicky je zrejmé, že keďže hovoríme o zaokrúhľovaní a doslovný preklad slova „podlaha“ znamená „podlaha“, tento nástroj zaokrúhli spracované hodnoty nadol.

Je tiež možné, že spracované číslo pomocou tejto funkcie zostane rovnaké. Dôvodom je, že zaokrúhľovanie sa vykonáva podľa nerovnej nerovnosti (<=). Таким образом, при отработке этой строчки кода:

výstraha (Mat. podlaha (4.5));

odpoveď bude číslo 4.

Math.ceil ()

Znova sa pozrite na názov (týmto spôsobom sa materiál absorbuje rýchlejšie). Ak niekto nevie, strop znamená strop. To znamená, že číselné údaje budú zaokrúhlené nahor pomocou voľnej nerovnosti (> =).

výstraha (Math.ceil (4.5));

Ako ste asi uhádli, odpoveďou bude číslo 5.

Math.round ()

Táto metóda zaokrúhli zlomkové číslo na najbližšie celé číslo. Ak je teda zlomková časť v rozsahu od 0 do 0,5, vrátane, potom sa zaokrúhľuje nadol. A ak je zlomková časť v rozsahu od 0,5 vrátane do nasledujúceho celého čísla, zaokrúhli sa nahor na väčšie celé číslo.

alert (Math.round (4.5));

Dúfam, že si každý myslel alebo povedal správnu odpoveď - 5.

Niekoľko ďalších metód

JavaScript má tiež 2 ďalšie metódy, ktoré sa zaoberajú zaokrúhľovaním numerických reprezentácií. Sú však v niečom odlišné.

Reč bude o nástrojoch ako napr toFixed () a toPrecision ()... Zodpovedajú nielen zaokrúhľovanie, ale aj za jeho presnosť voči určitým znakom. Poďme hlbšie.

toFixed ()

Pomocou tohto mechanizmu môžete určiť, koľko desatinných miest má byť hodnota zaokrúhlená. Metóda vráti výsledok ako reťazec. Nižšie som pripojil variant s tromi rôznymi variantmi. Analyzujte odpovede, ktoré ste dostali.

var num = 5656,9393;

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

document.writeln (num.toFixed (2)); // 5656,94

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

Ako vidíte, ak nezadáte argument, funkcia toFixed ()) zaokrúhli zlomkovú hodnotu k celkučísla. Tretí riadok je zaoblený až 2 znaky, a vo štvrtom - kvôli parametru „7“ boli pridané ďalšie tri 0.

toPrecision ()

Táto metóda funguje trochu iným spôsobom. Namiesto argumentu môžete nechať prázdne miesto alebo nastaviť parameter. Ten však zaokrúhli čísla na zadaný počet číslic, pričom čiarku ignoruje. Tu sú výsledky programu prepísaného z predchádzajúceho príkladu:

var num = 5656,9393;

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

document.writeln (num.toPrecision (2)); // 5,7e + 3

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

Funkcia delenia 0 v js

Ako viete z hodín matematiky, nemôžete deliť nulou. Toto pravidlo vzalo za základ väčšina tvorcov programovacích jazykov. Pri delení nulou preto všetky programy generujú chybu.

Aj tu sa však JavaScript vyznamenal. Počas vykonávania takejto operácie sa teda nezobrazia žiadne chybové správy ... pretože taká operácia sa vráti "Nekonečno"!

Prečo je to tak? Ako viete z rovnakých matematických vied, čím menší je deliteľ, tým je číslo väčšie. Preto sa tvorcovia tohto prototypu orientovaného jazyka rozhodli opustiť šablóny a ísť vlastnou cestou.

Pre tých, ktorí sa najskôr stretnú s hodnotou nekonečna, som nižšie vysvetlil jej vlastnosti.

Nekonečno - znamená nekonečno a plne zodpovedá matematickému znaku ∞.

Mohlo by to byť negatívne. Rovnako zostanú zachované všetky štandardné pravidlá pre prácu s aritmetickými operátormi.

výstraha (12/0); // Nekonečno

výstraha (12,34 / 0); // Nekonečno

výstraha (-3 / 0); // -Nekonečno

V tomto pravdepodobne a dokončite. Ak sa vám publikácia páčila, určite sa prihláste na odber môjho blogu. Nebuďte chamtiví s odkazmi na zaujímavé články a podeľte sa o ne so svojimi priateľmi. Zbohom!

Matematika JavaScript, zaokrúhlená na 2 desatinné miesta (9)

Mám nasledujúcu syntax JavaScriptu:

Var zľava = Math.round (100 - (cena / cenník) * 100);

Toto sa zaokrúhli na najbližšie celé číslo. Ako môžem vrátiť výsledok s dvoma desatinnými miestami?

Tu je pracovný príklad

Hodnota varu = 200,2365455; result = Math.round (hodnota * 100) / 100 // výsledok bude 200,24

Na zvládnutie zaokrúhľovania na ľubovoľný počet desatinných miest postačí pre väčšinu potrieb funkcia s 2 riadkami kódu. Tu je niekoľko ukážkových kódov k hre.

Var testNum = 134,9567654; var decPl = 2; var testRes = roundDec (testNum, decPl); alert (testNum + "zaokrúhlené na" + decPl + "desatinné miesta je" + testRes); funkcia roundDec (nbr, dec_places) (var mult = Math.pow (10, dec_places); return Math.round (nbr * mult) / mult;)

Najlepším a najjednoduchším riešením, ktoré som našiel, je

Funkcia zaokrúhlená (hodnota, desatinné miesta) (návratové číslo (matemat. Kolo (hodnota + "e" + desatinné miesta) + "e -" + desatinné miesta);) okrúhle (1,005, 2); // 1.01

Mierna variácia prijatej odpovede. toFixed (2) vráti reťazec a vždy dostanete dve desatinné miesta. Môžu to byť nuly. Ak chcete potlačiť koncové nuly, postupujte takto:

Var zľava = + ((cena / cenník) .toFixed (2));

Upravené: Práve som zistil, čo sa zdá byť chybou vo Firefoxe 35.0.1, čo znamená, že vyššie uvedené môže NaN poskytnúť určité hodnoty.
Zmenil som kód na

Var zľava = Math.round (cena / cenník * 100) / 100;

Toto číslo dáva dve desatinné miesta. Ak potrebujete tri, vynásobíte a delíte 1000 atď.
OP chce vždy dve desatinné miesta, ale ak je funkcia toFixed () vo Firefoxe poškodená, je potrebné ju najskôr opraviť.
Pozri https://bugzilla.mozilla.org/show_bug.cgi?id=1134388

Ak chcete získať výsledok s dvoma desatinnými miestami, môžete urobiť nasledovné:

Var zľava = Math.round ((100 - (cena / cenník) * 100) * 100) / 100;

Hodnota, ktorá sa má zaokrúhliť, sa vynásobí 100, aby zostali prvé dve číslice, potom vydelíme 100, aby sme získali skutočný výsledok.

Myslím, že najlepší spôsob, ktorý som videl, je vynásobiť 10 číslicami, potom urobiť Math.round a nakoniec deliť 10 počtom číslic. Tu je jednoduchá funkcia, ktorú používam v strojopise:

Funkcia roundToXDigits (hodnota: číslo, číslice: číslo) (hodnota = hodnota * Math.pow (10, číslic); hodnota = Math.round (hodnota); hodnota = hodnota / Math.pow (10, číslic); návratová hodnota; )

Alebo jednoduchý javascript:

Funkcia roundToXDigits (hodnota, číslice) (ak (! Číslice) (číslice = 2;) hodnota = hodnota * Math.pow (10, číslic); hodnota = Math.round (hodnota); hodnota = hodnota / Math.pow (10 , číslice); návratová hodnota;)

POZNÁMKA. - Ak je dôležitá trojciferná presnosť, pozrite si časť Úprava 4.

Var zľava = (cena / cenová cena) .toOpravené (2);

toFixed zaokrúhľuje nahor alebo nadol za vás na základe hodnôt väčších ako 2 desatinné miesta.

Zmeniť. Ako uviedli iní, výsledok sa skonvertuje na reťazec. Aby ste tomu zabránili:

Var zľava = + ((cena / cena) .toOpravené (2));

Úprava 2- Ako je uvedené v komentároch, táto funkcia nie je vykonaná s určitou presnosťou, napríklad v prípade 1,005 vráti 1,00 namiesto 1,01. Ak je presnosť taká dôležitá, našiel som túto odpoveď: https: //.com/a/32605063/1726511, ktorá vyzerá, že funguje dobre so všetkými testami, ktoré som vyskúšal.

Vyžaduje sa jedna menšia úprava, ale funkcia v odpovedi vyššie vráti celé čísla, keď sa zaokrúhli na jednu, takže napríklad 99,004 vráti 99 namiesto 99,00, čo nie je ideálne na zobrazenie cien.

Upraviť 3- Zdá sa, že toFixed na skutočnom návrate STÁLE prekrútil niektoré čísla, zdá sa, že táto konečná úprava funguje. Preboha, toľko reparácií!

Var zľava = roundTo ((cena / cenová cena), 2); funkcia 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) / multiplicator); return + (test.toFixed (digits));)

Upraviť 4"Chlapci, zabíjate ma." Úprava 3 zlyhá pri záporných číslach bez toho, aby sa zaoberal tým, prečo je jednoduchšie zaokrúhliť záporné číslo a potom ho vrátiť späť, kým nevrátite výsledok.

Funkcia roundTo (n, digits) (var negative = false; if (digits === undefined) (digits = 0;) if (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 DECALILY

x = .123456 result = Math.round (x * 100) / 100 // result .12

TRI DEKIMALITY

x = .123456 result = Math.round (x * 1000) / 1000 // result .123

Funkcia zaokrúhlená (num, dec) (num = math.round (num + "e" + dec) návratové číslo (num + "e -" + dec)) // Zaokrúhlenie na desatinné miesto podľa vášho výberu: okrúhle (1,3453,2 )

Ahoj. Dnes sa v stĺpci na Javascripte pozrieme na to, ako v JavaScripte nastaviť počet desatinných miest v číslach s pohyblivou rádovou čiarkou. Napríklad vo výstupe musíte nechať 3 desatinné miesta, alebo iba dve.

Problém: desatinné miesta JavaScript

Stojíme teda pred úlohou: existuje výsledok výpočtu, v ktorom sú čísla pred desatinnou čiarkou a za desatinnou čiarkou. Desatinné. Povedzme, že výsledok je takýto 1538.9891200153. Ale pri výbere by ste mali dostať číslo, ktoré odzrkadľuje sumu, kde je počet bankoviek na desatinnú čiarku a po - kopecks.

Existuje niekoľko spôsobov, ako tento problém vyriešiť.

Riešenie 1: Javascriptové desatinné miesta pomocou metódy toFixed

toFixed je vstavaná metóda javascript, ktorá sa používa na ľubovoľné číslo a ako parameter berie presnosť zaokrúhľovania (tj. počet desatinných miest).

Číslo varu = 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;

Parameter presnosti v tejto funkcii nesmie byť menší ako 0 (neakceptuje záporné hodnoty) a nesmie byť väčší ako 20.

Môžete sa tiež zaobísť bez premennej, napríklad takto:

Num_str = (1538,9891200153) .toFixed (2); //num_str=1538,98;

Riešenie 2: Javascriptové desatinné miesta pomocou metódy toPrecision

Toto riešenie je založené na rovnakej vstavanej metóde javascript. Charakteristickou črtou tejto metódy je, že parameter považovaný za vstup neznamená presnosť (počet číslic za desatinnou čiarkou), ale celkový počet číslic (pred aj za desatinnou čiarkou).

Číslo varu = 1538,9891200153; num_str = num.toPrecision (5); //num_str=1538.9; num_str = num.toPrecision (7); //num_str=1538.989;

Riešenie desatinnej čiarky: javascriptový počet desatinných miest

Ak potrebujete úplne zahodiť desatinné miesta, to znamená, že musíte zaokrúhliť zlomkové číslo na celé číslo, potom môžete použiť funkcie triedy Matematika: okrúhle, stropné a podlahové.
Okrúhle - zaokrúhľuje nahor alebo nadol (v závislosti od počtu). Ak je hodnota za desatinnou čiarkou väčšia ako polovica, zaokrúhli sa nahor, ak je menšia - nadol. To znamená, že ak 0,51 - stane sa 1, ak 0,49 - 0.

Ceil - z angličtiny. strop sa vždy zaokrúhľuje.

Poschodie - z angl. podlaha sa vždy zaokrúhľuje nadol.

Číslo varu = 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;

To je všetko. Dúfam, že vám tento príspevok pomohol vyriešiť problém. Ak niečo nefungovalo - položte otázky pomocou zeleného tlačidla „Položiť otázku špecialistovi“ alebo v komentároch.

Výpočty často prinášajú výsledky, ktoré nepatria do požadovaných rozsahov. V dôsledku toho musíte vykonať Zaokrúhľovanie JavaScriptu na určitú hodnotu.

Prečo zaokrúhľovať čísla?

JavaScript neukladá celé čísla, pretože ich hodnoty sú reprezentované ako čísla s pohyblivou rádovou čiarkou. Mnoho zlomkov nemôže byť reprezentovaných konečným počtom desatinných miest, takže JavaScript môže generovať výsledky ako je uvedené nižšie:

0.1 * 0.2; > 0.020000000000000004

V praxi to nebude mať žiadny význam, pretože hovoríme o chybe 2 kvintilóny. To však môže ovplyvniť výsledok pri práci s číslami, ktoré predstavujú hodnoty meny, percentá alebo veľkosť súboru. Preto musíte urobiť alebo na určité desatinné miesto.

Zaokrúhľovanie desatinných čísel

Na „orezanie“ desatinného čísla použite metódy toFixed () alebo toPrecision (). Obaja uvádzajú jeden argument, ktorý určuje počet platných a desatinných miest, ktoré majú byť zahrnuté do výsledku:

• ak pre toFixed () nie je zadaný žiadny argument, predvolená hodnota je 0, to znamená žiadne desatinné miesta; maximálna hodnota argumentu je 20;
• ak pre toPrecision () nie je zadaný žiadny argument, číslo sa nezmení.

var randNum = 6,25; randNum.toFixed (); > "6" Math.PI.toPrecision (1); > "3" var randNum = 87,335; randNum.toFixed (2); > "87,33" var randNum = 87,337; randNum.toPrecision (3); > "87,3"

Poznámka

ToFixed () aj toPrecision vracajú zaokrúhlený reťazec reprezentujúci výsledok, nie číslo. To znamená, že pridanie zaokrúhleného k randNum bude mať za následok skôr zreťazenie reťazcov než jedno číslo:

console.log (randNum + zaoblené); > "6,256"

Ak chcete, aby sa JavaScript zaokrúhlil na najbližšiu stotinu, použite parseFloat ():

var randNum = 6,25; var zaoblené = parseFloat (randNum.toFixed (1)); console.log (zaoblené); > 6,3

ToFixed () a toPrecision () sú tiež užitočné metódy na skrátenie veľkého počtu desatinných miest. Je to užitočné pri práci s číslami, ktoré predstavujú peňažné jednotky:

var wholeNum = 1 var dolárovCents = wholeNum.toFixed (2); console.log (dolárovCenty); > "1,00"

Upozorňujeme, že ak je v čísle viac číslic, ako je uvedené v parametri presnosti, funkcia toPrecision vráti výsledok vo vedeckom formáte:

var num = 123,435 num.toPrecision (2); > „1,2e + 2“

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

V niektorých prípadoch implementujú nástroje toFixed a toPrecision Zaokrúhľovanie JavaScriptu nadol 5 a nie viac:

var numTest = 1,005; numTest.toFixed (2); > 1;

Vyššie uvedený príklad by mal mať za následok 1,01, nie 1. Ak sa chcete tejto chybe vyhnúť, odporúčam použiť exponenciálne čísla:

zaokrúhlenie funkcie (hodnota, desatinné miesta) (návratové číslo (matematická hodnota (hodnota + "e" + desatinné miesta) + "e -" + desatinné miesta);)

Aplikácia:

okrúhle (1,005,2); > 1,01

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

Zaokrúhľovanie Epsilon

Alternatívna metóda Zaokrúhľovanie JavaScriptu na desatiny bol predstavený v ES6 ( známy aj ako JavaScript 2015). « Strojový epsilon»Poskytuje primeranú chybovosť pri porovnaní dvoch čísel s pohyblivou rádovou čiarkou. Bez zaokrúhľovania môžu porovnania priniesť výsledky podobné nasledujúcim:

0,1 + 0,2 === 0,3> nepravda

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

funkcia epsEqu (x, y) (návrat Math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

Funkcia má dva argumenty: jeden obsahuje výpočty, druhý je očakávaný (zaokrúhlený) výsledok. Vráti porovnanie týchto dvoch parametrov:

epsEqu (0,1 + 0,2, 0,3)> pravda

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

Skrátenie desatinných čísel

Vykonávajú sa všetky predtým uvedené metódy Zaokrúhľovanie JavaScriptu na desatiny... Ak chcete skrátiť kladné číslo na dve desatinné miesta, vynásobte ho číslom 100, znova skráťte a potom výsledok delte 100, potrebujete:

funkcia skrátená (num) (návrat Math.trunc (num * 100) / 100;) skrátená (3.1416)> 3,14

Ak potrebujete niečo flexibilnejšie, môžete použiť bitový operátor:

funkcia skrátená (num, decimalPlaces) (var numPowerConverter = Math.pow (10, decimalPlaces); návrat ~~ (num * numPowerConverter) / numPowerConverter;)

Použitie:

var randInt = 35,8874993; skrátený (randInt, 3); > 35,874

Zaokrúhľuje sa na najbližšie číslo

Vykonávať Zaokrúhľovanie JavaScriptu na celé číslo, používa Math.round ():

Matematický kruh (4,3)> 4 Matematický kruh (4,5)> 5

Poznač si to " polovičné hodnoty"Napríklad 0,5 sa zaokrúhľuje."

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

Ak chcete zaokrúhliť nadol, použite metódu Math.floor ():

Mat.podlaha (42,23); > 42 matematická podlaha (36,93); > 36

Zaokrúhľovanie nadol má jeden smer pre všetky čísla vrátane záporných. To si možno predstaviť ako mrakodrap s nekonečným počtom poschodí, vrátane pod úrovňou základu ( reprezentujúce záporné čísla). Ak ste vo výťahu medzi suterénom 2 a 3 ( čo zodpovedá hodnote -2,5), Math.floor vás zavedie na poschodie -3:

Mat.podlaha (-2,5); > -3

Ak sa tomu chcete vyhnúť, použite zaokrúhľovanie matematiky JavaScript s Math.trunc (), ktorý je podporovaný vo všetkých moderných prehliadačoch (okrem IE / Edge):

Math.trunc (-41,43); > -41

MDN tiež poskytuje Trojriadkový polyfill, ktorý poskytuje podporu Math.trunc v starších prehliadačoch a IE / Edge.

Zaokrúhlite nahor na najbližšie celé číslo

Ak chcete zaokrúhliť desatinné čísla nahor, použite Math.ceil. Túto metódu možno tiež považovať za nekonečný vzostup: Math.ceil vás vždy vezme hore, bez ohľadu na to, či je číslo záporné alebo kladné:

Math.ceil (42,23); > 43 Mat.ceil (36,93); > 37 Mat.hmotnosť (-36,93); -36

Zaokrúhlite na najbližší násobok

Ak potrebujete zaokrúhliť hodnotu na najbližší násobok 5, vytvorte funkciu, ktorá číslo vydelí 5, zaokrúhli a potom výsledok vynásobí rovnakou hodnotou:

funkcia roundTo5 (num) (návrat Math.round (num / 5) * 5;)

Použitie:

roundTo5 (11); > 10

Ak potrebujete, aby bol JavaScript zaokrúhlený na dve číslice, môžete tejto funkcii odovzdať jadro aj multiplicitu:

funkcia roundToMultiple (počet, násobok) (návrat matemat. okr. (počet / násobok) * násobok;)

Ak chcete použiť túto funkciu, zadajte číslo, ktoré má byť zaokrúhlené, a násobnosť jeho volania:

var initialNumber = 11; var násobok = 10; roundToMultiple (initialNumber, násobok); > 10;

Ak chcete hodnoty zaokrúhľovať iba nahor alebo nadol, nahraďte zaokrúhlenie stropom alebo podlahou.

Cvaknutie rozsahu

Niekedy potrebujete získať hodnotu x, ktorá musí byť v určitom rozmedzí. Potrebujeme napríklad hodnotu od 1 do 100, ale dostaneme hodnotu 123. Na vyriešenie tohto problému je možné použiť min () ( vráti najmenšie z čísel) a max ( vráti maximálny povolený počet).

Použitie:

var lowBound = 1; var highBound = 100; var numInput = 123; var clamped = Math.max (lowBound, Math.min (numInput, highBound)); console.log (upnuté); > 100;

Môžete vytvoriť funkciu alebo rozšírenie triedy Number.

Výpočty v jazyku JavaScript často neposkytujú požadované výsledky. S číslami samozrejme môžeme urobiť čokoľvek - zaokrúhliť nahor alebo nadol, nastaviť rozsahy, orezať nepotrebné čísla na určitý počet desatinných miest, všetko závisí od toho, čo s týmto číslom chcete v budúcnosti robiť.

Prečo je zaokrúhľovanie nevyhnutné?

Jeden zo zvláštnych aspektov JavaScriptu je, že v skutočnosti neukladá celé čísla, okamžite pracujeme s číslami s pohyblivou rádovou čiarkou. V kombinácii so skutočnosťou, že mnoho zlomkových hodnôt nemožno vyjadriť konečným počtom desatinných miest, v JavaScripte môžeme získať výsledky takto:

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Z praktických dôvodov táto nepresnosť vôbec nevadí, v našom prípade hovoríme o chybe v kvintilónoch častí, niekoho to však môže sklamať. Trochu zvláštny výsledok môžeme získať pri práci s číslami, ktoré predstavujú hodnoty mien, percent alebo veľkostí súborov. Aby sme opravili tieto nepresnosti, musíme byť schopní zaokrúhliť výsledky, pričom stačí nastaviť desatinnú presnosť.

Zaokrúhľovanie čísel má praktickú aplikáciu, môžeme manipulovať s číslom v určitom rozsahu, napríklad chceme hodnotu zaokrúhliť na najbližšie celé číslo a nepracovať iba s desatinnou časťou.

Zaokrúhlenie desatinných čísel

Ak chcete odstrániť desatinné číslo, použite metódu toFixed alebo toPrecision. Obaja berú jeden argument, ktorý určuje, koľko platných číslic (t. J. Celkový počet číslic použitých v čísle) alebo desatinných miest (číslo za desatinnou čiarkou), ktorý má výsledok obsahovať:

1. Ak argument nie je definovaný pre toFixed (), potom bude predvolene nula, čo znamená 0 ​​desatinných miest, argument má maximálnu hodnotu 20.
2. Ak pre toPrecision nie je zadaný žiadny argument, číslo zostane nedotknuté

nech 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"
ToFixed () aj toPrecision () vracajú reťazcovú reprezentáciu výsledku, nie číslo. To znamená, že keď sa zaokrúhlená hodnota sčíta s randNum, zreťazia sa reťazce, nie súčet čísel:

Nech randNum = 6,25; nechať zaokrúhliť = randNum.toFixed (); // "6" console.log (randNum + zaoblené); > "6,256"
Ak chcete, aby výsledok mal numerický typ údajov, budete musieť použiť parseFloat:

Nech randNum = 6,25; nech zaokrúhli = parseFloat (randNum.toFixed (1)); console.log (zaoblené); > 6,3
Všimnite si toho, že 5 hodnôt je zaokrúhlených okrem výnimočných prípadov.

Metódy toFixed () a toPrecision () sú užitočné, pretože môžu nielen odstrániť zlomkovú časť, ale aj doplniť desatinné miesta, čo je výhodné pri práci s menou:

Nech celé číslo = 1 nechajte doláre centy = celé číslo.toFixované (2); console.log (dolárovCenty); > "1,00"
Upozorňujeme, že toPrecision poskytne výsledok v exponenciálnom zápise, ak je počet celých čísel vyšší ako samotná presnosť:

Nech num = 123,435 num.toPrecision (2); > „1,2e + 2“

Ako sa vyhnúť chybám zaokrúhľovania s desatinnými číslami

V niektorých prípadoch toFixed a toPrecision zaokrúhľuje 5 nadol a hore:

Nech numTest = 1,005; numTest.toFixed (2); > "1,00"
Vyššie uvedený výsledok výpočtu mal byť 1,01, nie 1. Ak sa chcete tejto chybe vyhnúť, môžeme použiť riešenie navrhnuté Jackom L Moorom, ktoré na výpočet používa exponenciálne čísla:

Zaokrúhlenie funkcie (hodnota, desatinné miesta) (návratové číslo (matematická hodnota (hodnota + "e" + desatinné miesta) + "e -" + desatinné miesta);)
Teraz:

Okrúhle (1,005,2); > 1,01
Ak chcete robustnejšie riešenie, ako je uvedené vyššie, môžete prejsť na MDN.

Strojové zaoblenie epsilon

V ES6 bol zavedený alternatívny spôsob zaokrúhľovania desatinných čísel. Zaokrúhľovanie strojného epsilonu poskytuje primeranú chybovosť pri porovnaní dvoch čísel s pohyblivou rádovou čiarkou. Bez zaokrúhľovania môžu porovnania priniesť výsledky podobné nasledujúcim:

0,1 + 0,2 === 0,3> nepravda
Na získanie správneho porovnania používame v našej funkcii Math.EPSILON:

Funkcia epsEqu (x, y) (návrat Math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Funkcia má dva argumenty: prvý je aktuálny výpočet a druhý je očakávaný výsledok. Vráti porovnanie týchto dvoch:

EpsEqu (0,1 + 0,2, 0,3)> pravda
Všetky moderné prehliadače už podporujú matematické funkcie ES6, ale ak chcete podporu v prehliadačoch, ako je IE 11, použite polyfills.

Skrátenie frakčnej časti

Všetky vyššie uvedené metódy vedia, ako zaokrúhliť na desatinné čísla. Aby ste číslo jednoducho orezali na dve desatinné miesta, musíte ho najskôr vynásobiť 100 a potom výsledok rozdeliť 100:

Funkcia skrátená (num) (návrat Math.trunc (num * 100) / 100;) skrátená (3.1416)> 3,14
Ak chcete metódu prispôsobiť ľubovoľnému počtu desatinných miest, môžete použiť dvojitú bitovú negáciu:

Funkcia skrátená (num, decimalPlaces) (nech numPowerConverter = Math.pow (10, decimalPlaces); návrat ~~ (num * numPowerConverter) / numPowerConverter;)
Teraz:

Nech randInt = 35,8874993; skrátený (randInt, 3); > 35,874

Zaokrúhľuje sa na najbližšie číslo

Ak chcete zaokrúhliť desatinné číslo nahor alebo nadol, podľa toho, čo je najbližšie, použite Math.round ():

Matematický kruh (4,3)> 4 Matematický kruh (4,5)> 5
Všimnite si toho, že „polovica hodnoty“, 0,5, sa zaokrúhľuje nahor podľa matematických pravidiel.

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

Ak chcete vždy zaokrúhľovať nadol, použite Math.floor:

Mat.podlaha (42,23); > 42 matematická podlaha (36,93); > 36
Všimnite si toho, že zaokrúhľovanie nadol funguje pre všetky čísla vrátane záporných. Predstavte si mrakodrap s nekonečným počtom poschodí vrátane tých na nižšej úrovni (predstavujúce záporné čísla). Ak ste vo výťahu na nižšej úrovni medzi 2 a 3 (čo je hodnota -2,5), Math.floor vás dovedie až na -3:

Mat.podlaha (-2,5); > -3
Ak sa však chcete tejto situácii vyhnúť, použite Math.trunc, ktorý je podporovaný vo všetkých moderných prehliadačoch (okrem IE / Edge):

Math.trunc (-41,43); > -41
Na MDN nájdete polyfill, ktorý bude poskytovať podporu pre Math.trunc v prehliadačoch a IE / Edge.

Zaokrúhlite nahor na najbližšie celé číslo

Na druhej strane, ak potrebujete vždy zaokrúhliť, použite Math.ceil. Opäť si pamätáme na nekonečný zdvih: Math.ceil vždy pôjde hore, bez ohľadu na to, či je číslo záporné alebo nie:

Math.ceil (42,23); > 43 Mat.ceil (36,93); > 37 Mat.hmotnosť (-36,93); > -36

Zaokrúhľuje sa hore / dole podľa potreby

Ak chceme zaokrúhliť na najbližší násobok 5, najjednoduchší spôsob je vytvoriť funkciu, ktorá číslo delí 5, zaokrúhli a potom vynásobí rovnakou sumou:

Funkcia roundTo5 (num) (návrat Math.round (num / 5) * 5;)
Teraz:

RoundTo5 (11); > 10
Ak chcete zaokrúhliť na násobky svojej hodnoty, používame všeobecnejšiu funkciu, ktorá zadá počiatočnú hodnotu a násobok:

Funkcia roundToMultiple (počet, násobok) (návrat matemat. Okr. (Počet / násobok) * násobok;)
Teraz:

Nech initialNumber = 11; nech násobok = 10; roundToMultiple (initialNumber, násobok); > 10;

Oprava čísla v rozsahu

Existuje mnoho prípadov, keď chceme dostať x v rámci rozsahu. Napríklad môžeme chcieť hodnotu medzi 1 a 100, ale dostali sme hodnotu 123. Na vyriešenie tohto problému môžeme použiť min (vráti najmenšie zo sady čísel) a max (vráti najväčšie zo všetkých množín čísel ). V našom prípade je rozsah od 1 do 100:

Nech je lowBound = 1; nechajte highBound = 100; nech numInput = 123; let clamped = Math.max (lowBound, Math.min (numInput, highBound)); console.log (upnuté); > 100;
Opäť môžeme operáciu znova použiť a celú vec zabaliť do funkcie, použime riešenie navrhnuté Danielom X. Moorom:

Number.prototype.clamp = funkcia (min, max) (návrat Math.min (Math.max (this, min), max););
Teraz:

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

Gaussovské zaokrúhľovanie

Gaussovské zaokrúhľovanie, známe tiež ako bankové zaokrúhľovanie, je miesto, kde dochádza k zaokrúhľovaniu na najbližšiu párnosť. Táto metóda zaokrúhľovania funguje bez štatistických chýb. Najlepšie riešenie navrhol Tim Down:

Funkcia gaussRound (num, decimalPlaces) (nech d = decimalPlaces || 0, m = Math.pow (10, d), n = + (d? Num * m: num). ToFixed (8), i = Math.floor (n), f = n - i, 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; }
Teraz:

GaussRound (2,5)> 2 gaussRound (3,5)> 4 gaussRound (2,57,1)> 2,6
Desatinná čiarka v CSS:

Pretože JavaScript sa často používa na vytváranie polohových transformácií prvkov HTML, môže vás zaujímať, čo sa stane, ak pre naše prvky vygenerujeme desatinné hodnoty:

#box (šírka: 63,667731993px;)
Dobrou správou je, že moderné prehliadače budú v boxovom modeli brať do úvahy desatinné hodnoty vrátane percentuálnych alebo pixelových jednotiek.

Triedenie

Veľmi často musíme niektoré prvky triediť, napríklad máme množstvo herných záznamov a musia byť usporiadané zostupne podľa poradia hráčov. Metóda štandardného triedenia () má bohužiaľ niekoľko prekvapivých obmedzení: funguje dobre s bežne používanými anglickými slovami, ale okamžite sa rozbije, keď sa stretnete s číslami, jedinečnými znakmi alebo veľkými slovami.

Zoradiť podľa abecedy

Zdá sa, že abecedné zoradenie poľa by malo byť najjednoduchšou úlohou:

Nechajte ovocie = ["maslová tekvica", "marhuľa", "melón"]; fruit.sort (); > „marhuľa“, „maslová tekvica“, „melón“]
Narážame však na problém, akonáhle je jeden z prvkov veľký:

Nechajte ovocie = ["maslová tekvica", "marhuľa", "cantalope"]; fruit.sort (); > „Cantaloupe“, „marhuľa“, „maslová tekvica“]
Dôvodom je to, že zoraďovač v predvolenom nastavení porovnáva prvý znak reprezentovaný v Unicode. Unicode je jedinečný kód pre akýkoľvek znak, bez ohľadu na platformu, bez ohľadu na program, bez ohľadu na jazyk. Ak sa napríklad pozriete do tabuľky kódov, znak „a“ má hodnotu U + 0061 (v hexadecimálnom systéme 0x61), zatiaľ čo znak „C“ má kód U + 0043 (0x43), ktorý je na začiatku písmena Tabuľka Unicode ako znak „A“.

Aby sme zoradili pole, ktoré môže obsahovať zmiešané veľké písmená prvých písmen, musíme buď všetky prvky dočasne previesť na malé písmená, alebo definovať vlastné poradie zoradenia pomocou metódy localeCompare () s niektorými argumentmi. Spravidla je v takom prípade lepšie okamžite vytvoriť funkciu na opakované použitie:

Funkcia alphaSort (arr) (arr.sort (funkcia (a, b) (návrat a.localeCompare (b, "en", ("citlivosť": "základňa"));));) nechať ovocie = ["maslová tekvica "," marhuľa "," Cantaloupe "]; alphaSort (ovocie)>
Ak chcete zoradiť pole v opačnom abecednom poradí, stačí prehodiť pozície a a b vo funkcii:

Funkcia alphaSort (arr) (arr.sort (funkcia (a, b) (návrat b.localeCompare (a, "en", ("citlivosť": "základňa"));));) nechať ovocie = ["maslová tekvica "," marhuľa "," Cantaloupe "]; alphaSort (ovocie)> [„Cantaloupe“, „maslová tekvica“, „marhuľa“]
Tu stojí za zmienku, že localeCompare sa používa s argumentmi, musíte tiež pamätať na to, že je podporovaný IE11 +, pre staršie verzie IE ho môžeme použiť bez argumentov a malými písmenami:

Function caseSort (arr) (arr.sort (function (a, b) (return a.toLowerCase (). LocaleCompare (b.toLowerCase ());)));) let fruit = ["butternut squash", "apricot", "Cantaloupe"]; caseSort (ovocie)> ["marhuľa", "maslová tekvica", "melón"]

Číselné triedenie

To všetko neplatí pre príklad, o ktorom sme hovorili vyššie o rade herných záznamov. Pri niektorých numerických poliach triedenie funguje dobre, ale v určitom okamihu môže byť výsledok nepredvídateľný:

Nechajte vysoké skóre =; highScores.sort (); >
Faktom je, že metóda sort () vykonáva lexikografické porovnanie: čo znamená, že čísla budú prevedené na reťazec a porovnania sa budú vykonávať znova porovnaním prvého znaku tohto reťazca v poradí znakov tabuľky Unicode. Preto musíme znova definovať naše poradie zoradenia:

Nechajte vysoké skóre =; highScores.sort (funkcia (a, b) (návrat a - b;)); >
Ak chcete znova zoradiť čísla v opačnom poradí, prehoďte pozície a a b vo funkcii.

Zoradenie štruktúry podobnej JSON

Nakoniec, ak máme dátovú štruktúru podobnú formátu JSON, reprezentovanú ako pole herných záznamov:

Nechajme skóre = [("meno": "Daniel", "skóre": 21768), ("meno": "Michael", "skóre": 33579), ("meno": "Alison", "skóre": 38395 )];
V ES6 +môžete používať šípkové funkcie:

Scores.sort ((a, b) => b.score - a.score));
Pre staršie prehliadače, ktoré túto podporu nemajú:

Scores.sort (funkcia (a, b) (návrat a.score - b.score));
Ako vidíte, triedenie v JavaScripte nie je samozrejmosťou, dúfam, že tieto príklady nejako uľahčia život.

Práca s výkonovými funkciami

Umocnenie je operácia pôvodne definovaná ako výsledok viacnásobného násobenia prirodzeného čísla samého seba, druhá odmocnina z a je číslo, ktoré dáva, keď je druhá mocnina. Tieto funkcie by sme mohli používať neustále v každodennom živote na hodinách matematiky, vrátane výpočtov plôch, objemov alebo dokonca vo fyzickom modelovaní.

V JavaScripte je exponenciálna funkcia reprezentovaná ako Math.pow (), v novom štandarde ES7 je zavedený nový operátor umocnenia - „ * *“.

Umocnenie

Na zvýšenie čísla na n -tú mocninu použite funkciu Math.pow (), kde prvým argumentom je číslo, ktoré sa má zvýšiť na mocninu, druhým argumentom je exponent:

Math.pow (3,2)> 9
Táto forma zápisu znamená 3 na druhú alebo 3 × 3, čo vedie k výsledku 9. Môžete uviesť ďalší príklad, samozrejme:

Math.pow (5,3); > 125
To znamená, že 5 kociek alebo 5 × 5 × 5 sa rovná 125.

ECMAScript 7 je ďalšou verziou JavaScriptu, v zásade môžeme použiť nový navrhovaný operátor umocnenia - * *, táto forma zápisu môže byť popisnejšia:

3 ** 2 > 9
V súčasnosti je podpora tohto operátora dosť obmedzená, preto sa neodporúča používať ho.

Výkonová funkcia môže byť užitočná v rôznych situáciách. Jednoduchý príklad, ako vypočítať počet sekúnd za hodinu: Math.pow (60,2).

Odmocnina a kocka

Math.sqrt () a Math.cbrt () sú opakom funkcie Math.pow (). Pamätajte si, že druhá odmocnina a je číslo, ktoré dáva, keď je druhá mocnina.

Math.sqrt (9)> 3
Kocka odmocniny čísla a je zároveň číslo, ktoré dáva a, keď sa zvýši na kocku.

Math.cbrt (125)> 5
Math.cbrt () bol do špecifikácie JavaScript zavedený veľmi nedávno, a preto je podporovaný iba v moderných prehliadačoch: Chrome 38+, Firefox a Opera 25+ a Safari 7.1+. Všimnete si, že Internet Explorer nie je v tomto zozname, ale na MDN nájdete polyfill.

Príklady

V jednej z týchto funkcií môžeme samozrejme použiť aj iné ako celočíselné hodnoty:

Math.pow (1,25, 2); > 1,5625 Math.cbrt (56,57)> 3,8387991760286138
Všimnite si toho, že to funguje aj pre negatívne hodnoty argumentov:

Mat.pow (-5,2)> 25 Math.pow (10, -2)> 0,01
Pre odmocninu to však nebude fungovať:

Mat.sqrt (-9)> NaN
Z matematickej analýzy vieme, že imaginárnym číslom sa rozumejú odmocniny záporných čísel. A to nás môže priviesť k ďalšej technike práce s komplexnými číslami, ale to je iný príbeh.

V Math.pow () môžete použiť zlomkové hodnoty na nájdenie odmocninových a kockových koreňov čísel. Druhá odmocnina používa exponent 0,5:

Math.pow (5, 0,5); // = Math.sqrt (5) = 5 ** (1/2)> 2,23606797749979
Avšak kvôli rozmarom s pohyblivou rádovou čiarkou nemôžete presne uhádnuť správny výsledok:

Math.pow (2.23606797749979.2)> 5.000000000000001
V takýchto situáciách sa budete musieť uchýliť k skráteniu znakov z čísla alebo zaokrúhleniu na určitú hodnotu.

Niektorí si z neznámeho dôvodu v JavaScripte mýlia funkciu Math.pow () s Math.exp (), čo je exponenciálna funkcia pre čísla vo všeobecnosti. Poznámka: v angličtine sa „exponent“ prekladá ako „exponent“, takže je pravdepodobnejšie, že sa bude vzťahovať na anglicky hovoriacich, aj keď pre exponent existujú alternatívne názvy, ako napríklad index, power.

Matematické konštanty

Prácu s matematikou v JavaScripte uľahčuje množstvo vstavaných konštánt. Tieto konštanty sú vlastnosťami matematického objektu. Stojí za zmienku, že konštanty sú písané veľkými písmenami, nie notáciou CamelCase.

Math.abs, parseInt, parseFloat

Práca s číslami v JavaScripte môže byť oveľa komplikovanejšia, ako sa zdá. Získané hodnoty nie vždy spadajú do očakávaných rozsahov, niekedy výsledok nemusí byť vôbec taký, ako sme očakávali.

Math.abs ()

Metóda Math.abs () vracia absolútnu hodnotu čísla, ktorá nám pripomína analogickú matematickú funkciu pre modul čísla.

Nech newVal = -57,64; Math.abs (newVal); > 57,64
Math.abs (0) vždy vráti nulu, ale ak pred funkciu -Math.abs (NUM) dáme znamienko mínus, budeme vždy záporní.

Math.abs (0); > -0

parseInt ()

Vieme, že JavaScript chápe, že „15“ je reťazec, nie číslo, a napríklad pri analýze vlastností CSS pomocou JavaScriptu alebo získaní určitej hodnoty z nepripraveného poľa môžu byť naše výsledky nepredvídateľné. Ako vstup sme mohli dostať reťazec reprezentovaný ako „17 pixlov“, a to pre nás nie je neobvyklé. Otázkou je, ako previesť tento reťazec na skutočnú hodnotu a použiť ho v ďalších výpočtoch.

Syntax: parseInt (reťazec, radix);

Funkcia parseInt skonvertuje prvý argument, ktorý mu bol odovzdaný, na typ reťazca, interpretuje ho a vráti celočíselnú hodnotu alebo hodnotu NaN. Výsledok (ak nie NaN) je celé číslo a je prvým argumentom (reťazcom), ktorý je v uvedenom radixe považovaný za číslo. Napríklad báza 10 označuje prevod z desatinného čísla, 8 na osmičku, 16 do hexu a podobne. Ak je základ väčší ako 10, potom čísla označujú čísla väčšie ako 9. Napríklad hexadecimálne čísla (základ 16) používajú písmená A až F.

Uvažujme o príklade práce s vlastnosťami CSS, kde relatívne povedané môžeme získať nasledujúcu hodnotu:

Nech elem = document.body; nechajte centerPoint = window.getComputedStyle (elem) .transformOrigin; > "454px 2087,19px"
Hodnoty môžeme rozdeliť medzerami:

Nechajte centrá = centerPoint.split (""); > ["454 pixelov", "2087,19 pixelov"]
Každý prvok je však stále reťazec, toho sa môžeme zbaviť aplikáciou našej funkcie:

Nech centerX = parseInt (stredy, 10); > 454 nech centerY = parseInt (stredy, 10); > 2087
Ako vidíte, ako druhý argument uvádzame číselný systém, na ktorý sa číslo prevedie. Tento parameter je voliteľný, ale odporúča sa ho použiť v prípade, že neviete, ktorý reťazec bude odoslaný na vstup.

parseFloat ()

Z vyššie uvedeného príkladu ste si mohli všimnúť, že parseInt zahodí zlomkovú časť. V našom prípade je parseFloat schopný pracovať s číslami s pohyblivou rádovou čiarkou. Opäť to môže byť užitočné pri analýze CSS a ďalších úloh, najmä pri práci s percentami s pohyblivou rádovou čiarkou.

Syntax: parseFloat (reťazec)

Nech FP = "33,33333%"; console.log (parseFloat (FP)); > 33,33333
Všimnite si toho, že v syntaxi parseFloat neexistuje žiadny druhý argument.

Chápeme, že parseInt () a parseFloat () sú mimoriadne užitočné funkcie, je dôležité mať na pamäti, že nemôže byť bez chýb, preto je potrebné skontrolovať rozsah očakávaných hodnôt a v konečnom dôsledku analyzovať výsledok, aby sa zabezpečilo, že získané hodnoty sú správne.
Odoslať anonymne