Celočíselné delenie js. Metódy zaokrúhľovania čísel v JavaScripte

Výpočty v JavaScripte veľmi často nedávajú presne také výsledky, aké chceme. Samozrejme, s číslami si môžeme robiť, čo chceme – zaokrúhľovať nahor alebo nadol, nastavovať rozsahy, orezávať 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 potrebné zaokrúhľovanie?

Jedným zo zaujímavých aspektov JavaScriptu je, že v skutočnosti neukladá celé čísla, pracujeme priamo s číslami s pohyblivou rádovou čiarkou. V kombinácii so skutočnosťou, že mnohé zlomkové hodnoty nemožno vyjadriť v konečnom počte desatinných miest, môžeme v JavaScripte získať takéto výsledky:

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Pre praktické účely táto nepresnosť nevadí, v našom prípade hovoríme o chybe v kvintilióne dielov, čo však môže niektorých sklamať. Trochu zvláštne výsledky môžeme získať aj pri práci s číslami, ktoré predstavujú meny, percentá alebo veľkosti súborov. Aby sme tieto nepresnosti opravili, musíme mať možnosť výsledky zaokrúhliť a stačí nastaviť desatinnú presnosť.

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

Zaokrúhľovanie desatinných čísel

Ak chcete orezať desatinné číslo, použite metódu toFixed alebo toPrecision. Obaja používajú 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) by mal výsledok obsahovať:

Ak argument nie je definovaný pre toFixed(), predvolene sa nastaví na nulu, čo znamená 0 desatinných miest, argument má maximálnu hodnotu 20.
Ak pre Precision 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"
Metódy toFixed() aj toPrecision() vracajú reťazecovú reprezentáciu výsledku, nie číslo. To znamená, že pri sčítaní zaokrúhlenej hodnoty s randNum sa vytvorí zreťazenie reťazcov a nie súčet čísel:

Nech randNum = 6,25; nech rounded = randNum.toFixed(); // "6" console.log(randNum + rounded); > "6,256"
Ak chcete, aby bol výsledkom číselný dátový typ, budete musieť použiť parseFloat:

Nech randNum = 6,25; let rounded = parseFloat(randNum.toFixed(1)); console.log(zaoblene); > 6.3
Upozorňujeme, že hodnoty 5 sú okrem zriedkavých prípadov zaokrúhlené.

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

Nech celéCíslo = 1 nech doláreCenty = celéCíslo.toFixed(2); console.log(dollarsCents); > "1,00"
Stojí za zmienku, že toPrecision vytvorí 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 pri zaokrúhľovaní s desatinnými miestami

V niektorých prípadoch toFixed a toPrecision zaokrúhli hodnotu 5 nadol a nahor:

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

Funkcia round(hodnota, desatinné miesta) ( return Number(Math.round(value+"e"+decimals)+"e-"+decimals); )
teraz:

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

Strojové epsilonové zaokrúhľovanie

V ES6 bola zavedená alternatívna metóda na zaokrúhľovanie desatinných čísel. Strojové epsilonové zaokrúhľovanie poskytuje primeranú chybovosť pri porovnávaní dvoch čísel s pohyblivou rádovou čiarkou. Bez zaokrúhľovania môžu porovnania priniesť výsledky podobné týmto:

0,1 + 0,2 === 0,3 > nepravda
Na získanie platného 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 IE 11, použite polyfilly.

Orezanie zlomkovej časti

Všetky vyššie uvedené metódy možno zaokrúhliť na desatinné čísla. Ak chcete jednoducho znížiť číslo na dve desatinné miesta, musíte ho najprv vynásobiť 100 a potom vydeliť výsledný výsledok 100:

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

Funkcia skrátená (num, desatinné miesta) ( nech numPowerConverter = Math.pow(10, desatinné miesta); return ~~(num * numPowerConverter)/numPowerConverter; )
teraz:

Nech randInt = 35,874993; skrátené(randInt,3); > 35,874

Zaokrúhlite na najbližšie číslo

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

Mat.kolo(4.3) > 4 Mat.kolo(4.5) > 5
Upozorňujeme, že „polovičná hodnota“, 0,5 sa zaokrúhľuje nahor podľa pravidiel matematiky.

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

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

Math.floor(42,23); > 42 Mate.poschod (36,93); > 36
Upozorňujeme, že zaokrúhlenie nadol funguje pre všetky čísla vrátane záporných čísel. Predstavte si mrakodrap s nekonečným počtom poschodí vrátane poschodí na spodnej úrovni (predstavujú záporné čísla). Ak ste vo výťahu na najnižšej úrovni medzi 2 a 3 (čo predstavuje hodnotu -2,5), Math.floor vás zavedie na -3:

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

Math.trunc(-41,43); > -41
Na MDN nájdete polyfill, ktorý poskytne 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ť nahor, použite Math.ceil. Opäť si pamätajte na nekonečný výťah: Math.ceil pôjde vždy „hore“, bez ohľadu na to, či je číslo záporné alebo nie:

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

Zaokrúhľovanie nahor/nadol na požadované číslo

Ak chceme zaokrúhliť na najbližší násobok 5, najjednoduchším spôsobom je vytvoriť funkciu, ktorá vydelí číslo 5, zaokrúhli ho a potom ho vynásobí rovnakým množstvom:

Funkcia roundTo5(num) ( return Math.round(num/5)*5; )
teraz:

RoundTo5(11); > 10
Ak chcete zaokrúhliť na násobky vašej hodnoty, použijeme všeobecnejšiu funkciu, pričom zadáte počiatočnú hodnotu a násobok:

Funkcia roundToMultiple(počet, viacnásobok) ( return Math.round(číslo/násobok)*násobok; )
teraz:

Nech počiatočnéČíslo = 11; nech násobok = 10; roundToMultiple(počiatočnéČíslo, viacnásobné); > 10;

Oprava čísla v rozsahu

Existuje veľa prípadov, keď chceme získať hodnotu x, ktorá leží v rozsahu. Mohli by sme napríklad potrebovať hodnotu medzi 1 a 100, ale skončili sme s hodnotou 123. Aby sme to vyriešili, môžeme použiť min (vracia najmenšie z množiny čísel) a max (vracia najväčšie z ľubovoľnej množiny čísel). V našom príklade je rozsah od 1 do 100:

Nech lowBound = 1; nech highBound = 100; nech numInput = 123; nechať upnuté = Math.max(dolná hranica, Math.min(numInput, highBound)); console.log(upnuté); > 100;
Opäť môžeme operáciu znova použiť a celú vec zabaliť do funkcie pomocou riešenia, ktoré navrhol Daniel X. Moore:

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

NumInput.clamp(dolná hranica, vysoká hranica); > 100;

Gaussovo zaokrúhľovanie

Gaussovské zaokrúhľovanie, známe tiež ako bankové zaokrúhľovanie, zahŕňa zaokrúhľovanie na najbližšie párne číslo. Tento spôsob zaokrúhľovania funguje bez štatistickej chyby. Tim Down navrhol lepšie riešenie:

Funkcia gaussRound(počet, desatinné miesta) ( nech d = desatinné miesta || 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é v CSS:

Keďže JavaScript sa často používa na vytváranie pozičných mapovaní pre prvky HTML, možno vás zaujíma, čo by sa stalo, keby sme pre naše prvky vygenerovali desatinné hodnoty:

#box ( šírka: 63,667731993px; )
Dobrou správou je, že moderné prehliadače budú rešpektovať desatinné hodnoty v blokovom modeli vrátane percent alebo jednotiek pixelov.

Triedenie

Veľmi často musíme niektoré prvky triediť, napríklad máme rad záznamov o hrách a tie musia byť usporiadané v zostupnom poradí podľa hodnosti hráča. Bohužiaľ, štandardná metóda sort() má niekoľko prekvapivých obmedzení: funguje dobre s bežnými anglickými slovami, ale okamžite sa pokazí, keď narazí na čísla, jedinečné znaky alebo veľké slová.

Zoradenie podľa abecedy

Zdá sa, že zoradiť pole podľa abecedy by malo byť jednoduchou úlohou:

Nech ovocie = ["butternut tekvica", "marhuľa", "cantaloupe"]; ovocie.triedit(); > "marhuľa", "maslová tekvica", "cantaloupe"]
Avšak narazíme na problém, akonáhle je jeden z prvkov napísaný veľkými písmenami:

Nech ovocie = ["butternut tekvica", "marhuľa", "cantalope"]; ovocie.triedit(); > "Cantaloupe", "marhuľa", "maslová tekvica"]
Je to preto, že triedič štandardne 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. Napríklad, ak sa pozriete na tabuľku kódov, znak „a“ má hodnotu U+0061 (v šestnástkovej sústave 0x61), zatiaľ čo znak „C“ má kód U+0043 (0x43), ktorý je v Unicode skôr uvedený. tabuľka ako znak "a".

Na zoradenie poľa, ktoré môže obsahovať prvé písmená so zmiešanými veľkými a malými písmenami, musíme buď dočasne skonvertovať všetky prvky na malé písmená, alebo definovať naše poradie triedenia 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) ( return a.localeCompare(b, "en", ("citlivosť": "základ")); )); ) nech ovocie = ["butternut tekvica ", "marhuľa", "Cantaloupe"]; alphaSort(ovocie) >
Ak chcete pole zoradiť v obrátenom abecednom poradí, jednoducho zameňte pozície a a b vo funkcii:

Funkcia alphaSort(arr) ( arr.sort(funkcia (a, b) ( return b.localeCompare(a, "en", ("citlivosť": "základ")); )); ) nech ovocie = ["butternut tekvica ", "marhuľa", "Cantaloupe"]; alphaSort(ovocie) > ["Cantaloupe", "maslová tekvica", "marhuľa"]
Tu stojí za zmienku, že localeCompare sa používa s argumentmi, musíme 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:

Funkcia caseSort(arr) ( arr.sort(funkcia (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) nech ovocie = ["maslová tekvica", "marhuľa", "Cantaloupe"]; caseSort(ovocie) > ["marhuľa", "maslová tekvica", "Cantaloupe"]

Číselné zoradenie

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

Nech highScores = ; highScores.sort(); >
Ide o to, že metóda sort() vykonáva lexikografické porovnanie: čo znamená, že čísla sa skonvertujú na reťazec a porovnania sa opäť vykonajú porovnaním prvého znaku tohto reťazca v poradí znakov v tabuľke Unicode. . Preto musíme opäť definovať naše poradie zoradenia:

Nech highScores = ; highScores.sort(funkcia(a,b) ( return a - b; )); >
Opäť platí, že ak chcete čísla zoradiť v opačnom poradí, zameňte pozície a a b vo funkcii.

Triedenie štruktúry podobnej JSON

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

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

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

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

Práca s napájacími funkciami

Umocňovanie je operácia pôvodne definovaná ako výsledok opakovaného násobenia prirodzeného čísla samým sebou, druhá odmocnina a je číslo, ktoré dáva a; Tieto funkcie by sme mohli neustále využívať v každodennom živote na hodinách matematiky, aj pri výpočte plôch, objemov alebo aj pri fyzikálnom modelovaní.

V JavaScripte je funkcia napájania reprezentovaná ako Math.pow() av novom štandarde ES7 bol zavedený nový operátor umocňovania - " * * ".

Umocňovanie

Ak chcete zvýšiť číslo na n-tú mocninu, použite funkciu Math.pow(), kde prvý argument je číslo, ktoré bude umocnené, druhý argument 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ôžeme samozrejme uviesť aj iný príklad:

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

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

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

Funkcia napájania môže byť užitočná v rôznych situáciách. Jednoduchý príklad výpočtu počtu sekúnd za hodinu: Math.pow (60,2).

Štvorcové a kockové korene

Math.sqrt() a Math.cbrt() sú opakom Math.pow(). Ako si pamätáme, druhá odmocnina z a je číslo, ktoré dáva a pri druhej mocnine.

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

Math.cbrt(125) > 5
Math.cbrt() bol len nedávno zavedený do špecifikácie JavaScript, 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 nájdete polyfill na MDN.

Príklady

Samozrejme, môžeme použiť neceločíselné hodnoty v jednej z týchto funkcií:

Math.pow(1,25; 2); > 1,5625 Math.cbrt(56,57) > 3,8387991760286138
Upozorňujeme, že to funguje celkom dobre aj pri použití hodnôt záporných argumentov:

Math.pow(-5,2) > 25 Math.pow(10,-2) > 0,01
Toto však nebude fungovať pre druhú odmocninu:

Math.sqrt(-9) > NaN
Z matematickej analýzy vieme, že imaginárne číslo sa vzťahuje na druhú odmocninu záporných čísel. A to nás môže priviesť k ďalšej technike práce s komplexnými číslami, ale to je už iný príbeh.

V Math.pow() môžete použiť zlomky na nájdenie druhej mocniny a druhej mocniny čísel. Druhá odmocnina používa exponent 0,5:

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

Math.pow(2,23606797749979,2) > 5,00000000000001
V takýchto situáciách sa budete musieť uchýliť k odrezaniu znamienok od čísla alebo zaokrúhleniu na nejakú hodnotu.

Niektorí ľudia si z neznámych dôvodov 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 to platí skôr pre anglicky hovoriacich ľudí, aj keď existujú alternatívne názvy pre exponent, ako napríklad index, mocnina.

Matematické konštanty

Prácu s matematikou v JavaScripte uľahčuje množstvo vstavaných konštánt. Tieto konštanty sú vlastnosti objektu Math. Stojí za zmienku, že konštanty sa píšu veľkými písmenami, nie zápisom 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 nemusí byť výsledok vôbec taký, aký sme očakávali.

Math.abs()

Metóda Math.abs() vracia absolútnu hodnotu čísla, čo nám pripomína podobnú 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) vložíme znamienko mínus, vždy dostaneme zápornú hodnotu.

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 pri prijímaní 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 „17px“, a to pre nás nie je nezvyčajné. Otázkou je, ako previesť tento reťazec na skutočnú hodnotu a použiť ho v ďalších výpočtoch.

Syntax: parseInt(string, radix);

Funkcia parseInt skonvertuje prvý argument, ktorý jej bol odovzdaný, na typ reťazca, interpretuje ho a vráti celé číslo alebo hodnotu NaN. Výsledok (ak nie NaN) je celé číslo a je to prvý argument (reťazec), s ktorým sa zaobchádza ako s číslom v špecifikovanom základe. Napríklad základ 10 označuje prevod z desiatkovej, 8 z osmičky, 16 zo šestnástkovej atď. Ak je základ väčší ako 10, potom písmená predstavujú čísla väčšie ako 9. Napríklad pre hexadecimálne čísla (základ 16) sa používajú písmená A až F.

Pozrime sa na príklad práce s vlastnosťami CSS, kde relatívne povedané môžeme získať nasledujúcu hodnotu:

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

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

Nech centerX = parseInt(centers, 10); > 454 nech centerY = parseInt(centers, 10); >2087
Ako vidíte, druhým argumentom uvádzame číselný systém, do ktorého sa číslo prevedie, tento parameter je voliteľný, ale odporúčame ho použiť, ak neviete, ktorý reťazec bude prijatý ako vstup.

parseFloat()

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

Syntax: parseFloat(string)

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

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

Výpočty často prinášajú výsledky, ktoré sú mimo požadovaných rozsahov. V dôsledku toho je potrebné implementovať JavaScript zaokrúhľovanie do určitej hodnoty.

Prečo okrúhle čísla?

JavaScript neukladá celé čísla, pretože ich hodnoty sú reprezentované ako čísla s pohyblivou rádovou čiarkou. Mnohé zlomky nemožno reprezentovať ako číslo s konkrétnym konečným počtom desatinných miest, takže JavaScript môže generovať výsledky, ako sú tieto:

0.1 * 0.2; > 0.020000000000000004

V praxi to nebude žiadny rozdiel, keďže hovoríme o chybe 2 kvintilióntiny. To však môže ovplyvniť výsledky 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

Ak chcete "vyrezať" desatinné číslo, použite metódy toFixed() alebo toPrecision(). Obaja používajú jeden argument, ktorý určuje počet významných a desatinných miest, ktoré sa majú zahrnúť do výsledku:

ak toFixed() nemá zadaný žiadny argument, predvolená hodnota je 0 , čiže žiadne desatinné miesta; maximálna hodnota argumentu je 20 ;
ak nie je daný argument toPrecision(), čí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ú namiesto čísla zaokrúhlenú reťazcovú reprezentáciu výsledku. To znamená, že pridanie zaokrúhleného k randNum bude mať za následok zreťazenie reťazcov namiesto jedného čísla:

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

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

var randNum = 6,25; var rounded = parseFloat(randNum.toFixed(1)); console.log(zaoblene); > 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 predstavujúcimi peňažné jednotky:

var celeCislo = 1 var dollarsCents = celeCislo.toFixed(2); console.log(dollarsCents); > "1,00"

Upozorňujeme, že ak má číslo viac číslic, než je špecifikovaná presnosť, toPrecision vypíše 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 miest

V niektorých prípadoch na pevné a presné náradie JavaScript zaokrúhlenie 5 nadol a nie viac:

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

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

function round(hodnota, desatinné miesta) ( return Number(Math.round(value+"e"+decimals)+"e-"+decimals); )

Aplikácia:

kolo(1,005,2); > 1,01

Ak potrebujete ešte robustnejšie riešenie ako zaoblenie, je k dispozícii na MDN.

Zaokrúhľovanie s epsilon

Alternatívna metóda JavaScript zaokrúhľovanie na desatiny bol predstavený v ES6 ( tiež známy ako JavaScript 2015). « Stroj epsilon" poskytuje primeranú chybovosť pri porovnávaní dvoch čísel s pohyblivou rádovou čiarkou. Bez zaokrúhľovania môžu porovnania priniesť výsledky podobné týmto:

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

Math.EPSILON možno použiť vo funkcii na získanie platného porovnania:

funkcia epsEqu(x, y) ( return Math.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ý (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ť polyfilly.

Skracovanie desatinných čísel

Všetky vyššie uvedené metódy fungujú JavaScript zaokrúhľovanie na desatiny. Ak chcete skrátiť kladné číslo na dve desatinné miesta, vynásobte ho 100, znova ho skráťte a potom vydeľte výsledok 100:

function truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3.1416) > 3.14

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

function truncated(num, decimalPlaces) ( var numPowerConverter = Math.pow(10, desatinné miesta); return ~~(num * numPowerConverter)/numPowerConverter; )

Použitie:

var randInt = 35,874993; skrátené(randInt,3); > 35,874

Zaokrúhlite na najbližšie číslo

Na realizáciu JavaScript zaokrúhľovanie na najbližšie celé číslo, Math.round() sa používa:

Mat.kolo(4.3) > 4 Mat.kolo(4.5) > 5

Všimnite si, že " polovičné hodnoty“, ako napríklad 0,5, sú zaokrúhlené nahor.

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

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

Math.floor(42,23); > 42 Mate.poschod (36,93); > 36

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

Math.floor(-2,5); > -3

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

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

MDN tiež poskytuje trojriadkový polyfill na poskytovanie podpory pre 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ý výťah: Math.ceil vás vždy vezme „nahor“, bez ohľadu na to, či je číslo záporné alebo kladné:

Math.ceil(42,23); > 43 Math.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á vydelí číslo 5, zaokrúhli ho a potom vynásobí výsledok rovnakou hodnotou:

funkcia roundTo5(num) ( return Math.round(num/5)*5; )

Použitie:

roundTo5(11); > 10

Ak potrebujete JavaScript na zaokrúhlenie na dve číslice, môžete do funkcie vložiť základ aj násobok:

function roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )

Ak chcete funkciu použiť, zadajte do volania číslo, ktoré sa má zaokrúhliť, a násobok:

var počiatočné číslo = 11; var násobok = 10; roundToMultiple(počiatočnéČíslo, viacnásobné); > 10;

Ak chcete hodnoty zaokrúhliť iba nahor alebo nadol, nahraďte vo funkcii zaokrúhlenie za strop alebo podlahu.

Väzba rozsahu

Niekedy potrebujete získať hodnotu pre x, ktorá musí byť v určitom rozsahu. Napríklad potrebujeme hodnotu od 1 do 100, ale dostaneme hodnotu 123. Na opravu tohto problému môžete použiť min() ( vráti najmenšie číslo) a max ( vráti maximálny povolený počet).

Použitie:

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

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

V tomto článku sa podrobne pozrieme na čísla, matematické operátory, spôsoby prevodu čísla na reťazec a naopak, ako aj na mnohé ďalšie dôležité body.

funkcia isFinite

Funkcia isFinite vám umožňuje skontrolovať, či je argument konečným číslom.

Ako odpoveď táto funkcia vráti hodnotu false, ak je argument Infinity, -Infinity, NaN, alebo bude pretypovaný na jednu z týchto špeciálnych číselných hodnôt. V opačnom prípade táto funkcia vráti hodnotu true.

IsFinite(73); // true isFinite(-1/0); // false isFinite(Infinity); // false isFinite(NaN); // false isFinite("Text"); // nepravda

JavaScript má okrem globálnej funkcie isFinite aj metódu Number.isFinite. Na rozdiel od isFinite nevynúti prevod argumentu na číslo.

IsFinite("73"); // true Number.isFinite("73"); // nepravda

isNaN funkcia

Funkcia isNaN je navrhnutá tak, aby určila, či je argument číslo alebo či sa dá skonvertovať na číslo. Ak áno, funkcia isNaN vráti hodnotu false. V opačnom prípade vráti hodnotu true.

IsNaN(NaN); //pravda isNaN("25px"); //pravda, pretože 20px nie je číslo isNaN(25,5); //false isNaN("25,5"); //false isNaN(" "); //false, pretože medzera alebo niekoľko medzier sa prevedie na 0 isNaN(null); //false, pretože null sa prevedie na 0 isNaN(true); //false, pretože true sa prevedie na 1 isNaN(false); //false, pretože false sa prevedie na 0

Ak je potrebné vykonať túto akciu bez pretypovania, použite metódu Number.isNaN. Táto metóda bola zavedená do jazyka počnúc ECMAScript 6.

Ako explicitne previesť reťazec na číslo?

Reťazec môžete explicitne previesť na číslo pomocou nasledujúcich metód:

1. Použitie unárny operátor +, ktorý musí byť umiestnený pred hodnotou.

+"7,35"; // 7,35 +"text"; // NaN

Táto metóda ignoruje medzery na začiatku a na konci riadku, ako aj \n (riadkový posuv).

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

Pri tejto metóde je potrebné dbať na to, aby sa prázdny reťazec alebo reťazec pozostávajúci z medzier a \n skonvertoval na číslo 0. Okrem toho prevedie aj typ údajov null a booleovské hodnoty na číslo .

Null; //0 +true; //1 +false; //0 +" "; //0

2. Funkcia ParseInt. Táto funkcia je určená na konverziu argument na celé číslo. Na rozdiel od používania unárny operátor +, táto metóda umožňuje previesť reťazec na číslo, v ktorom nie všetky znaky sú číselné. Začne konvertovať reťazec od prvého znaku. A akonáhle narazí na nečíselný znak, táto funkcia zastaví svoju prácu a vráti výsledné číslo.

ParseInt("18px"); //18 parseInt("33,3%"); //33

Táto funkcia môže pracovať s rôznymi číselnými sústavami (dvojkové, osmičkové, desiatkové, hexadecimálne). Základ číselnej sústavy je špecifikovaný pomocou 2 argumentov.

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

JavaScript má okrem funkcie parseInt aj metódu Number.parseInt. Táto metóda sa nelíši od funkcie parseInt a bola zavedená do JavaScriptu so špecifikáciou ECMASCRIPT 2015 (6).

3. funkcia parseFloat. Funkcia parseFloat je podobná funkcii parseInt , okrem toho, že vám umožňuje previesť argument na zlomkové číslo.

ParseFloat("33,3%"); //33.3

Okrem toho funkcia parseFloat na rozdiel od parseInt nemá 2 argumenty, a preto sa vždy snaží s reťazcom zaobchádzať ako s číslom v desiatkovej sústave.

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

JavaScript má okrem funkcie parseFloat aj metódu Number.parseFloat. Táto metóda sa nelíši od funkcie parseFloat a bola zavedená do JavaScriptu so špecifikáciou ECMASCRIPT 2015 (6).

Prevod čísla na reťazec

Číslo môžete zmeniť na reťazec pomocou metódy toString.

(12.8).toString(); //"12,8"

Metóda toString vám tiež umožňuje určiť základ číselného systému, berúc do úvahy, ktorý musíte explicitne previesť číslo na reťazec:

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

Ako skontrolovať, či premenná je číslo

Pomocou jednej z nasledujúcich metód môžete určiť, či je hodnota premennej číslo:

1. Použitie funkcií isNaN a isFinite:

// myVar je premenná if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar je číslo alebo ho možno pretypovať);

Ako funkcia:

// funkcia function isNumeric(value) (return !isNaN(parseFloat(value)) && isFinite(parseFloat(value)); ) // use var myVar = "12px"; console.log(isNumeric(myVar)); //pravda

Táto metóda vám umožňuje určiť, či je zadaná hodnota číslo alebo či sa dá previesť na jednotku. Táto možnosť nepočíta prázdny reťazec, reťazec medzier, null, Infinity, -Infinity, true a false ako číslo.

2. Pomocou operátora typeof a isFinite funkcie isNaN:

// funkcia, ktorá kontroluje, či je hodnota číselná funkcia isNumber(value) (return typeof value === "number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Táto funkcia určuje, či je zadaná hodnota typu Number a či ide o jednu zo špeciálnych hodnôt Infinity, -Infinity a NaN. Ak áno, potom táto funkcia vráti hodnotu true.

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

Cislo.isInteger("20"); //false, pretože táto metóda nekonvertuje reťazec na číslo Number.isInteger(20); //pravda, pretože táto hodnota je číslo

Párne a nepárne čísla

Pomocou nasledujúcich funkcií môžete skontrolovať, či je číslo párne alebo nepárne:

// Funkcia na kontrolu čísla pre funkciu párnej parity isEven(n) ( return n % 2 == 0; ) // Funkcia na kontrolu čísla pre funkciu párnej parity isOdd(n) ( return Math.abs(n % 2) == 1;)

Pred vykonaním takejto kontroly sa však odporúča uistiť sa, že zadaná hodnota je číslo:

hodnota = 20; if (Number.isInteger(value)) ( if (isEven(value)) ( console.log("Číslo " + hodnota.toString() + " - párne"); ) )

Prvočísla v Javascripte

Pozrime sa na príklad, v ktorom pomocou Javascriptu zobrazíme prvočísla od 2 do 100.

// Funkcia, ktorá kontroluje, či je číslo prvočíslo, funkcia isPrime(value) (if (isNaN(hodnota) || !isFinite(value) || value%1 || value)< 2) return false; var max=Math.floor(Math.sqrt(value)); for (var i = 2; i< = max; i++) { if (value%i==0) { return false; } } return true; } // создать массив, который будет содержать простые числа от 2 до 100 var primaryNumber = ; for (var i = 2; i <= 100; i++) { if(isPrime(i)) primaryNumber.push(i); } // вывести в консоль простые числа от 2 до 100 console.log(primaryNumber);

Zaokrúhlenie čísla v Javascripte

Existujú rôzne spôsoby, ako v JavaScripte zaokrúhliť zlomok na celé číslo.

1. Pomocou metód Math.floor, Math.ceil a Math.round špeciálne navrhnutých na tento účel. Metóda Math.floor zaokrúhľuje zlomok nadol na najbližšie celé číslo, t.j. jednoducho zahodí zlomkovú časť. Math.ceil zaokrúhli zlomok nahor na najbližšie celé číslo. Math.round zaokrúhli číslo nahor alebo nadol v závislosti od hodnoty zlomkovej časti. Ak je zlomková časť väčšia alebo rovná 0,5, potom hore, inak je skrútenie dole.

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

2. Pomocou metódy toFixed(precision). Táto metóda zaokrúhľuje zlomkovú časť čísla na zadanú presnosť. Výsledok zaokrúhlenia sa vráti ako reťazec.

Console.log(7.987.toFixed(2)); //"7,99"

Ak nie je dostatok desatinných miest na vytvorenie špecifikovanej presnosti čísla, doplní sa nulami.

Console.log(7.987.toFixed(5)); //"7,98700"

3. Pomocou metódy toPrecision (presnosť). Táto metóda predstavuje číslo so špecifikovanou presnosťou. Zároveň vie zaokrúhliť nielen zlomok, ale aj celú časť čísla. V závislosti od výsledku môže táto metóda prezentovať výsledné číslo s pevným bodom alebo v exponenciálnom tvare.

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

4. Použitie logických operátorov NOT alebo OR.

//cez dvojitú logickú negáciu console.log(~~7.9); //7 // pomocou logického OR s nulou: console.log(7.9^0); //7

Celé číslo a zlomková časť čísla

Celú časť čísla môžete získať pomocou metód Math.floor() a parseInt():

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

Pomocou operátora percent (%) môžete získať zlomkovú časť čísla. Tento operátor vráti zvyšok, ktorý sa získa vydelením prvého čísla druhým. V tomto prípade musíte použiť 1 ako 2. číslo.

Console.log (7,21%1); // 0,20999999999999996 // s presnosťou na 2 desatinné miesta console.log((7,21%1).toFixed(2)); // "0,21"

Okrem toho je možné zlomkovú časť získať aj pomocou výpočtov:

Číslo var = 7,21; var zlomokNumber = číslo - Math.floor(Math.abs(číslo)); console.log(fractionNumber); // 0,20999999999999996

Je číslo deliteľné celým číslom?

Či je číslo deliteľné celým číslom, môžete určiť pomocou operátora percent:

Číslo var = 9; // ak je zvyšok čísla delený 3 0, tak áno, inak nie if (číslo%3==0) ( console.log ("Číslo " + číslo + " je deliteľné 3"); ) else ( konzola log("Číslo " + číslo + " nie je deliteľné 3");

Formátovanie čísel

V JavaScripte vám metóda toLocaleString() umožňuje formátovať výstup čísla v súlade s regionálnymi štandardmi (jazykové nastavenia operačného systému).

Napríklad naformátujme číslo v súlade s regionálnymi normami, ktoré sú štandardne nainštalované v systéme:

Číslo var = 345,46; console.log(number.toLocaleString()); //"345,46"

Napríklad naformátujme číslo 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 ako meny:

Console.log((2540.125).toLocaleString("ru-RU",(style:"currency", mena:"RUB"))); //"2 540,13 ₽" console.log((89,3).toLocaleString("ru-RU",(style:"currency", mena:"USD"))); //"89,30 $" console.log((2301,99).toLocaleString("ru-RU",(style:"currency", mena:"EUR"))); //"2 301,99 EUR"

Predstavuje číslo v percentách:

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

Rozdeľte číslo na číslice (vlastnosť useGrouping):

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

Vytlačte číslo s určitým počtom číslic (2) za desatinnou čiarkou:

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

Porovnanie čísel

Nasledujúce operátory sa používajú na porovnávanie čísel v JavaScripte: == (rovná sa), != (nerovná sa), > (väčšie ako),< (меньше), >= (väčšie alebo rovné),<= (меньше или равно).

Porovnajme napríklad dve čísla:

Console.log(2>3); //false console.log(5>=3); //pravda

Pri porovnávaní čísel s zlomkovou časťou je potrebné vziať do úvahy chyby, ktoré môžu pri týchto výpočtoch vzniknúť.

Napríklad v JavaScripte sa súčet čísel (0,2 + 0,4) nerovná 0,6:

Console.log((0,2+0,4)==0,6); //false

Chyby sa vyskytujú, pretože počítač alebo iné elektronické zariadenie vykonáva všetky výpočty v 2. číselnej sústave. Tie. Pred vykonaním akýchkoľvek akcií musí počítač najskôr previesť čísla uvedené vo výraze do 2. číselnej sústavy. Ale nie každé desatinné číslo sa dá presne znázorniť v 2. číselnej sústave.

Napríklad číslo 0,25 10 sa prevedie na binárne presne.

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

Napríklad číslo 0,2 10 je možné previesť na systém 2 len s určitou presnosťou:

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

V dôsledku toho tieto chyby ovplyvnia výpočet súčtu dvoch čísel a výsledky porovnania. Tie. Ukazuje sa, že JavaScript skutočne uvidí tento záznam takto:

0.6000000000000001==0.6

Pri výpočte alebo zobrazení čísel so zlomkovými časťami musíte vždy uviesť, s akou presnosťou to chcete urobiť.

Napríklad porovnávajte čísla s presnosťou na 2 desatinné miesta pomocou metód toFixed() a toPrecision():

//metóda toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //pravda //metóda toPrecision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //pravda

Základné matematické operácie

V JavaScripte existujú nasledujúce matematické operátory: + (sčítanie), - (odčítanie), * (násobenie), / (delenie), % (modulo), ++ (zvýšenie hodnoty o 1), -- (zníženie hodnoty o 1).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, t.j. 6:3=2 => 6-3*2 => zvyšok(0) 5%2 //1, t.j. 5:2=2(,5) => 5-2*2 => zvyšok(1) 7,3%2 //1,3, t.j. 7.3:2=3(.65) => 7.3-2*3 => zvyšok(1.3) //znamienko výsledku operácie % sa rovná znamienku prvej hodnoty -9%2.5 //-1.5 , t.j. 9:2,5=3(,6) => 9-2,5*3 => zvyšok(1,5) -9%-2,5 //-1,5, t.j. 9:2,5=3(,6) => 9-2,5*3 => zvyšok(1,5) -2%5 //-2, t.j. 2:5=0(.4) => 2-5*0 => zvyšok(2) x = 3; console.log(x++); //vypíše 3, potom nastaví 4 console.log(x); //4 x = 3; console.log(++x); //nastaví 4 a vypíše x = 5; console.log(x--); //vypíše 5, potom nastaví 4 console.log(x); //4 x = 5; console.log(--x); //nastaví 4 a výstupy Okrem toho má JavaScript kombinované operátory: x+=y (x=x+y), x-=y (x=x-y), x*=y (x=x*y), x/= y (x=x/y), x%=y (x=x%y).

V tomto článku sa podrobne pozrieme na čísla, matematické operátory, spôsoby prevodu čísla na reťazec a naopak, ako aj na mnohé ďalšie dôležité body.

funkcia isFinite

Funkcia isFinite vám umožňuje skontrolovať, či je argument konečným číslom.

IsFinite(73); // true isFinite(-1/0); // false isFinite(Infinity); // false isFinite(NaN); // false isFinite("Text"); // nepravda

JavaScript má okrem globálnej funkcie isFinite aj metódu Number.isFinite. Na rozdiel od isFinite nevynúti prevod argumentu na číslo.

IsFinite("73"); // true Number.isFinite("73"); // nepravda

isNaN funkcia

Funkcia isNaN je navrhnutá tak, aby určila, či je argument číslo alebo či sa dá skonvertovať na číslo. Ak áno, funkcia isNaN vráti hodnotu false. V opačnom prípade vráti hodnotu true.

Ak je potrebné vykonať túto akciu bez pretypovania, použite metódu Number.isNaN. Táto metóda bola zavedená do jazyka počnúc ECMAScript 6.

Ako explicitne previesť reťazec na číslo?

Reťazec môžete explicitne previesť na číslo pomocou nasledujúcich metód:

1. Použitie unárny operátor +, ktorý musí byť umiestnený pred hodnotou.

+"7,35"; // 7,35 +"text"; // NaN

Táto metóda ignoruje medzery na začiatku a na konci riadku, ako aj \n (riadkový posuv).

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

Null; //0 +true; //1 +false; //0 +" "; //0

ParseInt("18px"); //18 parseInt("33,3%"); //33

Táto funkcia môže pracovať s rôznymi číselnými sústavami (dvojkové, osmičkové, desiatkové, hexadecimálne). Základ číselnej sústavy je špecifikovaný pomocou 2 argumentov.

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

JavaScript má okrem funkcie parseInt aj metódu Number.parseInt. Táto metóda sa nelíši od funkcie parseInt a bola zavedená do JavaScriptu so špecifikáciou ECMASCRIPT 2015 (6).

3. funkcia parseFloat. Funkcia parseFloat je podobná funkcii parseInt , okrem toho, že vám umožňuje previesť argument na zlomkové číslo.

ParseFloat("33,3%"); //33.3

Okrem toho funkcia parseFloat na rozdiel od parseInt nemá 2 argumenty, a preto sa vždy snaží s reťazcom zaobchádzať ako s číslom v desiatkovej sústave.

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

JavaScript má okrem funkcie parseFloat aj metódu Number.parseFloat. Táto metóda sa nelíši od funkcie parseFloat a bola zavedená do JavaScriptu so špecifikáciou ECMASCRIPT 2015 (6).

Prevod čísla na reťazec

Číslo môžete zmeniť na reťazec pomocou metódy toString.

(12.8).toString(); //"12,8"

Metóda toString vám tiež umožňuje určiť základ číselného systému, berúc do úvahy, ktorý musíte explicitne previesť číslo na reťazec:

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

Ako skontrolovať, či premenná je číslo

Pomocou jednej z nasledujúcich metód môžete určiť, či je hodnota premennej číslo:

1. Použitie funkcií isNaN a isFinite:

// myVar je premenná if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar je číslo alebo ho možno pretypovať);

Ako funkcia:

// funkcia function isNumeric(value) (return !isNaN(parseFloat(value)) && isFinite(parseFloat(value)); ) // use var myVar = "12px"; console.log(isNumeric(myVar)); //pravda

2. Pomocou operátora typeof a isFinite funkcie isNaN:

Táto funkcia určuje, či je zadaná hodnota typu Number a či ide o jednu zo špeciálnych hodnôt Infinity, -Infinity a NaN. Ak áno, potom táto funkcia vráti hodnotu true.

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

Cislo.isInteger("20"); //false, pretože táto metóda nekonvertuje reťazec na číslo Number.isInteger(20); //pravda, pretože táto hodnota je číslo

Párne a nepárne čísla

Pomocou nasledujúcich funkcií môžete skontrolovať, či je číslo párne alebo nepárne:

// Funkcia na kontrolu čísla pre funkciu párnej parity isEven(n) ( return n % 2 == 0; ) // Funkcia na kontrolu čísla pre funkciu párnej parity isOdd(n) ( return Math.abs(n % 2) == 1;)

Pred vykonaním takejto kontroly sa však odporúča uistiť sa, že zadaná hodnota je číslo:

hodnota = 20; if (Number.isInteger(value)) ( if (isEven(value)) ( console.log("Číslo " + hodnota.toString() + " - párne"); ) )

Prvočísla v Javascripte

Pozrime sa na príklad, v ktorom pomocou Javascriptu zobrazíme prvočísla od 2 do 100.

Zaokrúhlenie čísla v Javascripte

Existujú rôzne spôsoby, ako v JavaScripte zaokrúhliť zlomok na celé číslo.

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

2. Pomocou metódy toFixed(precision). Táto metóda zaokrúhľuje zlomkovú časť čísla na zadanú presnosť. Výsledok zaokrúhlenia sa vráti ako reťazec.

Console.log(7.987.toFixed(2)); //"7,99"

Ak nie je dostatok desatinných miest na vytvorenie špecifikovanej presnosti čísla, doplní sa nulami.

Console.log(7.987.toFixed(5)); //"7,98700"

4. Použitie logických operátorov NOT alebo OR.

//cez dvojitú logickú negáciu console.log(~~7.9); //7 // pomocou logického OR s nulou: console.log(7.9^0); //7

Celé číslo a zlomková časť čísla

Celú časť čísla môžete získať pomocou metód Math.floor() a parseInt():

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

Console.log (7,21%1); // 0,20999999999999996 // s presnosťou na 2 desatinné miesta console.log((7,21%1).toFixed(2)); // "0,21"

Okrem toho je možné zlomkovú časť získať aj pomocou výpočtov:

Číslo var = 7,21; var zlomokNumber = číslo - Math.floor(Math.abs(číslo)); console.log(fractionNumber); // 0,20999999999999996

Je číslo deliteľné celým číslom?

Či je číslo deliteľné celým číslom, môžete určiť pomocou operátora percent:

Formátovanie čísel

V JavaScripte vám metóda toLocaleString() umožňuje formátovať výstup čísla v súlade s regionálnymi štandardmi (jazykové nastavenia operačného systému).

Napríklad naformátujme číslo v súlade s regionálnymi normami, ktoré sú štandardne nainštalované v systéme:

Číslo var = 345,46; console.log(number.toLocaleString()); //"345,46"

Napríklad naformátujme číslo 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 ako meny:

Predstavuje číslo v percentách:

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

Rozdeľte číslo na číslice (vlastnosť useGrouping):

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

Vytlačte číslo s určitým počtom číslic (2) za desatinnou čiarkou:

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

Porovnanie čísel

Porovnajme napríklad dve čísla:

Console.log(2>3); //false console.log(5>=3); //pravda

Pri porovnávaní čísel s zlomkovou časťou je potrebné vziať do úvahy chyby, ktoré môžu pri týchto výpočtoch vzniknúť.

Napríklad v JavaScripte sa súčet čísel (0,2 + 0,4) nerovná 0,6:

Console.log((0,2+0,4)==0,6); //false

Napríklad číslo 0,25 10 sa prevedie na binárne presne.

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

Napríklad číslo 0,2 10 je možné previesť na systém 2 len s určitou presnosťou:

V dôsledku toho tieto chyby ovplyvnia výpočet súčtu dvoch čísel a výsledky porovnania. Tie. Ukazuje sa, že JavaScript skutočne uvidí tento záznam takto:

0.6000000000000001==0.6

Pri výpočte alebo zobrazení čísel so zlomkovými časťami musíte vždy uviesť, s akou presnosťou to chcete urobiť.

Napríklad porovnávajte čísla s presnosťou na 2 desatinné miesta pomocou metód toFixed() a toPrecision():

//metóda toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //pravda //metóda toPrecision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //pravda

Základné matematické operácie

V JavaScripte existujú nasledujúce matematické operátory: + (sčítanie), - (odčítanie), * (násobenie), / (delenie), % (modulo), ++ (zvýšenie hodnoty o 1), -- (zníženie hodnoty o 1).