Prečo je zaokrúhľovanie nevyhnutné?
Jeden z kurióznych 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 nemôže byť vyjadrených konečným počtom desatinných miest, v JavaScripte môžeme získať tieto výsledky: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. Na opravu týchto nepresností potrebujeme iba vedieť 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ť:- Ak argument nie je definovaný pre toFixed (), potom bude predvolene nula, čo znamená 0 desatinných miest, argument má maximálnu hodnotu 20.
- Ak pre toPrecision nie je zadaný žiadny argument, číslo zostane nedotknuté
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 väčší 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, 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.
Frakčné orezávanie
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 sa nachádzate vo výťahu na nižšej úrovni medzi 2 a 3 (čo je hodnota -2,5), Math.floor vás zavedie 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ý nárast: 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 Math.ceil (-36,93); > -36
Zaokrúhľuje sa hore / dole podľa potreby
Ak chceme zaokrúhliť na najbližší násobok 5, najjednoduchším spôsobom je vytvoriť funkciu, ktorá číslo vydelí 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 (tento, 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žšie párne. Táto metóda zaokrúhľovania funguje bez štatistických chýb. Najlepšie riešenie navrhol to 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. Štandardná metóda sort () 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ď narazí na čísla, jedinečné znaky alebo slová v jazyku veľké písmená.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“]
Narazíme 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“.
Na zoradenie poľa, 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. V takom prípade je spravidla 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 +, v starších verziách 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 a na druhú. 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
Zapnuté tento moment podpora pre tohto operátora je dosť obmedzená, preto sa neodporúča používať ho.
Funkcia napájania 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 z a je číslo, ktoré dáva štvorček.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 JavaScriptu 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 to internet Explorer nie je v tomto zozname, ale polyfill nájdete na MDN.
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 anglický jazyk„Exponent“ sa prekladá ako „exponent“, takže je pravdepodobnejšie, že sa bude odvolávať na anglicky hovoriacich, aj keď pre exponent existujú alternatívne názvy, napríklad index, moc.
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í akejkoľvek hodnoty z nepripraveného poľa môžu byť naše výsledky nepredvídateľné. Ako vstup by sme mohli dostať reťazec reprezentovaný ako „17 pixelov“, 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 základňa 10 označuje prevod z desatinného čísla, 8 na oktál, 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 príde 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 iný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 sa tu vyskytujú chyby, 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
The Math.round () funkcia vráti hodnotu čísla zaokrúhlenú na najbližšie celé číslo.
Zdroj pre tento interaktívny príklad je uložený v úložisku GitHub. Ak by ste chceli prispieť k projektu interaktívnych príkladov, naklonujte https://github.com/mdn/interactive-examples a pošlite nám žiadosť o stiahnutie.
Syntax
Matematika. Kolo (x)Parametre
x A číslo.Návratová hodnota
Hodnota daného čísla sa zaokrúhľuje na najbližšie celé číslo.
Popis
Ak je zlomková časť argumentu väčšia ako 0,5, argument sa zaokrúhli na celé číslo s najbližšou vyššou absolútnou hodnotou. Ak je menší ako 0,5, argument sa zaokrúhli na celé číslo s nižšou absolútnou hodnotou. Ak je zlomková časť presne 0,5, argument sa zaokrúhli na ďalšie celé číslo v smere + ∞. Všimnite si toho, že sa to líši v mnohých jazykoch od okrúhlych () funkcií, ktoré často zaokrúhľujú tento prípad na ďalšie celé číslo ďaleko od nuly , namiesto toho dáva iný výsledok v prípade záporných čísel so zlomkovou časťou presne 0,5.
Pretože round () je statická metóda matematiky, vždy ju používate ako Math.round (), a nie ako metódu matematického objektu, ktorý ste vytvorili (matematika nemá žiadny konštruktor).
Príklady
Matematika.kolo (20,49); // 20 Math.round (20.5); // 21 Math.round (42); // 42 Math.round (-20,5); // -20 Math.round (-20,51); // -21Ukážková implementácia
Nasleduje úryvok kódu, ktorý je funkčne ekvivalentný s matematikou.kolo, okrem toho, že útržok nižšie uvedeného kódu je pomalší ako Math.round. Cieľom úryvku kódu nižšie je demonštrovať, ako Math.round funguje.
Funkcia vanilla_round (x) (var y = Math.abs (x) + 0,5; // tak, aby sa zaokrúhlilo menej ako 1/2 nadol; väčšie zaokrúhlilo nahor návrat Math.floor (x + 0,5))
Vyššie uvedený operátor modulu dostane desatinnú časť x. Ďalej môže byť vyššie uvedený útržok kódu upravený tak, aby bol zaokrúhlený na určitú presnosť pre číslo:
Funkcia round_to_precision (x, presnosť) (var y = + x + (presnosť === nedefinovaná? 0,5: presnosť / 2); návrat y - (y% (presnosť === nedefinovaná? 1: + presnosť));)
Round_to_precision (11, 2); // výstupy 12 round_to_precision (11, 3); // výstupy 12 round_to_precision (11, 4); // výstupy 12 round_to_precision (11, 5); // výstupy 10 round_to_precision (11, 6); // výstupy 12 round_to_precision (11, 7); // výstupy 14 round_to_precision (11, 8); // výstupy 8 round_to_precision (3,7, 0,5); // výstupy 3,5 round_to_precision (3,75, 0,5); // výstupy 4 round_to_precision (3,8, 0,5); // výstupy 4
technické údaje
| Špecifikácia | Postavenie | Komentovať |
|---|---|---|
| 1. vydanie ECMAScript (ECMA-262) | Štandardné | Počiatočná definícia. Implementované v JavaScripte 1.0. |
| ECMAScript 5.1 (ECMA-262) |
Štandardné | |
| ECMAScript 2015 (6. vydanie, ECMA-262) Definícia „Math.round“ v tejto špecifikácii. |
Štandardné | |
| Najnovší návrh ECMAScript (ECMA-262) Definícia „Math.round“ v tejto špecifikácii. |
Návrh |
Kompatibilita s prehliadačom
Tabuľka kompatibility na tejto stránke je generovaná zo štruktúrovaných údajov. Ak by ste chceli prispieť k údajom, navštívte stránku https://github.com/mdn/browser-compat-data a pošlite nám žiadosť o stiahnutie.
Aktualizujte údaje o kompatibilite na GitHub
| Pracovná plocha | Mobilné | Server | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Chrome | Hrana | Firefox | internet Explorer | Opera | Safari | Webview v systéme Android | Chrome pre Android | Firefox pre Android | Opera pre Android | Safari v systéme iOS | Internet Samsung | Node.js | |
| okrúhly | Plná podpora prehliadača Chrome 1 | Úplná podpora Edge 12 | Plná podpora Firefoxu 1 | Plná podpora IE 3 | Opera Plná podpora Áno | Safari Plná podpora Áno | WebView Android Plná podpora 1 | Chrome Android Plná podpora 18 | Firefox Android Plná podpora 4 | Opera Android Plná podpora Áno | Safari iOS Plná podpora Áno | Samsung Internet Android Plná podpora 1.0 | nodejs Plná podpora Áno |
Výsledkom výpočtov je často číslo s veľkým počtom desatinných miest. Ak bude toto číslo použité na ďalšie výpočty, môže byť ponechané tak, ako je. Niekedy však potrebujete číslo zaokrúhliť, napríklad aby sa zobrazilo na stránke. V JavaScripte existuje niekoľko spôsobov zaokrúhľovania čísel.
Metóda Math.round () zaokrúhli hodnotu na celé číslo.
Matematika. Kolo (číslo)
Číslo sa zaokrúhľuje podľa matematických pravidiel. To znamená, že ak je za desatinnou čiarkou číslica od 0 do 4, zlomková časť sa jednoducho zahodí. A ak je za desatinnou čiarkou číslo od 5 do 9, zlomková časť sa zahodí a jedna sa pridá k celej časti. príklad:
JavaScript:
Existujú ďalšie dve metódy, ktoré zaokrúhľujú číslo na celočíselnú hodnotu. Metóda Math.floor () sa zaokrúhľuje nadol. Zahodí zlomkovú časť čísla. A metóda Math.ceil () sa zaokrúhľuje. Zahodí zlomkovú časť a jednu pridá k celej časti. Príklad:
5 - (-2) je samozrejme 5 + 2. Nezabudnite, že v tomto vzorci nedostanete číslo 5. Maximum bude 4,999999999. Získané hodnoty je možné zaokrúhliť na požadovanú presnosť.
Ak sú potrebné iba celé čísla, získané hodnoty je možné zaokrúhliť nadol na najbližšie celé číslo. K maximu treba pridať jeden, aby bolo možné aj toto maximum. Vzorec je nasledujúci:
integer = Math.floor (minimum + Math.random () * (maximum + 1 - minimum)
Vytlačíme čísla od 10 do 15:
20 |
pre (i = 1; i<=10; i++) { rand = Math.floor(10 + Math.random() * (15 + 1 - 10)); console.log(rand); } |
Porovnanie zlomkových čísel
Matematické výpočty majú jednu zvláštnosť - ich výsledky nie sú vždy úplne presné. To je problém nielen v JavaScripte, ale aj vo väčšine programovacích jazykov. Dôvodom je, že čísla a ďalšie údaje sa prevádzajú na binárny kód a až potom sa s nimi vykonávajú výpočty. Vo väčšine prípadov to nevedie k zvláštnym ťažkostiam, práve ako výsledok výpočtov sa niekedy získa číslo s veľkým počtom desatinných miest. Existuje však situácia, keď nepresnosť výpočtov ovplyvňuje činnosť programu. Toto je porovnanie čísel. Ak sa porovnajú rôzne čísla, potom by tu malo byť všetko v poriadku.
5.1 < 5.2
Ak však výsledkom výpočtu sú dve rovnaké zlomkové čísla, výsledok ich porovnania nie je predvídateľný. Môžu byť rovnakí, alebo jeden môže byť väčší ako druhý. Keď je takéto porovnanie použité v skripte, je potrebné skontrolovať, či skript funguje správne. Ak je v ňom chyba, musíte porovnať hodnoty, ktoré sa porovnávajú.
Iné matematické metódy
Existuje mnoho metód na rôzne matematické výpočty. Sú jednoduché a zrozumiteľné. Metódy, ktoré sa bežne používajú, sú uvedené v nasledujúcej tabuľke:
Skúste niektoré výpočty pomocou týchto metód.
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úhlenie 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;
Výsledkom vyššie uvedeného príkladu je 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 JavaScript zaokrúhľuje 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 matematické zaokrúhľovanie 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 Math.ceil (-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 do jej zaokrúhľovania číslo a násobnosť:
var initialNumber = 11; var násobok = 10; roundToMultiple (initialNumber, násobok); > 10;
Ak chcete hodnoty zaokrúhliť iba nahor alebo nadol, nahraďte zaokrúhlenie stropom alebo podlahou vo funkcii.
Chytanie doletu
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.