Vyznáte se v aritmetice? Umíte čísla sčítat a odečítat? JavaScript umí také sčítat a odečítat. JavaScript má tyto operátory: sčítání +, odčítání -, dělení /, násobení *, dělení se zbytkem %.
Var jedna = 121;
var dva = 13;
výstraha (jedna + dvě);
výstraha (jedna - dvě);
výstraha (jedna * dvě);
výstraha (jedna / dvě);
výstraha (jedna % dvě);
Zkomplikujeme příklad 1
Var odpověď = ((121 - 12) * 103) + 200;
upozornit(odpověď);
Zkomplikujeme příklad 2
VarPI = 3,14;
upozornit(odpověď);
A zkomplikujme třetí příklad
VarPI = 3,14;
var odpověď = ((121 - 12) * 103) + PI;
var answerEnd = (2 * odpověď * PI) + (-100);
upozornit(odpověďKonec);
A i tohle se dá udělat
Var odpověď = 101 + (-(-100));
upozornit(odpověď);
To je ale nesmysl oproti tomu, co umí JavaScript. Pro tento účel existuje standardní objekt Math s mnoha vlastnostmi (vlastnosti jsou v tomto kontextu operace).
Math.pow(2, 53) /* -> 2 na mocninu 53 */
Math.round(0.6) /* -> 1.0 - zaokrouhleno na nejbližší celé číslo */
Math.ceil(0.6) /* -> 1.0 - zaokrouhleno nahoru */
Math.floor(0,6) /* -> 0,0 - zaokrouhleno dolů */
Math.abs(-5) /* -> 5 - modul, absolutní hodnota */
Math.max(x, y, z) /* -> Vrátí největší argument */
Math.min(x, y, z) /* -> Vrátí nejmenší argument */
Math.random(); /* -> Kde výstupní číslo je větší než 0, ale menší než 1 */
Math.PI /* -> Pi */
Math.E /* -> Báze přirozeného logaritmu */
Math.sqrt(3) /* -> Druhá odmocnina ze 3 */
Math.pow(3, 1/3) /* -> Odmocnina ze 3 */
Math.sin(0) /* -> Trigonometrie: existují také Math.cos, Math.atan a další */
Math.log(10) /* -> Přirozený logaritmus 10 */
Math.log(100) / Math.LN10 /* -> Logaritmus 100 základ 10 */
Math.log(512) / Math.LN2 /* -> Logaritmus 512 základ 2 */
Math.exp(3) /* -> Math.E cubed */
Jak používat objekt Math?
/* První příklad */
var twoInPow = Math.pow(2, 53);
alert(twoInPow);
/* Druhý příklad */
var valueRaund = 0,1312;
var answerRaunt = Math.round(valueRaund);
alert(odpověďRaunt);
/* Třetí příklad */
var valueRaund = 0,1312;
alert(Math.round(valueRaund));
/* Čtvrtý příklad: nalezení největšího ze tří čísel */
var a = 12, b = 11, c = 10;
alert(Math.max(a, b, c));
V případě mimo rozsah, ztráty platných číslic nebo dělení nulou JavaScript nevyhodí chybu. Pokud je výsledek příliš velký a mimo rozsah, bude vrácena speciální hodnota „nekonečno“, vypadá takto „nekonečno“.
Ztráta platných číslic: Výsledek aritmetické operace je velmi blízký nule. Pokud došlo ke ztrátě, vrátí se 0 (nula).
Globální proměnná NaN znamená „ne číslo“. Tato proměnná má jednu zvláštnost: operace testu rovnosti (==) vždy vrátí negativní výsledek, i když je porovnána sama se sebou.
/* Takhle nemůžeš psát */
if (x == NaN) ( ... )
Chcete-li určit, zda je hodnota proměnné x hodnotou NaN, musíte použít níže uvedenou konstrukci. Tato kontrola se vyhodnotí jako true pouze tehdy, když se x rovná NaN
Aritmetické operátory a přetypování
JavaScript podporuje následující aritmetické operátory:
Zajímavou funkcí JavaScriptu je schopnost provádět aritmetické operace s proměnnými různé typy. V tomto případě interpret provede přetypování sám a provede zadanou operaci. V procesu údržby typu se používají následující pravidla:
1. Je-li jeden z operandů řetězec, pak jsou všechny ostatní operandy převedeny na řetězec.
Var1 = "Strýček" var2 = "Vanya" výsledek = var1 + " " + var2 // výsledek = "Strýček Vanya" smíšený = var2 + 100 // smíšený = "Vanya100"
2. Všechny logické operandy jsou převedeny na číselnou formu, kromě případů, kdy jsou všechny operandy ve výrazu logické. V tomto případě je pravda snížena na "1" a nepravda - na "0". Při kombinování logických operandů s řetězci jsou všechny operandy převedeny do textové podoby.
Var1 = true var2 = true result = var1 + var2 // result = 2 mixed = var2 + 100 // mixed = 101 var3 = "string:" str = var3 + var1 // str = "string:true"
3. Pokud přetypování selže, výsledkem výrazu bude „NaN“ (například při pokusu o rozdělení řetězce na něco).
Var1 = "Strýček" var2 = "Vanya" výsledek = var1 / var2 // výsledek = "NaN" smíšené = var2 * pravda // smíšené = "NaN"
V počáteční fázi je však lepší zdržet se odlévání typů a triků s transformujícími výsledky. To vám ušetří značné množství chyb.
Matematický objekt
Objekt Math obsahuje základní matematické konstanty a standard matematické funkce. Ty nejpoužívanější jsou uvedeny v tabulce:
| Vlastnosti | |
| LN10 | Hodnota přirozeného logaritmu čísla 10 |
| LN2 | Hodnota přirozeného logaritmu čísla 2 |
| P.I. | Hodnota pí |
| Metody | |
| abs(číslo) | Vrátí absolutní hodnotu čísla (tj. číslo bez zohlednění jeho znaménka) |
| strop (číslo) | Zaokrouhlí číslo na nejbližší vyšší celé číslo (zaokrouhlí nahoru) |
| exp(číslo) | Vrátí číslo "e" na mocninu "čísla" |
| patro (číslo) | Zaokrouhlí číslo na nejbližší nižší celé číslo (zaokrouhlí dolů) |
| max(číslo1, číslo2) | Vrátí větší ze dvou čísel |
| min(číslo1, číslo2) | Vrátí menší ze dvou čísel |
| pow(číslo1, číslo2) | Vrátí "číslo1" umocněné na "číslo2" |
| náhodný() | Vrátí náhodné číslo v rozsahu od 0 do 1 |
| kolo (číslo) | Zaokrouhlí číslo podle standardních pravidel zaokrouhlování |
| sqrt(číslo) | Vrátí druhou odmocninu čísla. |
Ze všech uvedených funkcí má smysl dále vysvětlovat pouze ceil(), floor() a round(). Podívejme se na jejich rozdíly na příkladu:
Num = 1,222 // nejbližší celé číslo "dolů" je 1 // nejbližší celé číslo "nahoru" je 2 // aritmeticky zaokrouhleno na 1 alert(Math.ceil(num)) alert(Math.floor(num)) alert(Math.round (num)) // dostaneme tři zprávy: 2, 1, 1 num = 1,777 // nejbližší celé číslo "dolů" je 1 // nejbližší celé číslo "nahoru" je 2 // aritmeticky zaokrouhleno na 2 alert(Math.ceil (num) ) alert(Math.floor(num)) alert(Math.round(num)) // dostáváme tři zprávy: 2, 1, 2
Matematická sada Funkce JavaScriptu umožňuje vyřešit poměrně širokou škálu problémů, ale neměli byste to zneužívat. Nezapomeňte, že kód je spouštěn interpretem, ale o nízkoúrovňové optimalizaci výpočtů nemůže být řeč, proto vysoký výkon bude velmi obtížné dosáhnout.
Operátory: - (odčítání), + (sčítání), * (násobení) a / (dělení) fungují úplně stejně jako aritmetické operace v matematice. Operátor % ( rozdělení se zbytkem) vrátí zbytek, když je první operand dělen druhým. Výsledek dělení se zbytkem bude mít stejné znaménko jako první operand:
Upozornění(10 + 2); // 12 alert(10 - 2); // 8 alert(10 * 2); // 20 alert(10 / 2); // 5 alert(5 % 2); // 1 upozornění(-5 % 2); // -1
Operátor ** ( umocňování) má dva operandy. První operand je základ mocniny, druhý operand je exponent, takže operátor vrátí základ umocněný na zadanou mocninu:
2 ** 4; // 16
Všechny matematické operátory převádějí své operandy pomocí stejných pravidel jako funkce Number().
Unární + (plus) a - (mínus)
Operátor + (unární plus) převede hodnotu svého operandu na číslo a vrátí převedenou hodnotu. Při použití s číselným operandem nedělá nic:
Var x = +"5";
Operátor - (unární minus) v případě potřeby převede hodnotu svého operandu na číslo a poté číslo učiní záporným:
Var x = -5 + 3;
Unární plus a mínus převádějí své operandy pomocí stejných pravidel jako funkce Number().
Zvyšování a snižování
Operátor ++ (přírůstek) zvýší hodnotu svého operandu o jednu. Pokud hodnota operandu není číslo, operátor ji automaticky převede na číslo, zvýší ji o jedničku a vrátí výsledek, který je přiřazen zpět k operandu.
Přírůstek má dvě formy - postfix (operátor je umístěn za operandem) a prefix (operand je umístěn před operandem). Pokud je použit ve formě postfixu, je vrácen jako první původní hodnota operand a teprve potom se hodnota operandu zvýší o jedničku.
Výpočty v JavaScriptu velmi často nedávají přesně takové výsledky, jaké bychom chtěli. S čísly si samozřejmě můžeme dělat, co chceme – 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 zajímavých aspektů JavaScriptu je, že ve skutečnosti neukládá celá čísla, pracujeme rovnou s čísly s plovoucí desetinnou čárkou. To v kombinaci se skutečností, že mnoho zlomkových hodnot nelze vyjádřit v konečném počtu 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 nevadí, v našem případě se bavíme o chybě v kvintilionu dílů, nicméně to může někoho zklamat. Poněkud podivné výsledky můžeme získat také při práci s čísly, která představují měny, procenta nebo velikosti souborů. Abychom tyto nepřesnosti opravili, potřebujeme umět výsledky zaokrouhlit a stačí nastavit desetinnou přesnost.
Zaokrouhlování čísel má praktické využití, můžeme manipulovat s číslem v určitém rozsahu, například chceme zaokrouhlit hodnotu na nejbližší celé číslo a nepracovat pouze s desetinnou částí.
Zaokrouhlování desetinných čísel
Abychom odřízli 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:- Pokud argument není pro toFixed() definován, bude implicitně nula, což znamená, že argument má 0 desetinných míst maximální hodnota, rovno 20.
- Pokud parametru toPrecision není zadán žádný argument, číslo zůstane nedotčeno
Metody toFixed() i toPrecision() vracejí řetězcovou reprezentaci výsledku, nikoli číslo. To znamená, že při sečtení zaokrouhlené hodnoty s randNum vznikne zřetězení řetězců spíše než součet čísel:
Nechť randNum = 6,25; let rounded = randNum.toFixed(); // "6" console.log(randNum + rounded); > "6,256"
Pokud chcete, aby výsledkem byl číselný datový typ, budete muset použít parseFloat:
Nechť randNum = 6,25; let rounded = parseFloat(randNum.toFixed(1)); console.log(zaoblene); > 6.3
Vezměte prosím na vědomí, že hodnoty 5 jsou zaokrouhleny kromě vzácných případů.
Metody toFixed() a toPrecision() jsou užitečné, protože mohou nejen oříznout zlomkovou část, ale také přidat desetinná místa, což je praktické při práci s měnou:
Nechť celéNum = 1 nechť dolaryCenty = celéNum.toFixed(2); console.log(dollarsCents); > "1,00"
Všimněte si, že toPrecision vytvoří výsledek ve vědecké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í s desetinnými místy
V některých případech toFixed a toPrecision zaokrouhlí hodnotu 5 dolů a nahoru:Nechť numTest = 1,005; numTest.toFixed(2); > "1,00"
Výsledek výše uvedeného výpočtu měl být 1,01, nikoli 1. Pokud se chcete podobné chybě vyhnout, můžeme použít řešení navržené Jackem L Moorem, které pro výpočet používá exponenciální čísla:
Funkce round(hodnota, desetinná místa) ( return Number(Math.round(hodnota+"e"+desetinná)+"e-"+desetinná); )
Nyní:
kolo(1,005,2); > 1.01
Pokud chcete robustnější řešení než to uvedené výše, můžete přejít 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 míru chyb 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
V naší funkci používáme Math.EPSILON, abychom získali platné srovnání:
Funkce epsEqu(x, y) ( return 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) > pravda
Všechny moderní prohlížeče již podporují matematické funkce ES6, ale pokud chcete podporu v prohlížečích jako IE 11, použijte polyfills.
Oříznutí zlomkové části
Všechny výše uvedené metody lze zaokrouhlit na desetinná čísla. Chcete-li jednoduše snížit číslo na dvě desetinná místa, musíte je nejprve vynásobit 100 a poté vydělit výsledný výsledek 100:Funkce truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3.1416) > 3.14
Pokud chcete metodu přizpůsobit libovolnému počtu desetinných míst, můžete použít bitovou dvojitou negaci:
Funkce zkrácena (num, desetinná místa) ( nechť numPowerConverter = Math.pow(10, desetinná místa); return ~~(num * numPowerConverter)/numPowerConverter; )
Nyní:
Nechť randInt = 35,874993; truncated(randInt,3); > 35,874
Zaokrouhlete na nejbližší číslo
Chcete-li zaokrouhlit desetinné číslo na nejbližší číslo nahoru nebo dolů, podle toho, kterému jsme nejblíže, použijte Math.round():Mat.kolo(4.3) > 4 Mat.kolo(4.5) > 5
Vezměte prosím na vědomí, že „poloviční hodnota“, 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 Mate.podla(36,93); > 36
Upozorňujeme, že zaokrouhlení dolů funguje pro všechna čísla, včetně záporných čísel. Představte si mrakodrap s nekonečným počtem pater, včetně pater na spodní úrovni (představující záporná čísla). Pokud jste ve výtahu na nejnižší úrovni mezi 2 a 3 (což představuje hodnotu -2,5), Math.floor vás přenese 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í prohlížeče(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 pamatujte nekonečný výtah: Math.ceil vždy půjde „nahoru“, 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ů na požadované číslo
Pokud chceme zaokrouhlit na nejbližší násobek 5, nejjednodušší je vytvořit funkci, která číslo vydělí 5, zaokrouhlí a poté vynásobí stejnou hodnotou:Funkce roundTo5(num) ( return Math.round(num/5)*5; )
Nyní:
RoundTo5(11); > 10
Pokud chcete zaokrouhlit na násobky vaší hodnoty, použijeme obecnější funkci, předáme počáteční hodnotu a násobek:
Funkce roundToMultiple(počet, násobek) ( return Math.round(num/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 hodnotu x, která leží v rozsahu. Například bychom mohli potřebovat hodnotu mezi 1 a 100, ale skončili jsme s hodnotou 123. Abychom to napravili, můžeme použít min (vrátí nejmenší ze sady čísel) a max (vrátí největší ze sady čísel čí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(dolní hranice, Math.min(numInput, highBound)); console.log(upnutý); > 100;
Opět můžeme operaci znovu použít a celou věc zabalit do funkce pomocí řešení navrženého Danielem X. Mooreem:
Number.prototype.clamp = function(min, max) ( return Math.min(Math.max(this, min), max); );
Nyní:
NumInput.clamp(lowBound, highBound); > 100;
Gaussovo zaokrouhlení
Gaussovské zaokrouhlování, známé také jako bankéřské zaokrouhlování, zahrnuje zaokrouhlování na nejbližší sudé číslo. Tato metoda zaokrouhlování funguje bez statistické chyby. Nejlepší rozhodnutí navrhl Tim Down:Funkce gaussRound(číslo, desetinná místa) ( nechť 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é v CSS:
Vzhledem k tomu, že JavaScript se často používá k vytváření pozičních mapování pro prvky HTML, možná vás zajímá, co by se stalo, kdybychom pro naše prvky vygenerovali desetinné hodnoty:
#box ( šířka: 63,667731993px; )
Dobrou zprávou je, že moderní prohlížeče budou respektovat desetinné hodnoty v blokovém modelu, včetně jednotek procent nebo 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 hráčské hodnosti. Standardní metoda sort() má bohužel některá překvapivá omezení: funguje dobře s běžnými anglickými slovy, ale okamžitě se porouchá, když narazí na čísla, jedinečné znaky nebo velká písmena.Řazení podle abecedy
Zdá se, že řazení pole podle abecedy by mělo být jednoduchým úkolem:Nechte ovoce = ["butternut squash", "meruňka", "cantaloupe"]; ovoce.sort(); > "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.sort(); > "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 na tabulku kódů, znak „a“ má hodnotu U+0061 (v hexadecimální soustavě 0x61), zatímco znak „C“ má kód U+0043 (0x43), který je v Unicode dříve uveden. tabulka než znak "a".
Chcete-li seřadit pole, které může obsahovat smíšená první písmena velkých a malých písmen, musíme buď dočasně převést všechny prvky na malá písmena, nebo definovat naše 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) ( return a.localeCompare(b, "en", ("citlivost": "základ")); )); ) nechť ovoce = ["máslová dýně ", "meruňka", "cantaloupe"]; alphaSort(ovoce) >
Pokud chcete pole seřadit v obráceném abecedním pořadí, jednoduše prohoďte pozice a a b ve funkci:
Funkce alphaSort(arr) ( arr.sort(funkce (a, b) ( return 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íme také pamatovat na to, že je podporováno 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) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) nechť ovoce = ["máslová dýně", "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 poli 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(); >
Jde o to, že metoda sort() provádí lexikografické srovnání: což znamená, že čísla budou převedena na řetězec a porovnání budou opět provedena shodou prvního znaku tohoto řetězce v pořadí znaků v tabulce Unicode. . Proto musíme znovu definovat naše pořadí řazení:
Nechat highScores = ; highScores.sort(funkce(a,b) ( return a - b; )); >
Opět platí, že chcete-li seřadit čísla v opačném pořadí, prohoďte pozice aab ve funkci.
Řazení struktury podobné JSON
A konečně, pokud máme datovou strukturu podobnou JSON reprezentovanou jako pole herních záznamů:Let score = [ ( "name": "Daniel", "score": 21768 ), ( "name": "Michael", "score": 33579 ), ( "name": "Alison", "score": 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(function(a, b) ( return a.score - b.score ));
Jak vidíte, řazení v JavaScriptu je poměrně obskurní záležitost, 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 opakovaného násobení přirozeného čísla sebou samým; druhá odmocnina z a je číslo, které dává a při druhé mocnině. Tyto funkce bychom mohli používat neustále Každodenní život v hodinách matematiky, včetně počítání ploch, objemů nebo dokonce fyzikálního modelování.V JavaScriptu je funkce napájení reprezentována jako Math.pow() a v novém standardu ES7 byl zaveden nový operátor umocňování - " * * ".
Umocňování
Chcete-li zvýšit číslo na n-tou mocninu, použijte funkci Math.pow(), kde první argument je číslo, které bude 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. Lze samozřejmě uvést jiný příklad:
Math.pow(5,3); > 125
To znamená, že 5 krychlových nebo 5 × 5 × 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
Na tento moment Podpora tohoto operátora je značně omezená, proto se jeho použití nedoporučuje.
Funkce napájení může být užitečná ve většině různé situace. Jednoduchý příklad výpočtu počtu sekund za hodinu: Math.pow (60,2).
Čtvercové a krychlové kořeny
Math.sqrt() a Math.cbrt() jsou opakem Math.pow(). Jak si pamatujeme, druhá odmocnina z a je číslo, které dává a, když je na druhou.Math.sqrt(9) > 3
Zároveň je třetí odmocninou a číslo, které dává a, když je zvýšeno na krychli.
Math.cbrt(125) > 5
Math.cbrt() byl do specifikace JavaScriptu zaveden teprve nedávno, a je tedy podporován pouze v moderních prohlížečích: Chrome 38+, Firefox a Opera 25+ a Safari 7.1+. Toho si všimnete internet Explorer není na tomto seznamu, ale na MDN najdete polyfill.
Příklady
Samozřejmě můžeme použít neceločíselné hodnoty v jedné z těchto funkcí:Math.pow(1,25; 2); > 1,5625 Math.cbrt(56,57) > 3,8387991760286138
Vezměte prosím na vědomí, že to také funguje docela dobře při použití hodnot záporných argumentů:
Math.pow(-5,2) > 25 Math.pow(10,-2) > 0,01
To však nebude fungovat pro druhou odmocninu:
Math.sqrt(-9) > NaN
Z matematické analýzy víme, že imaginární číslo odkazuje na odmocniny záporných čísel. A to nás může přivést k další technice pro práci s komplexními čísly, ale to je jiný příběh.
V Math.pow() můžete použít zlomky k nalezení druhé a třetí odmocniny čísel. 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 k odříznutí znamének od čísla nebo zaokrouhlení na nějakou hodnotu.
Někteří lidé si z neznámých důvodů v JavaScriptu pletou funkci Math.pow() s Math.exp() , což je exponenciální funkce pro čísla obecně. Poznámka: v anglický jazyk„exponent“ se překládá jako „exponent“, takže to platí spíše pro anglicky mluvící, i když 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.Průzkumu se mohou zúčastnit pouze registrovaní uživatelé. , Prosím.
Štítky: Přidat štítkyPřipomínám, že toto úvodní kurz JavaScriptu pro začátečníky. Dnes se podíváme na co operátory existovat v JavaScriptu. Zapněte si bezpečnostní pásy! Bude hodně bukafu.
Když máte hromadu dat, musíte s nimi něco udělat. Operátoři mají plné ruce práce. Pořád sčítají, násobí, rozdělují, odečítají, porovnávají, přivlastňují a cokoli sakra dělají. Bez operátorů v programování prostě nemůžete vařit kaši.
V JavaScriptu se používají následující typy operátorů:
- Aritmetické operátory
- Operátoři přiřazení
- Porovnávací operátory
- Logické operátory
- Řetězcové operátory
- Podmíněné výroky
To je daleko od toho úplný seznam, ale pro začátek to pro oči stačí. Podívejme se na jednotlivé typy prezentovaných operátorů, proč jsou potřeba a k čemu se používají. Jít!
Aritmetické operátory v JavaScriptu
Aritmetické operátory všichni znáte už od školy. Jsou to obvyklá znaménka sčítání, odčítání, dělení a násobení: + , - , / , * . Podle toho plní v programování stejné funkce jako v běžné matematice. S tím nebudete mít žádné potíže.
Data, se kterými operátoři pracují, se nazývají operandy.
2 + 3 // zde jsou čísla 2 a 3 operandy a znaménko + je operátor sčítání
Stejně jako v matematice mají aritmetické operátory své vlastní priority: násobení a dělení mají vyšší prioritu než sčítání a odčítání.
2 + 3 * 4 // se zde nejprve provede násobení a teprve potom sčítání
A stejně jako v matematice se závorky aktivně používají ke změně priority:
(2 + 3) * 4 // zde se nejprve provede sčítání a poté násobení
Mimochodem, znak = je také operátor. Jak jsme již zjistili v článku o , jedná se o operátor přiřazení a vůbec ne o rovnítko. Nezapomeňte na to!
Operátor divize Modulo
Nyní se podíváme na zajímavější aritmetické operátory. A první ikonou bude ikona procent - %. V JavaScriptu to vůbec nejsou procenta slova. Tak se v programování označuje modulo dělení. Výsledkem takové operace bude zbytek divize. Například:
100 % 22 // zbytek bude 12
100 % 10 // zbytek bude 0
Ve výpočtech má tento operátor stejnou prioritu jako násobení a dělení, takže nezapomeňte dát závorky.
Kombinace operátorů
Operátor = může a měl by být kombinován s jinými operátory, aby se zkrátil zápis. Příklad:
var n = 2; // přiřadit proměnné n hodnotu 2
n = n + 3; // přiřadit proměnné n novou hodnotu n + 2, získat 5
Totéž lze napsat takto:
var n = 2;
n+= 3; // ekvivalentní zápisu n = n + 3
Inkrementovat operátory ++ a dekrementovat – –
Mezi aritmetickými operátory je několik velmi zajímavých - přírůstek A dekrementovat. Jsou označeny ++ a ––. První zvyšuje proměnnou o jednu a druhý ji snižuje. Tato funkce se velmi často používá při programování, protože poskytuje spoustu pohodlí. Nejčastěji jej lze nalézt v podmíněných výrazech, ale o tom později.
Oba operátoři mají v záznamu konkrétní umístění. Mohou být jako předpona tvar (před proměnnou) ++n a in postfix(za proměnnou) n++ . Rozdíl je obrovský! Nikdy si tyto tvary nezaměňujte a dobře si je zapamatujte. Pokud se tyto operátory objeví před proměnnou, pak ve výsledku zvýší její hodnotu o 1. Ale! Pokud následují za proměnnou, vrátí původní hodnotu. Příklad:
var n = 2, m = 0;
m = ++n // zvýší n o 1 (n = 3) a přiřadí m stejnou hodnotu jako 3
var n = 2, m = 3;
m = n++ // zvýší n o 1 (n = 3), ale nastaví m na předchozí hodnotu n = 2
Jsem si jistý, že první příklad snadno pochopíte. S tím druhým ale mohou nastat problémy. Pro snazší pochopení této věci a nenechte se zmást si představte, že jste nejprve přiřadili hodnotu proměnné n proměnné m a teprve poté hodnotu n zvýšili o jedna. V prvním příkladu jste nejprve zvýšili hodnotu n o jednu a pak tuto hodnotu přiřadili proměnné m.
To je pro aritmetické operátory vše. Samozřejmě stále existuje mnoho variací a jemností používání těchto jednoduchých operátorů, ale pro začátek vám to bude více než dost.
Porovnávací operátory
A opět si připomeneme matematiku. Známky zná každý. V programování se jim říká srovnávací operátory. JavaScript používá následující operátory porovnání:
< меньше
> více
<= меньше или равно
>= větší nebo rovno
== rovný
!= nerovná se
=== přísně rovné
!== striktně se nerovná
Vezměte prosím na vědomí, že znaménko „větší než nebo rovno“ se píše přesně takto >= , nikoli => . To znamená, že šipka je umístěna před rovnítkem, nikoli za ním.
Porovnávací operátory umožňují porovnávat hodnoty proměnných a výsledkem této operace je vždy booleovská hodnota true nebo false. Obvykle se používají v podmíněných výrazech. Výsledek porovnání určuje, která část kódu bude provedena jako další.
V JavaScriptu můžete porovnávat odlišné typy data současně, například číslo a řetězec:
12345 == "12345" // pravda
Jde jen o to, že v tomto případě se řetězec automaticky převede na číslo. Přísná rovnost === nebo nerovnost!== se používají pouze při porovnávání proměnných stejného typu.
Logické operátory
Logické operace v JavaScriptu jsou pro začátečníky jedním z poměrně ošemetných témat. Stojí za to mu důkladně porozumět, abyste se úspěšně posunuli vpřed ve zvládnutí jazyka. Nejčastěji se používají ve spojení s operátory porovnání a vytvářejí booleovskou hodnotu true nebo false .
Existují tři logické operátory:
&& (A)
|| (NEBO)
! (NE)
Logický operátor && (AND)
Operátor && provede logickou operaci AND na dvou hodnotách. Vrátí však hodnotu true tehdy a pouze tehdy, když se oba operandy vyhodnotí jako true . Pokud jsou jeden nebo oba operandy nepravdivé, operátor vrátí false. Příklady:
2 < 3 && 4 < 5 // true
2 < 3 && 5 < 4 // false
3 < 2 && 5 < 4 // false
Logické operátory mají nižší prioritu než operátory porovnání, takže v uvedených příkladech se obejdeme bez závorek. Je jasné, že nejprve porovnáme čísla mezi sebou a teprve potom aplikujeme logiku.
Logický operátor || (NEBO)
S logickým operátorem || (NEBO) další píseň. Provozovatel || provede logickou operaci OR na dvou operandech. Pokud jeden nebo oba operandy mají pravý význam, vrátí true. Pokud jsou oba operandy nepravdivé, vrátí hodnotu false. Příklady:
2 < 3 || 4 < 5 // true
2 < 3 || 5 < 4 // true
3 < 2 || 5 < 4 // false
Logické operátory mají trik. Nemají rádi práci navíc. Mimochodem, stejně jako já. Své výpočty vždy začínají zleva doprava. A pokud první část výrazu odpovídá jejich podmínkám, pak ani nevyhodnocují zbytek výrazu.
Pokud například operátor || najde skutečnou hodnotu hned na začátku, okamžitě uvede skutečnou hodnotu a zbytek nekontroluje. Také operátor &&, pokud najde nepravdivý výraz na samém začátku, okamžitě dává falešný výsledek a nekontroluje zbytek výrazu.
A ještě jeden trik: priorita operátoru AND && je větší než priorita OR || takže se to provede dříve:
2 < 3 || 4 < 5 && 5 < 6 // здесь сначала будет выполнено вычисление в правой части, а потом уже в левой
Logický operátor! (NE)
Logický operátor! znamená „logické NE“. Používá se pouze s jedním operandem a obrátí hodnotu tohoto operandu. Pokud je n pravda, pak!n bude nepravda. Protože tento operátor může být připojen pouze k jednomu operandu, pro invertování celého výrazu musí být umístěn v závorkách!(n && m) .
Řetězcové operátory
O řetězcových operátorech jsme již hovořili dříve. Toto je stejné plus +, které se používá pro připojení řetězcových proměnných, nebo jinak - pro zřetězení(přidání strun). Příklad:
"Igor" + "Quentor" == "Igor Quentor"
Všimněte si, že první slovo má před koncovou uvozovkou mezeru. Pokud jej nepřidáte, řádky se spojí do jednoho slova „IgorQuentor“.
Tento operátor má jednu vlastnost: pokud výraz obsahuje alespoň jeden řetězec, pak se tento a všechny ostatní argumenty převedou na typ řetězce. Například:
Zbývající aritmetické operátory pracují pouze s čísly a vždy redukují své argumenty na číslo.
Podmíněné výroky
V JavaScriptu existují dva podmíněné operátory if a?: I když, abychom byli přesní, if je ve skutečnosti řídicí instrukce a je poměrně obsáhlá, s hromadou vychytávek a zajímavých funkcí. Proto o tom bude samostatný článek. Podívejme se nyní na jednodušší podmíněný operátor?:
Obvykle se tento operátor zapisuje jako?: Ale v programech to vypadá jinak. Má tři operandy. Předchází první operand znak? , ten druhý je mezi postavami? a: třetí - po:
stav? hodnota 1: hodnota 2
Význam jeho operace je jednoduchý: pokud je nastavená podmínka splněna, pak je vrácena hodnota 1, ale pokud ne, hodnota 2. Tento podmíněný operátor často slouží jako jednodušší náhrada za příkaz if, když druhý není nijak zvlášť nutné. Zároveň je samotný záznam zkrácen a lépe čitelný.
To je prozatím vše!
Doufám, že nyní trochu rozumíte operátorům v JavaScriptu. A aby se váš mozek nevařil, zde je pro vás krátký kreslený film na odpočinek – Programátor dokáže všechno! :)