Javascriptové celočíselné a zlomkové části. Odebrat – Oddělení celých čísel se zbytkem v JavaScriptu? Zaokrouhlete na nejbližší násobek

Toto opravuje odpověď @ MarkElliot, aby fungovala i pro záporná čísla:

Var div = Math.trunc (y / x); var rem = y% x;

Všimněte si, že matematické metody mají přednost před bitovými operátory v tom, že pracují s čísly většími než 2 31.

JavaScript vypočítá pravou polovinu záporných čísel a zbytek necelých čísel podle jejich matematických definic.

FLOOR je definováno jako „největší celé číslo menší než parametr“, tedy:

• kladná čísla: PODLAŽÍ (X) = celá část X;
• záporná čísla: PODLAŽÍ (X) = celá část X mínus 1 (protože musí být MENŠÍ než parametr, tj. zápornější!)

REMAINDER je definován jako "zbývající" dělení (euklidovská aritmetika). Když dividenda není celé číslo, faktor obvykle také není celé číslo, tj. neexistuje žádný zbytek, ale pokud je faktor nucen být celým číslem (a to se stane, když se někdo pokusí získat zbytek nebo modul a číslo s plovoucí desetinnou čárkou ), samozřejmě bude necelé číslo "opuštěno".

JavaScript počítá vše podle očekávání, takže programátor musí být opatrný, aby kladl správné otázky (a lidé si musí dávat pozor, aby odpovídali na to, na co se ptají!) Yarinova první otázka NEBYLA „co je celé číslo dělení X Y“, místo tohoto: "Celé číslo, kolikrát dané celé číslo přejde k jinému". Pro kladná čísla je odpověď stejná pro obě, ale ne pro záporná čísla, protože celočíselné dělení (dělitel dělitelem) bude o -1 menší, než číslo (dělitel) "jde do jiného" (dividenda). Jinými slovy, FLOOR vrátí správnou odpověď pro celočíselné dělení záporného čísla, ale Yarin se na to neptal!

gammax odpověděl správně, tento kód funguje podle pokynů Yarin. Na druhou stranu, Samuel se mýlí, asi to neudělal, nebo by viděl, že to skutečně funguje (také neřekl, jaký byl dělitel jeho příkladu, ale doufám, že to bylo 3):

Zbytek = X % Y = -100 % 3 = -1

GoesInto = (X - zbytek) / Y = (-100 - -1) / 3 = -99 / 3 = -33

BTW, testoval jsem kód na Firefoxu 27.0.1, fungoval podle očekávání s kladnými a zápornými čísly a také neceločíselnými hodnotami, pro dividendy i dělitele. Příklad:

100,34 / 3,57: GoesInto = -28, Zbytek = -0,3800000000000079

Ano, všiml jsem si, že je tam problém s vysokou věrností, ale neměl jsem čas to zkontrolovat (nevím, jestli je problém s Firefoxem, Windows 7 nebo mým CPU FPU). Nicméně na Yarinovu otázku, která obsahuje pouze celá čísla, kód gammax funguje dobře.

K získání zkráceného výsledku můžete použít funkci parseInt.

ParseInt (a / b)

Chcete-li získat zbytek, použijte příkaz mod:

parseInt má některá úskalí s řetězci, aby se zabránilo použití parametru radix se základem 10

ParseInt ("09", 10)

V některých případech může být řetězcová reprezentace čísla vědecká notace, v takovém případě parseInt vytvoří nesprávný výsledek.

ParseInt (1000000000000000000000000000000, 10) // 1e + 32

Toto volání poskytne výsledek 1.

Výpočet počtu stránek lze provést v jednom kroku: Math.ceil (x / y)

Pokud právě sdílíte pravomoci těchto dvou, můžete použít bitové operátory:

Exportní funkce divisionBy2 (num) (návrat;) exportní funkce divisionBy4 (num) (návrat;) exportní funkce divisionBy8 (num) (návrat;)

(První je kvocient, druhý je zbytek)

Toto se vždy zkrátí na nulu. Nejsem si jistý, jestli není příliš pozdě, ale píše se zde:

Funkce intdiv (dividenda, dělitel) (dělitel = dělitel - dělitel% 1; if (dělitel == 0) vyvolá novou chybu ("dělení nulou"); dělitel = dělenec - dělenec% 1; var rem = dělitel% dělitel; návrat (zbytek: rem, kvocient: (dividenda - rem) / dělitel);)

Nejsem odborník na bitové operátory, ale tady je další způsob, jak získat celé číslo:

Var num = ~~ (a / b);

To bude fungovat dobře i pro záporná čísla, zatímco Math.floor () se bude otáčet špatným směrem.

I toto se zdá být správné:

Var num = (a / b) >> 0;

Math.floor (operace) vrací zaokrouhlenou hodnotu operace.

Příklad první otázky:

Var x = 5; var y = 10,4; var z = Math.podlaží (x + y); console.log (z);

Předpona:

Příklad 2. otázky:

Var x = 14; var y = 5; var z = Math.floor (x% y); console.log (x);

Předpona:

Pro nějaké číslo y a nějaký dělitel x vypočítejte podíl a zbytek jako:

Var kvocient = Math.floor (y / x); var zbytek = y% x;

Výpočty v JavaScriptu často nedávají přesně takové výsledky, jaké bychom chtěli. S čísly můžeme samozřejmě dělat cokoli – zaokrouhlovat nahoru nebo dolů, nastavovat rozsahy, ořezávat nepotřebná čísla na určitý počet desetinných míst, vše záleží na tom, co s tímto číslem chcete v budoucnu dělat.

Proč je nutné zaokrouhlování?

Jedním ze zvláštních aspektů JavaScriptu je, že ve skutečnosti neukládá celá čísla, okamžitě pracujeme s čísly s plovoucí desetinnou čárkou. To ve spojení se skutečností, že mnoho zlomkových hodnot nelze vyjádřit v konečných počtech desetinných míst, můžeme v JavaScriptu získat výsledky takto:

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Pro praktické účely tato nepřesnost vůbec nevadí, v našem případě se bavíme o chybě kvintilionů dílů, nicméně to může někoho zklamat. Při práci s čísly, která představují hodnoty měn, procent nebo velikosti souborů, můžeme získat trochu zvláštní výsledek. Abychom tyto nepřesnosti opravili, potřebujeme umět výsledky zaokrouhlit, přičemž stačí nastavit desetinnou přesnost.

Zaokrouhlování čísel má praktické uplatnění, můžeme manipulovat s číslem v určitém rozsahu, chceme například zaokrouhlit hodnotu na nejbližší celé číslo a nepracovat pouze s desetinnou částí.

Zaokrouhlování desetinných čísel

Chcete-li odstranit desetinné číslo, použijte metodu toFixed nebo toPrecision. Oba používají jeden argument, který určuje, kolik platných číslic (tj. celkový počet číslic použitých v čísle) nebo desetinných míst (číslo za desetinnou čárkou) by měl výsledek obsahovat:

1. Pokud argument není definován pro toFixed (), bude výchozí hodnota nula, což znamená 0 ​​desetinných míst, argument má maximální hodnotu 20.
2. Pokud není zadán žádný argument pro toPrecision, číslo zůstane nedotčeno

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 () i toPrecision () vracejí řetězcovou reprezentaci výsledku, nikoli číslo. To znamená, že když je zaokrouhlená hodnota sečtena s randNum, budou řetězce zřetězeny, nikoli součet čísel:

Nechť randNum = 6,25; let rounded = randNum.toFixed (); // "6" console.log (randNum + zaokrouhleno); > "6,256"
Pokud chcete, aby výsledek měl číselný datový typ, budete muset použít parseFloat:

Nechť randNum = 6,25; let rounded = parseFloat (randNum.toFixed (1)); console.log (zaoblený); > 6.3
Všimněte si, že 5 hodnot je zaokrouhleno kromě vzácných případů.

Metody toFixed () a toPrecision () jsou užitečné, protože mohou nejen odstranit zlomkovou část, ale také doplnit desetinná místa, což je výhodné při práci s měnou:

Nechť celéNum = 1 nechť dolaryCenty = celéČíslo.toFixed (2); console.log (dollarsCents); > "1,00"
Vezměte prosím na vědomí, že toPrecision poskytne výsledek v exponenciálním zápisu, pokud je počet celých čísel větší než samotná přesnost:

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

Jak se vyhnout chybám při zaokrouhlování u desetinných čísel

V některých případech toFixed a toPrecision zaokrouhlí 5 dolů a nahoru:

Nechť numTest = 1,005; numTest.toFixed (2); > "1,00"
Výše uvedený výsledek výpočtu by měl být 1,01, nikoli 1. Pokud se této chybě chcete vyhnout, můžeme použít řešení navržené Jackem L Moorem, které k výpočtu používá exponenciální čísla:

Funkce round (hodnota, desetinná místa) (vrácení čísla (Math.round (hodnota + "e" + desetinná místa) + "e -" + desetinná místa);)
Nyní:

Kolo (1,005,2); > 1.01
Pokud chcete robustnější řešení než to uvedené výše, můžete zamířit na MDN.

Strojní epsilonové zaokrouhlování

V ES6 byla zavedena alternativní metoda pro zaokrouhlování desetinných čísel. Strojové zaokrouhlení epsilon poskytuje přiměřenou chybovost při porovnávání dvou čísel s pohyblivou řádovou čárkou. Bez zaokrouhlení mohou srovnání přinést výsledky podobné následujícím:

0,1 + 0,2 === 0,3> nepravda
Abychom získali správné srovnání, používáme v naší funkci Math.EPSILON:

Funkce epsEqu (x, y) (návrat Math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Funkce má dva argumenty: první je aktuální výpočet, druhý je očekávaný výsledek. Vrátí srovnání těchto dvou:

EpsEqu (0,1 + 0,2, 0,3)> true
Všechny moderní prohlížeče již podporují matematické funkce ES6, ale pokud chcete podporu v prohlížečích, jako je IE 11, použijte polyfills.

Zlomkové oříznutí

Všechny výše uvedené metody vědí, jak zaokrouhlovat na desetinná čísla. Chcete-li číslo jednoduše oříznout na dvě desetinná místa, musíte jej nejprve vynásobit 100 a poté vydělit výsledek 100:

Funkce zkrácena (num) (return Math.trunc (num * 100) / 100;) zkrácena (3,1416)> 3,14
Pokud chcete pojmout libovolný počet desetinných míst, můžete použít dvojitou bitovou negaci:

Funkce zkrácena (num, decimalPlaces) (nech numPowerConverter = Math.pow (10, decimalPlaces); return ~~ (num * numPowerConverter) / numPowerConverter;)
Nyní:

Nechť randInt = 35,874993; zkrácený (randInt, 3); > 35,874

Zaokrouhlení na nejbližší číslo

Chcete-li zaokrouhlit desetinné číslo nahoru nebo dolů, podle toho, co se nejvíce blíží, použijte Math.round ():

Mat.kolo (4.3)> 4 Mat.kolo (4.5)> 5
Všimněte si, že "polovina hodnoty", 0,5, se zaokrouhluje nahoru podle pravidel matematiky.

Zaokrouhlete dolů na nejbližší celé číslo

Pokud chcete vždy zaokrouhlit dolů, použijte Math.floor:

Math.floor (42,23); > 42 Matematická podlaha (36,93); > 36
Pamatujte, že zaokrouhlení dolů funguje pro všechna čísla, včetně záporných. Představte si mrakodrap s nekonečným počtem pater, včetně těch na nižší úrovni (představující záporná čísla). Pokud jste ve výtahu na nižší úrovni mezi 2 a 3 (což je hodnota -2,5), Math.floor vás vezme dolů na -3:

Math.floor (-2,5); > -3
Pokud se ale této situaci chcete vyhnout, použijte Math.trunc, který je podporován ve všech moderních prohlížečích (kromě IE / Edge):

Math.trunc (-41,43); > -41
Na MDN najdete polyfill, který bude poskytovat podporu pro Math.trunc v prohlížečích a IE / Edge.

Zaokrouhlete nahoru na nejbližší celé číslo

Na druhou stranu, pokud potřebujete vždy zaokrouhlit nahoru, použijte Math.ceil. Znovu si pamatujme na nekonečný výtah: Math.ceil bude vždy stoupat, bez ohledu na to, zda je číslo záporné nebo ne:

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

Zaokrouhlení nahoru / dolů podle potřeby

Pokud chceme zaokrouhlit na nejbližší násobek 5, nejjednodušším způsobem je vytvořit funkci, která vydělí číslo 5, zaokrouhlí je a pak je vynásobí stejnou hodnotou:

Funkce roundTo5 (num) (návrat Math.round (num / 5) * 5;)
Nyní:

RoundTo5 (11); > 10
Pokud chcete zaokrouhlit na násobky své hodnoty, použijeme obecnější funkci, předáme počáteční hodnotu a násobek:

Funkce roundToMultiple (počet, násobek) (vrácení Math.round (počet / násobek) * násobek;)
Nyní:

Nechť initialNumber = 11; nechť násobek = 10; roundToMultiple (počátečníNumber, násobek); > 10;

Oprava čísla v rozsahu

Existuje mnoho případů, kdy chceme získat x v rozsahu. Můžeme například chtít hodnotu mezi 1 a 100, ale dostaneme hodnotu 123. K vyřešení tohoto problému můžeme použít min (vrátí nejmenší ze sady čísel) a max (vrátí největší z libovolné sady čísel ). V našem příkladu je rozsah od 1 do 100:

Nechť lowBound = 1; nech highBound = 100; nechť numInput = 123; nechat upnuté = Math.max (lowBound, Math.min (numInput, highBound)); console.log (upnutý); > 100;
Opět můžeme operaci znovu použít a celé to zabalit do funkce, použijme řešení navržené Danielem X. Mooreem:

Number.prototype.clamp = funkce (min, max) (návrat Math.min (Math.max (toto, min), max););
Nyní:

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

Gaussovo zaokrouhlení

Gaussovské zaokrouhlování, známé také jako zaokrouhlení bank, je místo, kde se zaokrouhluje na nejbližší sudý. Tato metoda zaokrouhlování funguje bez statistické chyby. Nejlepší řešení navrhl Tim Down:

Funkce gaussRound (num, desetinná místa) (ať d = desetinná místa || 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; }
Nyní:

GaussRound (2.5)> 2 GaussRound (3.5)> 4 GaussRound (2.57,1)> 2.6
Desetinná čárka v CSS:

Vzhledem k tomu, že JavaScript se často používá ke generování pozičních transformací prvků HTML, můžete se divit, co se stane, když pro naše prvky vygenerujeme desetinné hodnoty:

#box (šířka: 63,667731993px;)
Dobrou zprávou je, že moderní prohlížeče budou brát v úvahu desetinné hodnoty v krabicovém modelu, včetně procent nebo jednotek pixelů.

Řazení

Velmi často musíme některé prvky třídit, například máme řadu herních záznamů a musí být uspořádány v sestupném pořadí podle pořadí hráčů. Bohužel, standardní metoda řazení () má některá překvapivá omezení: funguje dobře s běžně používanými anglickými slovy, ale okamžitě se rozpadne, když narazíte na čísla, jedinečné znaky nebo velká písmena.

Seřadit podle abecedy

Zdá se, že seřadit pole podle abecedy by mělo být nejjednodušším úkolem:

Nechte ovoce = ["butternut squash", "meruňka", "cantaloupe"]; ovoce.třídit (); > "meruňka", "máslová dýně", "cantaloupe"]
Jakmile je však jeden z prvků velkými písmeny, narazíme na problém:

Nechte ovoce = ["butternut squash", "meruňka", "Cantalope"]; ovoce.třídit (); > "Cantaloupe", "meruňka", "máslová dýně"]
Je to proto, že ve výchozím nastavení třídič porovnává první znak reprezentovaný v Unicode. Unicode je jedinečný kód pro jakýkoli znak, bez ohledu na platformu, bez ohledu na program, bez ohledu na jazyk. Pokud se například podíváte do kódové tabulky, znak "a" má hodnotu U + 0061 (v šestnáctkové soustavě 0x61), zatímco znak "C" má kód U + 0043 (0x43), který je uveden dříve v Unicode tabulka než znak "A".

Abychom seřadili pole, které může obsahovat smíšená velká a malá písmena prvních písmen, musíme buď dočasně převést všechny prvky na malá písmena, nebo definovat vlastní pořadí řazení pomocí metody localeCompare () s některými argumenty. Zpravidla je pro takový případ lepší okamžitě vytvořit funkci pro opakované použití:

Funkce alphaSort (arr) (arr.sort (funkce (a, b) (vrácení a.localeCompare (b, "en", ("citlivost": "základ"));));) nechť ovoce = ["máslová dýně "," meruňka "," Cantaloupe "]; alphaSort (ovoce)>
Pokud chcete získat pole seřazené v obráceném abecedním pořadí, stačí prohodit pozice a a b ve funkci:

Funkce alphaSort (arr) (arr.sort (funkce (a, b) (návrat b.localeCompare (a, "en", ("citlivost": "základ"));));) nechť ovoce = ["máslová dýně "," meruňka "," Cantaloupe "]; alphaSort (ovoce)> ["Cantaloupe", "máslová dýně", "meruňka"]
Zde stojí za zmínku, že localeCompare se používá s argumenty, musíte si také pamatovat, že je podporován IE11 +, pro starší verze IE jej můžeme použít bez argumentů a malými písmeny:

Funkce caseSort (arr) (arr.sort (funkce (a, b) (návrat a.toLowerCase (). LocaleCompare (b.toLowerCase ());));) nechť ovoce = ["butternut tykev", "meruňka", "Ananasový meloun"]; caseSort (ovoce)> ["meruňka", "máslová dýně", "Cantaloupe"]

Číselné řazení

To vše neplatí pro příklad, o kterém jsme hovořili výše o řadě herních záznamů. U některých číselných polí funguje řazení dobře, ale v určitém okamžiku může být výsledek nepředvídatelný:

Nechat highScores =; highScores.sort (); >
Faktem je, že metoda sort () provádí lexikografické srovnání: což znamená, že čísla budou převedena na řetězec a porovnání budou provedena znovu shodou prvního znaku tohoto řetězce v pořadí znaků tabulky Unicode. Proto musíme znovu definovat naše pořadí řazení:

Nechat highScores =; highScores.sort (funkce (a, b) (návrat a - b;)); >
Opět platí, že chcete-li seřadit čísla v opačném pořadí, prohoďte pozice a a b ve funkci.

Řazení struktury podobné JSON

A konečně, pokud máme datovou strukturu podobnou JSON, reprezentovanou jako pole herních záznamů:

Nechte skóre = [("jméno": "Daniel", "skóre": 21768), ("jméno": "Michael", "skóre": 33579), ("jméno": "Alison", "skóre": 38395 )];
V ES6 + můžete používat funkce šipek:

Scores.sort ((a, b) => b.score - a.score));
Pro starší prohlížeče, které tuto podporu nemají:

Scores.sort (funkce (a, b) (vrácení a.skóre - b.skóre));
Jak vidíte, řazení v JavaScriptu není samozřejmostí, doufám, že tyto příklady nějak usnadní život.

Práce s výkonovými funkcemi

Umocňování je operace původně definovaná jako výsledek vícenásobného násobení přirozeného čísla samo o sobě, druhá odmocnina z a je číslo, které dává a při druhé mocnině. Tyto funkce bychom mohli neustále používat v každodenním životě v hodinách matematiky, včetně počítání ploch, objemů nebo dokonce při fyzikálním modelování.

V JavaScriptu je exponenciální funkce reprezentována jako Math.pow (), v novém standardu ES7 je zaveden nový operátor umocňování - "* *".

Umocňování

Chcete-li umocnit číslo na n-tou mocninu, použijte funkci Math.pow (), kde první argument je číslo, které má být umocněno, druhý argument je exponent:

Math.pow (3,2)> 9
Tato forma zápisu znamená 3 na druhou nebo 3 × 3, což vede k výsledku 9. Můžete samozřejmě uvést jiný příklad:

Math.pow (5,3); > 125
To znamená, že 5 krychlových nebo 5 x 5 x 5 se rovná 125.

ECMAScript 7 je další verzí JavaScriptu, v zásadě můžeme použít nový navrhovaný operátor umocňování - * *, tato forma zápisu může být popisnější:

3 ** 2 > 9
V současné době je podpora tohoto operátora spíše omezená, proto se nedoporučuje používat.

Funkce napájení se může hodit v celé řadě situací. Jednoduchý příklad pro výpočet počtu sekund za hodinu: Math.pow (60,2).

Čtvercová a krychlová odmocnina

Math.sqrt () a Math.cbrt () jsou opakem funkce Math.pow (). Pamatujte, že druhá odmocnina z a je číslo, které dává a, když je na druhou.

Math.sqrt (9)> 3
Zároveň je třetí odmocnina čísla a číslem, které dává a, když je povýšeno na krychli.

Math.cbrt (125)> 5
Math.cbrt () byl zaveden do specifikace JavaScriptu velmi nedávno, a proto je podporován pouze v moderních prohlížečích: Chrome 38+, Firefox a Opera 25+ a Safari 7.1+. Všimnete si, že v tomto seznamu chybí Internet Explorer, nicméně na MDN najdete polyfill.

Příklady

V jedné z těchto funkcí můžeme samozřejmě použít i neceločíselné hodnoty:

Math.pow (1,25, 2); > 1,5625 Math.cbrt (56,57)> 3,8387991760286138
Všimněte si, že to také funguje dobře pro záporné hodnoty argumentů:

Math.pow (-5,2)> 25 Math.pow (10, -2)> 0,01
Pro druhou odmocninu to však nebude fungovat:

Math.sqrt (-9)> NaN
Z matematické analýzy víme, že imaginární číslo je chápáno jako odmocniny záporných čísel. A to by nás mohlo přivést k další technice pro práci s komplexními čísly, ale to je jiný příběh.

K vyhledání druhé a třetí odmocniny čísel můžete použít zlomkové hodnoty v Math.pow (). Druhá odmocnina používá exponent 0,5:

Math.pow (5, 0,5); // = Math.sqrt (5) = 5 ** (1/2)> 2,23606797749979
Kvůli rozmarům s pohyblivou řádovou čárkou však nemůžete přesně odhadnout správný výsledek:

Math.pow (2,23606797749979,2)> 5,00000000000001
V takových situacích se budete muset uchýlit ke zkrácení znamének z čísla nebo zaokrouhlení na nějakou hodnotu.

Někteří si z nějakého neznámého důvodu v JavaScriptu pletou funkci Math.pow () s Math.exp (), což je exponenciální funkce pro čísla obecně. Poznámka: V angličtině se „exponent“ překládá jako „exponent“, takže to spíše odkazuje na anglicky mluvící, ačkoli existují alternativní názvy pro exponent, jako je index, mocnina.

Matematické konstanty

Práci s matematikou v JavaScriptu usnadňuje řada vestavěných konstant. Tyto konstanty jsou vlastnostmi objektu Math. Stojí za zmínku, že konstanty jsou psány velkými písmeny, nikoli zápisem CamelCase.

Math.abs, parseInt, parseFloat

Práce s čísly v JavaScriptu může být mnohem složitější, než se zdá. Získané hodnoty ne vždy spadají do očekávaných rozsahů, někdy výsledek nemusí být vůbec takový, jaký jsme očekávali.

Math.abs ()

Metoda Math.abs () vrací absolutní hodnotu čísla, což nám připomíná analogickou matematickou funkci pro modul čísla.

Nechť newVal = -57,64; Math.abs (newVal); > 57,64
Math.abs (0) vždy vrátí nulu, ale pokud před funkci -Math.abs (NUM) vložíme znaménko mínus, budeme vždy záporní.

Math.abs (0); > -0

parseInt ()

Víme, že JavaScript chápe, že „15“ je řetězec, nikoli číslo, a například při analýze vlastností CSS pomocí JavaScriptu nebo získání nějaké hodnoty z nepřipraveného pole mohou být naše výsledky nepředvídatelné. Jako vstup jsme mohli obdržet řetězec reprezentovaný jako „17px“, a to u nás není neobvyklé. Otázkou je, jak tento řetězec převést na skutečnou hodnotu a použít ji v dalších výpočtech.

Syntaxe: parseInt (řetězec, radix);

Funkce parseInt převede první argument, který jí byl předán, na typ řetězce, interpretuje jej a vrátí celé číslo nebo hodnotu NaN. Výsledek (pokud nejde o NaN) je celé číslo a je to první argument (řetězec), s nímž se zachází jako s číslem v zadaném základu. Například základ 10 označuje převod z desítkové soustavy, 8 na osmičkovou, 16 na hexadecimální a tak dále. Pokud je základ větší než 10, pak se k označení čísel větších než 9 použijí písmena. Například hexadecimální čísla (základ 16) používají písmena A až F.

Podívejme se na příklad práce s vlastnostmi CSS, kde relativně vzato můžeme získat následující hodnotu:

Nechť elem = dokument.tělo; let centerPoint = window.getComputedStyle (elem) .transformOrigin; > "454px 2087,19px"
Hodnoty můžeme rozdělit mezerami:

Nechť centra = centerPoint.split (""); > ["454px", "2087,19px"]
Každý prvek je však stále řetězec, toho se můžeme zbavit použitím naší funkce:

Nechť centerX = parseInt (centers, 10); > 454 let centerY = parseInt (centers, 10); > 2087
Jak vidíte, jako druhý argument uvádíme číselnou soustavu, do které se bude číslo převádět, tento parametr je volitelný, ale doporučujeme jej použít v případě, že nevíte, jaký řetězec bude na vstup odeslán.

parseFloat ()

Z výše uvedeného příkladu jste si mohli všimnout, že parseInt zahodí zlomkovou část. V našem případě je parseFloat schopen pracovat s čísly s pohyblivou řádovou čárkou. Opět to může být užitečné při analýze CSS a dalších úlohách, zejména při práci s procenty s pohyblivou řádovou čárkou.

Syntaxe: parseFloat (řetězec)

Nechť FP = "33,33333 %"; console.log (parseFloat (FP)); > 33,33333
Všimněte si, že v syntaxi parseFloat není žádný druhý argument.

Chápeme, že parseInt () a parseFloat () jsou extrémně užitečné funkce, je důležité mít na paměti, že to není bez chyb, takže je nutné zkontrolovat rozsah očekávaných hodnot a nakonec analyzovat výsledek, aby bylo zajištěno, že získané hodnoty jsou správné.
Odeslat anonymně

V této části našich lekcí se seznámíme s objektem Číslo jako u kontejneru číselného datového typu. Jeho vlastní entity bude dnes velmi povrchně dotčeno.

Stejně jako předmět Tětiva obsahuje řádky textu, objekt Číslo obsahuje čísla. Stejně jako řetězce se i čísla, která vytvoříme, automaticky stanou instancemi objektu.

Typ dat čísla

Čísla v JavaScriptu jsou dvou typů: celá čísla a pohyblivá řádová čárka (neexistují žádné dělení na mnoho typů, jako v jiných jazycích - celé číslo, dlouhé, krátké, dvojité). Čísla s plovoucí desetinnou čárkou mají celé a zlomkové části, oddělené tečkou (bez ohledu na národní prostředí).

Tyto dva typy čísel nejsou nezávislé typy a nevyžadují mezi sebou zvláštní převod. Pokud např. 32.5 násobíme tím 0.4 , pak okamžitě dostaneme celé číslo 13 , ani zlomek 13.0 , kterou je potřeba převést na celočíselnou hodnotu (jako vždy v jiných jazycích).

Vytvoření objektu Number

Stejně jako řetězec je číslo obvykle instancí jako objekt Číslo, jednoduché přiřazení (na rozdíl od řetězce nejsou vyžadovány uvozovky).

var myNum = 21;

Ale můžete také vytvořit nový objekt pomocí konstruktoru:

var myNum = nové číslo; myNum = 21;

V drtivé většině případů je to zbytečné a dokonce škodlivé. Správné příklady takové práce s předměty zvážíme ve 4. části.

Reprezentace čísel

Exponenciální forma

Čísla mohou být reprezentována v normální i exponenciální formě, například:

2e6 // bez mezer!

To znamená: 2 × 10 6

Pokud takové číslo vypíšeme pomocí metody document napsat (), pak dostaneme rozšířené číslo v obvyklé reprezentaci.

Dokument. napsat(14e12);

Výsledek:

Základní číselné soustavy

Čísla mohou být také reprezentována v desítkové, šestnáctkové a osmičkové soustavě.

Celý desetinná čísla nemusí začínat od nuly protože nula je předpona pro jiné než desítkové soustavy. Prostě 0 Je předpona pro osmičkové hodnoty a 0x- pro hexadecimální.

Například, 075 Je osmičkovým vyjádřením desetinného čísla 61 , a 0x75- hexadecimální vyjádření desítkového čísla 117 .

Pro osmičkové hodnoty čísla od 0 před 7 , pro hexadecimální - alfanumerický řádek 0123456789ABCDEF... Lze použít písmena v jakémkoli registru.

V aritmetických výrazech lze použít jakoukoli formu čísla, ale výsledkem bude vždy desetinné číslo.

Reprezentace čísel v jiných systémech

Mluvit o předmětu Tětiva, dotkli jsme se metody toString () který převede jakýkoli objekt na řetězec. Při převodu čísel na řetězce je žádoucí zadat číselný systém jako argument.

Poznámka

Původní číslo musí být uzavřeno v závorkách

(číslo). toString(Systém)

Systém- může nabývat libovolných hodnot od 2 do 36.

(157 ).toString(2 ); // binární reprezentace 157, rovná se (53 ).toString(27 ); // exotická 27členná reprezentace 53 se rovná

Ale tyto výsledné výrazy jsou řetězce. Abyste z nich udělali reálná čísla v uvedených číselných soustavách, potřebujete výsledek metody toString (systém) převést zpět na číslo. To už se nedělá metodou, ale funkce jádra číslo (objekt)... O funkcích jádra budeme hovořit v jedné z nadcházejících lekcí, ale prozatím věnujte pozornost syntaxi, je podobná volání funkce:

var a = 1546; var b = a. toString(2); var c = Číslo(b);

Nebo najednou „dva v jednom“:

var a = 1546; var b = Číslo(A. toString(2 ));

Poznámka

Pokud je počáteční číslo přiřazeno proměnné, není nutné je při volání metody uzavírat do závorek toString () .

Vlastnosti objektu čísla

V lekci o objektu se dotkneme obecného konstruktoru vlastností objektu a prototypu. Objekt, a nyní přejděme ke konkrétním vlastnostem objektu Číslo.

Tyto vlastnosti jsou - pouze na čtení, to znamená, že je nemůžeme změnit.

MAX_VALUE

Maximální počet, který JavaScript zvládne.

Podívejme se, jaké je toto číslo:

var e = Číslo. MAX_VALUE dokument. napsat(E)

Výsledek:

1,7976931348623157e + 308

Plus v tomto případě není známkou sčítání, ale kladného stupně, tzn 1,7976931348623157 × 10 308

Poznámka

Obvykle demonstruji výsledky pomocí skutečných skriptů. Příliš mnoho zlomkových výpočtů však může zpomalit načítání stránky a většina výsledků v tomto tutoriálu je takříkajíc ručně psaná.

MIN_VALUE

A to je – podle toho – minimální hodnota. Pojďme to prozkoumat.

var f = Číslo. MIN_VALUE dokument. napsat(F)

Výsledek:

To znamená 5 × 10 -324

Nečíselná hodnota, se kterou jsme se již setkali.

Tato vlastnost je vrácena JavaScriptem, když numerická operace z nějakého důvodu vytvoří nenumerický výsledek.

NEGATIVE_INFINITY, POSITIVE_INFINITY

Jednou si mysleli něco takového: "jeden jelen, dva jeleni, mnoho jelenů."

JavaScript počítá o něco "pokročilejší": "jeden jelen, dva jeleni, tři jeleni, ..., 1,7976931348623157 × 10 308 jelenů, mnoho jelenů."

Toto transcendentní „mnoho“ je vyjádřeno vlastností POSITIVE_INFINITY.

V opačném procesu - rozdělení jednotky ("jeden jelen") na malé malé kousky - nejmenší díl, který lze přečíst, bude mít 5 × 10 -324. Cokoli méně už je NEGATIVE_INFINITY.

Metody číselných objektů

Poznámka: stejně jako v metodě toString () i ve všech ostatních metodách musí být původní číslo uzavřeno v závorkách, pokud je uvedeno explicitně (a nikoli jako proměnná).

toExponenciální ()

Vrátí řetězec představující číslo v exponenciálním zápisu s jednou číslicí před desetinnou čárkou.

Syntax:

číslo. až Exponenciální(počet znamení)

Argument počet znamení nastavuje přesnost zaokrouhlení za desetinnou čárkou. Pokud je vynechán, počet číslic za desetinnou čárkou se rovná počtu číslic potřebných k vyjádření hodnoty.

Příklad:

var myFullNumber = 4659872156831598853654127; dokument. napsat(myFullNumber.toExponential (4))

Výsledek:

toFixed ()

Vrátí řetězec představující číslo s pevnou čárkou zaokrouhlené na počet desetinných míst zadaný v argumentu.

Syntax:

číslo. na Opraveno(počet znamení)

Příklady:

var myDecimal1 = 46,59872156831598853654127; var myDecimal2 = 46; dokument. napsat(myDecimal1.toFixed (1)) dokumentu. napsat("
") dokument. napsat(myDecimal2.toFixed (3))

Výsledek:

Tato metoda je někdy velmi užitečná. Například těžkopádnou funkci z minulé lekce lze nyní reprezentovat takto:

funkce anyRootPlus (x, y) (var srcnum = Math. zk(Matematika. log(x) / y); var vysledek = (srcnum). na Opraveno(3); vrátit výsledek; )

Nyní jej vložíme do formuláře a otestujeme:

Pravda, nyní budou celá čísla se třemi nulami za bodem. Ale se znalostí chování čísel a řetězců, znalosti práce s podmíněnými operátory a převodu typů není tak těžké udělat potřebný numerický „návrh“.

toLocaleString ()

Převede číselný objekt na řetězcovou hodnotu, přičemž respektuje národní prostředí pro oddělovače desetinných míst a tisíců. Národní měna je brána jako základ, proto jsou v ruské verzi všechna čísla, dokonce i celá čísla, uváděna se dvěma desetinnými místy (kopecky):

var myDrob = 25,327; var myMnogo = 25635120; var myRoubl = 35; / * zvětšit, aby lépe viděly čárky * / dokument. napsat("

" + můjDrob. toLocaleString() + "

" ); dokument. napsat("

" + myMnogo. toLocaleString() + "

" ); dokument. napsat("

" + myRoubl. toLocaleString() + "

" );

Výsledek:

toPrecision ()

Vrátí řetězec představující číslo se zadaným celkovým počtem platných číslic.

Syntax:

číslo. na přesnost(počet číslic)

Argument:

počet číslic- počet číslic v zobrazeném řádku. Pokud je zadané množství větší než původní množství, zobrazí se desetinné nuly.

Dokument. napsat((354 ).na přesnost(8 ))

Výsledek:

Metody toPrecision () a toLocaleString () společně nefunguje, pro "ruský design" čísel jakékoli přesnosti budete muset napsat vlastní funkci. Psaná funkce může být doplňkovou metodou objektu Číslo, něco podobného jsme s objektem už dělali Datum ()... Více - v lekci o předmětu Objekt.

toString ()

Tuto metodu jsme již podrobně probrali na začátku lekce.

Vytvořte si vlastní metodu

Nyní vytvoříme stejnou metodu, která zobrazí číslo s libovolným počtem desetinných míst s mezerami mezi tisícinami a s čárkou jako oddělovačem desetinných míst.

K tomu potřebujeme poměrně záludnou funkci, která převede řetězce a pole získaná z instance objektu. Číslo.

Pojďme deklarovat metodu:

Number.prototype.toRussianString = toRussianString

Než začneme funkci budovat, zformulujme si úkoly.

Nejprve musíme číslo reprezentovat jako řetězec a extrahovat z něj část celého čísla, zlomkovou část a oddělovač.

Poté vložte potřebné mezery do celé části, zaokrouhlete zlomkovou část na počet znaků, které lze zadat jako argument funkce (a metody), a změňte tečku na čárku.

Začněme funkci deklarací požadovaných proměnných.

function toRussianString (prec) ( / * proměnné pro převod řetězců * / var a = "" , b = "" c, d, e;

Při pohledu do budoucna řeknu, že desetinná část v důsledku našich poruch strun ztrácí svou "zlomkovou" podstatu a musíme s ní pracovat jako s jiným celým číslem. K práci s ním použijeme metodu toPrecision (), a argument naší funkce (a zároveň naší metody) nastavuje hodnotu specificky pro metodu toPrecision ()... Minimální parametr pro tuto metodu je jedna. A pro naši funkci může být potřeba i nula (při zaokrouhlování na celé číslo). A přitom by správné zaokrouhlení mělo fungovat ještě předtím, než začneme předmět „rozporcovat“. Proto ihned při deklarování proměnných toto úskalí obejdeme:

/ * proměnná, která převádí danou instanci objektu na řetězec * / if (prec == 0) var str = this. na Opraveno(0 ).toStringtoString(10 );

Pokračujeme v deklarování proměnných.

/ * proměnná pro návratovou hodnotu * / var nr1; / * proměnné pro rozložené části * / var intpart, fractpaft, precpart, dělič, tečka = str. lastIndexOf("." ); / * čítač * / var i;

Variabilní tečka najde polohu bodu v řetězci zadaného čísla. V této poloze odřízneme celou část ( intpart). Pokud je číslo celé číslo a neexistuje žádný bod, jeho pozice bude menší než nula. V tomto případě oddělovač ( dělič) a zlomkovou část ( fraktpart) musí být prázdné řádky. V opačném případě je k oddělovači přiřazena čárka a zlomková část je zkrácena pro další práci:

pokud (tečka< 0 ) { intpart = str; fractpart = "" ; dělič = "" ;) else (intpart = str. podřetězec(0, tečka); fraktpart = str. podřetězec(tečka + 1, str. délka); dělič = "," ;}

Pracujeme s celým dílem. Mezery jsou potřeba pouze v případě, že obsahuje více než 3 znaky:

pokud (část. délka > 3 ) {

Nyní rozbalme následující „solitaire“ (to vše se děje uvnitř podmíněného operátoru):

Projdeme trojicemi v opačném pořadí.

Nejprve je shromáždíme do proměnné A bez jakýchkoli dodatků, jen pro výpočet délky výsledného podřetězce. Koneckonců, pokud celkový počet číslic nebyl dělitelný 3, pak vlevo zůstal ocas 1 nebo 2 číslic a nyní to můžeme vyjádřit jako podřetězec odečtením délky podřetězce s "trojicemi" od délka celého řetězce (proměnná C). A dáme před něj nezalomitelný prostor - (který později odstraníme). za co? Protože skupiny tří číslic byly čteny v opačném pořadí, musí být tento počáteční konec umístěn na konec řady. To znamená, že pokud bychom měli číslo, řekněme, 36748521, musíme seřadit 521 748 36, přičemž před každou skupinu vložíme pevnou mezeru, aby tam byl oddělovač pro pole (koneckonců, musíme převrátit je zpět, a to lze provést pomocí metody pole obráceně ()).

V poslední instrukci cyklu se uspořádáme do trojic a výsledek zapíšeme do proměnné b.

pro (i = intpart. délka-3; i> = 0; i- = 3) / * sbírat trojky * /(a = a + intpart. podstr(i, 3); / * najdi levý ocas * / c = " " + intpart. podstr(0, nedílná. délka-A. délka); / * umístěte oddělovače do trojic * / b = b + " " + intpart. podstr(i, 3);)

Při přidávání řetězců b + c získáme řetězec, který je třeba převést na pole, a poté toto pole obrátit a znovu jej převést na řetězec (toto vše je zapsáno do proměnné d).

D = (b + c). rozdělit(" " ).zvrátit().toString().nahradit(/, / g, " " );

Pole je převedeno na řetězec spolu s oddělovači čárek, nepotřebujeme je. Proto je ve stejné instrukci vymažeme pomocí regulární výraz /, / g, kde /,/ - vytvoření regulárního výrazu pro čárku a G- "vlajka", která ukazuje, že musíte nahradit všechny výrazové vzory (zjednodušeně řečeno - všechny čárky), které se nacházejí v řetězci. Nahradíme je stejnými nepřerušitelnými mezerami.

(Více o regulárních výrazech se budeme zabývat v poslední části tutoriálu.)

A teď musíme vyčistit něco jiného (uvnitř stejného podmíněného operátoru if (intpart.length> 3)).

Faktem je, že buď na začátku nebo na konci našeho řádku bude navíc nezalomitelná mezera, která se skládá ze 6 znaků: "&", "n", "b", "s", "p" a ";". Vyčistíme proto smetí a výsledek zapíšeme do proměnné E:

pokud (d. podřetězec(0 , 1 ) == "&" ) e = d. podřetězec(6, d. délka-6); jinak e = d. podřetězec(0, d. délka-6 );

Nyní můžeme s čistým svědomím uzavřít celý podmíněný operátor a napsat alternativu pro krátké číslo, které není potřeba dělit na „troje“.

) else e = intpart;

Takže proměnná E ukládá celočíselnou část čísla a my se budeme zabývat desetinnou čárkou.

Pozornost! Když pracujeme se zlomkovou částí (kterou je nyní potřeba pojmout jako celek), musíme si to pamatovat prec == 0 funkce bude "obtěžovat", takže okamžitě "vyplníme útržek":

if (prec! = 0) (

Nyní můžete v klidu pracovat. Je tu ale ještě pár „oblázků“, které nyní obejdeme.

Za prvé, pokud máme zlomkovou část, předpokládejme 41 , a nastavíme zaokrouhlování na 3 číslice, pak metodu na přesnost, vezmeme-li naši zlomkovou část jako celé číslo, bude výstupem 41.0 , to znamená, že musíte odstranit bod.

Za druhé, pokud se ukáže, že zlomková část původního čísla je více než 3 číslice, pak metoda na přesnost začne produkovat výsledek v exponenciální podobě. I s tím se bude muset bojovat.

Výsledek tedy „vyčistíme“ prostřednictvím tří proměnných: precpart, precpart1 a předdíl2.

Precpart = (Číslo (fractpart). na přesnost(předchozí)). toString(10 )

Nyní „čistíme“:

/ * pokud existuje zlomková část * / if (fractpart! = "") ( / * najít a odstranit tečku * / precpart1 = precpart. nahradit(".", "") / * zkontrolujte, zda je tam exponent, * / var plus = precpart1.lastIndexOf ("e"); / * a pokud existuje, * / if (plus> 0) / * vytáhnout s kořenem, * / precpart2 = precpart1. podřetězec(0, plus); /* v opačném případě */ jiný / * nic neměň * / precpart2 = precpart1) / * pokud není žádná zlomková část, * / jiný / * pak vytisknout nuly a znovu se zbavit té tečky * / precpart2 = "," + precpart. nahradit("." , "" )

Vzhledem k tomu, že jsme na začátku uvedli, že při absenci zlomkové části není v původním čísle žádná čárka, musíme ji v tomto případě zadat znovu.

) jinak ( / * to znamená, že pokud je prec stále nula, stačí vytisknout prázdné řádky * / precpart2 = "" ; dělič = "" ; }

A závěrečný akord:

Nr1 = e + dělič + předčást2; návrat nr1; )

Celá funkce:

funkce toRussianString (prec) (var a = "" , b = "" c, d, e; if (prec == 0) var str = this. na Opraveno(0 ).toString(10); else var str = toto. toString(10); var nr1; var intpart, fractpaft, precpart, dělič, tečka = str. lastIndexOf("." ); var i; pokud (tečka< 0 ) { intpart = str; fractpart = "" ; dělič = "" ;) else (intpart = str. podřetězec(0, tečka); fraktpart = str. podřetězec(tečka + 1, str. délka); dělič = "," ;) pokud (část. délka> 3) (pro (i = intpart. délka-3; i> = 0; i- = 3) (a = a + intpart. podstr(i, 3); c = " " + intpart. podstr(0, nedílná. délka-A. délka); b = b + " " + intpart. podstr(i, 3);) d = (b + c). rozdělit(" " ).zvrátit().toString().nahradit(/, / g, " " ); pokud (d. podřetězec(0 , 1 ) == "&" ) e = d. podřetězec(6, d. délka-6); jinak e = d. podřetězec(0, d. délka-6); ) else e = intpart; if (prec! = 0) (precpart = (Číslo (fractpart). na přesnost(předchozí)). toString(10) if (fractpart! = "") (Precpart1 = precpart. nahradit(."", "") var plus = precpart1.lastIndexOf ("e"); if (plus> 0) precpart2 = precpart1. podřetězec(0, plus); else precpart2 = precpart1) else precpart2 = "," + precpart. nahradit("." , "" )) else (precpart2 = "" ; dělič = "" ; ) nr1 = e + dělič + precpart2; návrat nr1; )

Nyní lze tuto funkci volat jako metodu.

Var myNumber = 2569843359,6583521 dokumentu. napsat(moje číslo. toRussianString(3 ))

Výsledek:

Konstruktor metody a funkce můžete vložit do knihovny – tedy do souboru .js, který můžete volat z kódu svých webových stránek. Při psaní metod pro různé objekty můžete metody třídit do souborů knihovny pro tyto objekty a používat další metody.

Tento článek se blíže podívá na čísla, matematické operátory, jak převést číslo na řetězec a naopak a také na mnoho dalších důležitých bodů.

Funkce IsFinite

Funkce isFinite vám umožňuje zkontrolovat, zda je argument konečný.

V odezvě tato funkce vrátí hodnotu false, pokud je argument Infinity, -Infinity, NaN nebo bude přetypován na jednu z těchto speciálních číselných hodnot. Jinak tato funkce vrátí hodnotu true.

IsFinite (73); // true isFinite (-1/0); // false isFinite (nekonečno); // false isFinite (NaN); // false isFinite ("Text"); // Nepravdivé

Kromě globální funkce isFinite má JavaScript také metodu Number.isFinite. Na rozdíl od isFinite nenutí argument k číslu.

IsFinite ("73"); // true Number.isFinite ("73"); // Nepravdivé

Funkce IsNaN

Funkce isNaN je navržena tak, aby určila, zda je argument číslem nebo zda jej lze na něj převést. Pokud ano, pak funkce isNaN vrátí hodnotu false. V opačném případě vrátí hodnotu true.

IsNaN (NaN); // true isNaN ("25px"); // pravda, protože 20px není číslo isNaN (25,5); // false isNaN ("25,5"); // false isNaN (""); // nepravda, protože mezera nebo několik mezer se převede na 0 isNaN (null); // nepravda, protože null se převede na 0 isNaN (true); // nepravda, protože true převede na 1 isNaN (false); // nepravda, protože false převede na 0

Pokud potřebujete provést tuto akci bez přetypování, použijte metodu Number.isNaN. Tato metoda byla zavedena do jazyka od ECMAScript 6.

Jak mohu explicitně převést řetězec na číslo?

Řetězec můžete explicitně převést na číslo pomocí následujících metod:

1. Použití unární + operátor umístit před hodnotu.

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

Tato metoda ignoruje úvodní a koncové mezery a \ n (odřádkování).

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

Při použití této metody je třeba věnovat pozornost skutečnosti, že prázdný řetězec nebo řetězec složený z mezer a \ n je přeložen na číslo 0. Kromě toho také převádí datový typ null a booleovské hodnoty na číslo .

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

2. Funkce parseInt. Tato funkce je určena ke konverzi argument na celé číslo... Na rozdíl od používání unární operátor +, tato metoda umožňuje převést řetězec na číslo, ve kterém ne všechny znaky jsou číselné... Začne převádět řetězec, počínaje prvním znakem. A jakmile narazí na nečíselný znak, tato funkce zastaví svou práci a vrátí výsledné číslo.

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

Tato funkce může pracovat s různými číselnými soustavami (dvojkové, osmičkové, desítkové, šestnáctkové). Radix je specifikován pomocí 2 argumentů.

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

Kromě funkce parseInt má JavaScript metodu Number.parseInt. Tato metoda se neliší od funkce parseInt a byla zavedena v JavaScriptu se specifikací ECMASCRIPT 2015 (6).

3. Funkce parseFloat. ParseFloat je podobný parseInt, kromě toho, že převádí argument na zlomek.

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

Navíc funkce parseFloat na rozdíl od parseInt nemá 2 argumenty, a proto se vždy snaží zacházet s řetězcem jako s desítkovým číslem.

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

Kromě funkce parseFloat má JavaScript metodu Number.parseFloat. Tato metoda se neliší od funkce parseFloat a byla zavedena v JavaScriptu se specifikací ECMASCRIPT 2015 (6).

Převést číslo na řetězec

Číslo můžete převést na řetězec pomocí metody toString.

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

Metoda toString také umožňuje specifikovat základ číselného systému, přičemž je třeba vzít v úvahu, že je nutné explicitně přetypovat číslo na řetězec:

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

Jak zkontrolovat, zda je proměnná číslo

Zda je hodnota proměnné číslo, můžete určit pomocí jedné z následujících metod:

1. Použití funkcí isNaN a isFinite:

// myVar je proměnná if (! isNaN (parseFloat (myVar)) && isFinite (parseFloat (myVar))) (// myVar je číslo nebo na něj lze přetypovat);

Jako funkce:

// funkce funkce isNumeric (value) (return! isNaN (parseFloat (value)) && isFinite (parseFloat (value));) // use var myVar = "12px"; console.log (isNumeric (myVar)); // skutečný

Tato metoda umožňuje určit, zda je zadaná hodnota číslem, nebo zda na něj lze převést. Tato volba nepovažuje prázdný řetězec, řetězec mezer, null, Infinity, -Infinity, true nebo false za číslo.

2. Pomocí operátoru typeof a isFinite funkce isNaN:

// funkce, která kontroluje, zda je hodnota číselná funkce isNumber (hodnota) (návratový typ hodnoty === "(! LANG: number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Tato funkce určuje, zda je zadaná hodnota typu Number a jedna ze speciálních hodnot Infinity, -Infinity a NaN. Pokud ano, pak tato funkce vrátí hodnotu true.

3. Použití metody ECMAScript 6 Number.isInteger (hodnota). Tato metoda umožňuje určit, zda je zadaná hodnota celé číslo.

Number.isInteger ("20"); // nepravda, protože tato metoda nepřevádí řetězec na číslo Number.isInteger (20); // pravda, protože daná hodnota je číslo

Sudá a lichá čísla

Pomocí následujících funkcí můžete zkontrolovat, zda je číslo sudé nebo liché:

// Funkce pro kontrolu čísla pro funkci sudosti isEven (n) (návrat n% 2 == 0;) // Funkce pro kontrolu čísla pro funkci lichosti isOdd (n) (návrat Math.abs (n% 2) == 1 ;)

Před provedením takové kontroly je však vhodné se ujistit, že zadaná hodnota je číslo:

hodnota = 20; if (Number.isInteger (hodnota)) (if (isEven (hodnota)) (console.log ("Číslo" + hodnota.toString () + "- sudé");))

Javascript prime

Uvažujme příklad, ve kterém zobrazíme prvočísla od 2 do 100 pomocí Javascriptu.

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

Zaokrouhlení čísla v Javascriptu

Existují různé způsoby, jak zaokrouhlit zlomkové číslo na celočíselnou hodnotu v JavaScriptu.

1. Pomocí speciálně navržených metod Math.floor, Math.ceil a Math.round. Metoda Math.floor zaokrouhlí zlomkové číslo dolů na nejbližší celé číslo, tzn. jednoduše zahodí zlomkovou část. Math.ceil zaokrouhlí zlomkové číslo nahoru na nejbližší celé číslo. Math.round zaokrouhlí číslo nahoru nebo dolů v závislosti na hodnotě zlomkové části. Pokud je zlomková část větší nebo rovna 0,5, pak nahoru, jinak je zvlnění dolů.

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

2. Pomocí metody toFixed (přesnost). Tato metoda zaokrouhlí zlomkovou část čísla na zadanou přesnost. Výsledek zaokrouhlení je vrácen jako řetězec.

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

Pokud není k dispozici dostatek desetinných míst k vytvoření zadané přesnosti čísla, doplní se nulami.

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

3. Prostřednictvím metody toPrecision. Tato metoda představuje číslo se zadanou přesností. Navíc umí zaokrouhlit nejen zlomek, ale i celou část čísla. Tato metoda může reprezentovat výsledné číslo v závislosti na výsledku s pevným bodem nebo v exponenciální formě.

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žití logických operátorů NOT nebo OR.

// přes dvojitou logickou negaci console.log (~~ 7.9); // 7 // pomocí logického OR s nulou: console.log (7.9 ^ 0); // 7

Celé číslo a zlomková část čísla

Celou část čísla můžete získat pomocí metody Math.floor () a parseInt ():

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

Zlomkovou část čísla můžete získat pomocí operátoru procent (%). Tento operátor vrátí zbytek, který se získá vydělením prvního čísla druhým. V tomto případě musí být 1 použito jako číslo 2.

Console.log (7,21 % 1); // 0,20999999999999996 // s přesností na 2 desetinná místa console.log ((7,21 % 1) .toFixed (2)); // "0,21"

Kromě toho lze zlomkovou část získat také pomocí výpočtů:

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

Je číslo ještě dělitelné

Pomocí operátoru procent můžete určit, zda je číslo dělitelné rovnoměrně:

Číslo var = 9; // pokud je zbytek po dělení čísla 3 0, tak ano, jinak ne if (číslo% 3 == 0) (console.log ("Číslo" + číslo + "je dělitelné 3");) else (console . log ("Číslo" + číslo + "není dělitelné 3");)

Formátování čísel

V JavaScriptu vám metoda toLocaleString () umožňuje formátovat výstup čísla tak, aby odpovídal regionálnímu nastavení jazyka (operačního systému).

Například zformátujme číslo podle regionálních standardů, které jsou standardně nainstalovány v systému:

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

Například zformátujme číslo v souladu s regionálními standardy Ruska (ru):

Console.log ((108.1) .toLocaleString ("ru-RU")); // "108,1"

Tuto metodu lze také použít k formátování čísla jako měny:

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

Zobrazení čísla v procentech:

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

Rozdělte číslo na číslice (vlastnost useGrouping):

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

Vytiskněte číslo s určitým počtem číslic (2) za desetinnou čárkou:

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

Porovnání čísel

JavaScript používá k porovnání čísel následující operátory: == (rovná se),! = (Nerovná se),> (větší než),< (меньше), >= (větší nebo rovno),<= (меньше или равно).

Porovnejme například dvě čísla:

Console.log (2> 3); // false console.log (5> = 3); // skutečný

Při porovnávání čísel se zlomkovými částmi je nutné vzít v úvahu chyby, které mohou při těchto výpočtech vzniknout.

Například v JavaScriptu součet čísel (0,2 + 0,4) není 0,6:

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

K chybám dochází, protože všechny výpočty provádí počítač nebo jiné elektronické zařízení v 2. číselné soustavě. Tito. před provedením jakékoli akce musí počítač nejprve převést čísla reprezentovaná ve výrazu na 2 číselnou soustavu. Ale žádné zlomkové desetinné číslo nemůže být reprezentováno ve 2 číselné soustavě přesně.

Například číslo 0,25 10 je převedeno přesně do dvojkové soustavy.

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

Například číslo 0,2 10 lze převést na systém 2 pouze s určitou přesností:

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 tyto chyby ovlivní výpočet součtu dvou čísel a výsledky porovnání. Tito. ukázalo se, že JavaScript ve skutečnosti uvidí tento záznam takto:

0.6000000000000001==0.6

Při výpočtu nebo zobrazení čísel se zlomkovou částí musíte vždy uvést přesnost, s jakou to musí být provedeno.

Například porovnávejte čísla až na 2 desetinná místa pomocí metod toFixed () a toPrecision ():

// metoda toFixed () console.log ((0.2 + 0.4) .toFixed (2) == (0.6) .toFixed (2)); // true // metoda toPrecision () console.log ((0.2 + 0.4) .toPrecision (2) == (0.6) .toPrecision (2)); // skutečný

Základní matematické operace

V JavaScriptu existují následující matematické operátory: + (sčítání), - (odčítání), * (násobení), / (dělení), % (modulo), ++ (zvýšení o 1), - (snížení o 1 ).

6 + 3 // 9 6-3 // 3 6 * 3 // 18 6/3 // 2 6 % 3 // 0, tzn. 6: 3 = 2 => 6-3 * 2 => zbytek (0) 5 % 2 // 1, tzn. 5: 2 = 2 (,5) => 5-2 * 2 => zbytek (1) 7,3 % 2 //1,3, tzn. 7,3: 2 = 3 (,65) => 7,3-2 * 3 => zbytek (1,3) // znaménko výsledku operace % se rovná znaménku první hodnoty -9% 2,5 //-1,5 , tj 9: 2,5 = 3 (,6) => 9-2,5 * 3 => zbytek (1,5) -9 % -2,5 //-1,5, tzn. 9: 2,5 = 3 (,6) => 9-2,5 * 3 => zbytek (1,5) -2 % 5 // - 2, tzn. 2: 5 = 0 (.4) => 2-5 * 0 => zbytek (2) x = 3; console.log (x ++); // vypíše 3, y nastaví 4 později console.log (x); // 4 x = 3; console.log (++ x); // nastaví 4 a vypíše x = 5; console.log (x--); // vypíše 5, y nastaví 4 později console.log (x); // 4 x = 5; console.log (- x); // nastaví 4 a výstupy Kromě toho má JavaScript kombinované operátory: x + = y (x = x + y), x- = y (x = xy), x * = y (x = x * y), x / = y (x = x / y), x % = y (x = x % y). x = 3; y = 6; x + = y; console.log (x); // 9 x = 3; y = 6; x- = y; console.log (x); // - 3 x = 3; y = 6; x * = y; console.log (x); // 18 x = 3; y = 6; x/ = y; console.log (x); //0,5 x = 3; y = 6; x % = y; console.log (x); // 3