Math

Pokud potřebujete provádět složitější matematické operace, než jsme již diskutovali, jako je základní sčítání, odčítání, násobení a tak dále, brzy oceníte vestavěný objekt Math. Obsahuje spoustu metod pro provádění složitějších matematických úkonů, stejně jako některé užitečné vlastnosti.

Na rozdíl od několika dalších vestavěných objektů, o kterých jsme již v této kapitole diskutovali, objekt Math obsahuje pouze statické členy. Jinými slovy, nemůžete jen tak volat metody Math na například Number (objekt). Místo toho musíte odkazovat na vlastnosti a metody na objektu Math, přičemž předáváte čísla, se kterými chcete pracovat. To také znamená, že nemůžete vytvořit nový objekt Math nebo ho volat jako funkci, jak jsme viděli u některých dalších vestavěných objektů.

Podívejme se, jaké užitečné vlastnosti a metody můžeme od objektu Math očekávat.

Vlastnosti Math

Objekt Math obsahuje několik vlastností, které jsou užitečné pro různé aspekty pokročilých matematických operací. Protože se přímo týkají skutečné matematiky a nejsou tedy specifické pro JavaScript, nebudu vám ukazovat příklady všech z nich. Místo toho zde je rychlý seznam s odkazy na jejich referenci, pro případ, že byste se chtěli do nich ponořit hlouběji:

• Math.E - Eulerovo číslo (základ přirozeného logaritmu)
• Math.LN10 - přirozený logaritmus čísla 10 - přibližně 2.302
• Math.LN2 - přirozený logaritmus čísla 2 - přibližně 0.693
• Math.LOG10E - logaritmus o základu 10 z e - přibližně 0.434
• Math.LOG2E - logaritmus o základu 2 z e - přibližně 1.442.
• Math.PI - přibližně 3,14159, což představuje poměr obvodu kruhu k jeho průměru.
• Math.SQRT1_2 - druhá odmocnina z 1/2 (přibližně 0.707)
• Math.SQRT2 - druhá odmocnina ze 2 (přibližně 1.414)

S tím na místě, pojďme si promluvit o metodách objektu Math.

Metody Math

Objekt Math obsahuje řadu užitečných statických metod, ale jak bylo zmíněno, v současné době neobsahuje žádné instanční metody.

Některé statické metody nalezené v objektu Math přímo souvisí s matematickými funkcemi, jako jsou Math.cos() a Math.sin() (kosinus a sinus) - tyto metody přeskočím, protože se v zásadě týkají spíše matematiky než JavaScriptu. Pro úplný seznam metod nalezených v objektu Math se prosím podívejte na tento odkaz.

S tím na paměti je zde seznam nejrelevantnějších a nejzajímavějších metod nalezených v objektu Math.

Math.ceil()

Metoda ceil() zaokrouhlí (pokud je to nutné) číslo na nejbližší celé číslo. Zde je pár příkladů, které ukazují, jak to funguje:

// Result: 4 (already an integer)
alert(Math.ceil(4));

// Result: 1
alert(Math.ceil(0.95));

// Result: 7
alert(Math.ceil(6.01));

// Result: 8
alert(Math.ceil(7.95));

Fakt, že vždy zaokrouhlí číslo nahoru a nikdy dolů, nemusí být nejlepší volbou pro většinu požadavků na zaokrouhlení. Metoda Math.round() se používá častěji - o tom si povíme níže.

Math.floor()

Zatímco metoda ceil() vždy zaokrouhlí nahoru, metoda Math.floor() vždy zaokrouhlí dolů na nejbližší celé číslo. Zde jsou některé příklady, které ukazují, jak to funguje:

// Result: 4 (already an integer)
alert(Math.floor(4));

// Result: 0
alert(Math.floor(0.95));

// Result: 6
alert(Math.floor(6.01));

// Result: 7
alert(Math.floor(7.95));

A znovu, pokud hledáte metodu, která zaokrouhlí nahoru nebo dolů, a ne vždy dolů, podívejte se na Math.round() níže.

Math.max()

Metoda max() vezme neomezený počet čísel (ale minimálně 2) a vrátí nejvyšší z nich. Funguje jak pro celá čísla, tak pro čísla s plovoucí desetinnou čárkou. Zde je příklad, jak ji lze použít:

// Result: 2
alert(Math.max(1, 2));

// Result: 8
alert(Math.max(1, 8, 2));

// Result: 0.97
alert(Math.max(0.95, 0.97, 0.01));

// Result: 10.01
alert(Math.max(4, 7.97, 10.01));

Math.min()

Zatímco metoda max() vrací největší číslo, metoda min() udělá opak a vrátí nejmenší číslo. A stejně jako metoda max() funguje jak pro celá čísla, tak pro čísla s plovoucí desetinnou čárkou. Zde jsou některé příklady:

// Result: 1
alert(Math.min(1, 2));

// Result: 2
alert(Math.min(10, 8, 2));

// Result: 0.01
alert(Math.min(0.95, 0.97, 0.01));

// Result: 4.01
alert(Math.min(4.01, 7.97, 10));

Math.random()

Často se ocitnete v situaci, kdy potřebujete vygenerovat něco náhodného, a obvykle to začíná generováním náhodného čísla. V JavaScriptu to můžeme udělat pomocí metody random(), která je součástí objektu Math. Tato metoda vždy generuje náhodné číslo s plovoucí desetinnou čárkou mezi 0 (včetně) a 1 (výjma). Zde je příklad:

// Example output: 0.5611124673777659
alert(Math.random());

Ale co když potřebujete, aby toto číslo bylo kladné celé číslo? Můžeme ho jednoduše vynásobit nějakým číslem a pak zaokrouhlit, takto:

// A number between 0 and 9
alert(Math.floor(Math.random() * 10));

// A number between 1 and 10
alert(Math.ceil(Math.random() * 10));

Vynásobím číslem 10, abych vytvořil číslo mezi 0 a 10, ale všimněte si, jak se liší použití metod ceil() a floor(), abych kontroloval, zda jsou 0 a 10 zahrnuty.

Vzhledem k tomu, že číslo, které dostaneme z metody random(), je mezi 0 a ~0,99999999, fakt, že buď zaokrouhlíme nahoru, nebo dolů na nejbližší celé číslo, znamená, že buď 0, nebo 10 bude exkluzivní, když použijeme metody ceil() a floor().

Pokud potřebujeme vygenerovat číslo, které spadá do libovolného rozsahu, například mezi 1 a 255, můžeme to docílit poměrně snadno s trochou chytré matematiky. Zde je příklad, kde jsem vytvořil funkci, která přijímá minimální a maximální parametr, aby snadno generovala číslo v určitém rozsahu:

function GetRandomNumber(min, max)
{
	return Math.random() * (max - min) + min;
}

// Example output: 163.11894979340966
alert(GetRandomNumber(0, 255));

// Example output: 163
alert(Math.floor(GetRandomNumber(0, 255)));

Ve výchozím nastavení naše funkce vrací desetinné číslo, ale jak můžete vidět z posledního řádku příkladu, můžeme to snadno zaokrouhlit na celé číslo.

Math.round()

Dříve jsme použili metodu ceil() pro zaokrouhlení nahoru na nejbližší celé číslo a metodu floor() pro zaokrouhlení dolů na nejbližší celé číslo.

Nicméně v mnoha situacích můžete chtít nechat číslo rozhodnout, zda by mělo být zaokrouhleno nahoru nebo dolů. Například 6,49 by mělo být zaokrouhleno dolů na 6, zatímco 6,51 by mělo být zaokrouhleno nahoru na 7. Naštěstí pro to máme metodu Math.round():

// Result: 1
alert(Math.round(0.51));

// Result: 10
alert(Math.round(10.42));

// Result: 10
alert(Math.round(9.71));

// Result: 42
alert(Math.round(41.50));

Jak vidíte z posledního příkladu, JavaScript zaokrouhlí nahoru, pokud je hodnota kladná a přesně mezi dvěma nejbližšími celými čísly.

Math.trunc()

Máme již tři různé metody pro zaokrouhlování čísel (ceil(), floor() a round()), ale JavaScript nabízí i čtvrtou variantu pro provádění této operace: Metodu trunc(). Je ve skutečnosti trochu jednodušší než metody, které jsme již viděli, protože funguje tak, že jednoduše odstraní desetinnou část z čísla s plovoucí desetinnou čárkou, ponechává pouze celou část. Zde je pár příkladů, které ilustrují, co to dělá:

// Result: 0
alert(Math.trunc(0.51));

// Result: 10
alert(Math.trunc(10.42));

// Result: 9
alert(Math.trunc(9.71));

// Result: 41
alert(Math.trunc(41.50));

Shrnutí

Provádění základních matematických operací v JavaScriptu je poměrně jednoduché, jak jsme viděli v předchozích článcích. Když potřebujete provést složitější operace, přijde vhod vestavěný objekt Math, jak jsme viděli v tomto článku. A pamatujte, že jsme v tomto článku nepokryli všechny dostupné metody - pro úplný přehled se prosím podívejte na dokumentaci k objektu Math.