Popis

Metóda Math.random () vracia pseudo náhodné číslo medzi 0 a 1.

Pseudonáhodné číslo sa generuje v rozsahu od 0 (vrátane) do 1 (exkluzívne), to znamená, že vrátené číslo môže byť nula, ale vždy bude menšie ako jedna.

Na zaokrúhlenie čísla s pohyblivou rádovou čiarkou na celé číslo môžete použiť napríklad metódu Math.floor ().

Syntax

Math.random ()

Návratová hodnota

• Číslo s pohyblivou rádovou čiarkou v rozsahu od 0 (vrátane) do 1 (bez).

Metóda Math.random () sa používa hlavne na generovanie pseudonáhodného čísla v špecifickom rozsahu. Napríklad potrebujeme získať číslo v rozsahu od 50 do 100 (vrátane). Aby sme to dosiahli, musíme napísať nasledujúci kód:

Document.write (Math.floor (Math.random () * 51 + 50));

Pozrime sa podrobne na to, ako funguje náš príklad a prečo sa používa táto konkrétna forma zápisu. Najprv musíme uviesť minimálnu hodnotu získanú z požadovaného rozsahu, v našom príklade je to číslo 50. Teraz musíme nejakým spôsobom dostať náhodné číslo, ktoré po pripočítaní k číslu 50 nebude zodpovedať číslo 100. Ako vieme z matematiky, hľadanie neznámeho pojmu sa robí odčítaním známeho pojmu od súčtu. 100 - 50: dostaneme rozdiel 50. Teraz, aby sme skontrolovali, či je toto číslo pre nás vhodné alebo nie, vynásobíme ho možným minimom a maximálny počet vrátené metódou Math.random (). Minimum vynásobíme 0,004704564176082244 * 50 = 0,2 ... a maximum 0,9999999999746223 * 50 = 49,9 ... A tak vidíme, že pri vynásobení rozdielu maximálnym možným náhodným číslom nám výsledok dá celú časť čísla menej ako je potrebné. Aby sme situáciu napravili, stačí nám pripočítať jednu jednotku k 50, t.j. 50 + 1 = 51, ak teraz výsledné číslo vynásobíme maximálnym možným počtom vráteným metódou, dostaneme číslo 50,9 ... - to je to, čo potrebujeme, po sčítaní čísel 50,9 + 50 dostaneme 100,9 . Ak chcete zaokrúhliť číslo na celé číslo, použite metódu Math.floor (). Vzorec na získanie požadovaného čísla teda vyzerá nasledujúcim spôsobom: max - min + 1. Prepíšme vyššie uvedený príklad:

Var max = 100, min = 50; document.write (Math.floor (Math.random () * (max - min + 1) + min));

Tento vzorec je užitočný najmä vtedy, keď vopred neviete, v akom rozsahu chcete získať náhodné číslo.

Príklad

Pseudonáhodné číslo v rozsahu od 1 do 10.

2. júna 2013 o 22:56

JavaScript riadený náhodne

• JavaScript

"Algoritmus" pre náhodné vzorkovanie hodnôt z poľa bez ich opakovania. Presnejšie, v rámci JS tréningu som ho použil na vygenerovanie klasickej RPG skupiny postáv (barbar, kúzelník, zlodej, rytier, kňaz), bez opakovania tried a mien.

Princíp je mimoriadne jednoduchý, no môže sa hodiť začiatočníkom JS, ako som ja. Odkaz na RPG je mimoriadne symbolický - teraz sa aktívne snažím zmeniť svoj profil z marketingu na IT (uvedomil som si, že moja duša leží) a cvičím v herná forma oveľa zaujímavejšie.

1. Vytvorte šablónu

Pred vygenerovaním skupiny znakov je potrebné nastaviť šablónu na ich generovanie. Vlastne tu:

Funkcia GamePlayer (n, r, l, p) (this.nick = n; this.role = r; this.level = l; this.portrait = p;)
V skutočnosti táto funkcia vytvorí znaky z premenných, cez ktoré sa bude volať. Napríklad:

Var player1 = nový hráč hry ("Power Ranger", "barbarian", "64", "img / barbarian.jpg")
Teraz variabilný hráč1 ukladá barbara Power Rangera 64. úrovne s určitým portrétom; ktorýkoľvek z jeho parametrov môžeme zobraziť v tele stránky pomocou player1.nick, player1.level atď.

Hodnoty (n, r, l, p) z GamePlayer sú zodpovedné za príjem a príjem dát do funkcie. Ak sa v príklade vymenia n a r, potom mocný ranger Barbarian zostane v hráčovi 1, čo úplne nezodpovedá úlohe.

2. Nastavenie polí

Aby sme znaky nevytvárali sami, ale takmer náhodne ich generovali (ako sľubuje nadpis), potrebujeme polia, z ktorých budeme brať parametre práve týchto postáv. Ako už bolo popísané vyššie, máme len 4 parametre: meno postavy, trieda, úroveň a portrét.

Pole pre meno:

Menná hráča Var = ["Bezmocný králik", "Teplé obávané žriebä", "Súprava túžby", "Angel Dusty", "Sladký mrazivý", "Silver Heavy Wombat", "Lost Puma", "Vital Panda", "Rolling Sun" , "Steel Runny", "Young Fox", "Needless Ruthless Volunteer", "Chipmunk Cult", "Indigo Puppy"];
Dalo by sa ísť ďalej a generovať mená z 2-3 komponentov, ale algoritmus na takéto zlepšenie neobsahuje nič nové (rovnako náhodné), a potom by to jednoducho skomplikovalo študijný proces.

Pole pre triedu:

Var hráč Roly = ["barbar", "mág", "darebák", "rytier", "kňaz"];
Všetko je rovnako samozrejmé. Niekoľko reťazcov, z ktorých potom vyberieme hodnoty pre zobrazenie na stránke.

Pole pre úroveň:

V konkrétny príklad, Chcel som, aby všetci členovia skupiny mali úroveň 60 až 70. Keďže sa však podmienky môžu meniť, bolo potrebné vytvoriť pole od 0 do 80 úrovní, z ktorých potom vyberte požadované hodnoty. Vytvorené v slučke:

Var hráčÚrovne =; pre (i = 0; i<= 80;i++) { console.log(i); playerLevels[i] = i; }
Výsledkom je pole playerLevels, ktorého každá bunka obsahuje int s vlastným číslom.

Pole pre portréty:

Var playerPortraits = ["img / barbarian.jpg", "img / mág.jpg", "img / rogue.jpg", img / rytier.jpg "," img / priest.jpg "];
Rovnaký princíp, ale namiesto textu používame odkazy na obrázky. Ďalej ich môžeme nahradiť v parametri background-image požadovaného divu (alebo v parametri src požadovaného obrázku, ako je to pre každého pohodlnejšie).

Dôležité je, aby poradie obrázkov v poli playerPortraits bolo totožné s poradím tried v poli playerRoles, potom môžeme použiť rovnakú náhodnú premennú na ich vygenerovanie (aby sa obrázok zhodoval s triedou).

3. Generovanie znakov

Ako som povedal, v skupine by malo byť 5 postáv. Preto vytvoríme cyklus:

Pre (i = 0; i<=4;i++) { }
Pred cyklom je dôležité deklarovať pole pre naše budúce znaky:

Var hráči =;

Var namerand = Math.floor (Math.random () * playerNames.length)

• Marh.random () sa používa na generovanie náhodného čísla;
• Násobenie menami hráčov.dĺžka (dĺžka poľa playerNames) - na obmedzenie náhodného čísla počtom mien v poli;
• Math.floor - na prevod výsledného čísla na celé číslo.

Nuansou je, že Math.floor sa zaokrúhľuje nadol, ale keďže číslovanie v poliach začína od 0, vyhovuje nám to.

Generovanie tried

Princíp a implementácia sú rovnaké:

Var rolerand = Math.floor (Math.random () * (playerRoles.length));
Jediný rozdiel je v tom, že pre triedy používame pole playerRoles.

Generovanie úrovne

Var levelrand = Math.floor (Math.random () * (70 - 60 + 1) + 60);
Výpočet náhody v určitom intervale prebieha podľa vzorca Math.random () * (max - min) + min.

V príklade dostaneme náhodu od 0 do 10 a potom k nej pridáme 60, čím dostaneme rozsah od 60 + 0 do 60 + 10 (to je to, čo chceme). Pridanie jednotky je nevyhnutné kvôli použitiu Math.floor (čítaj vyššie).

Generovanie znakov

Predfinálny krok. Aby sme vytvorili znak, musíme skombinovať všetky jeho parametre do jednej premennej, ako v prvom príklade. Vyzerá to takto:

Hráči [i] = nový hráč (mená hráčov, roly hráčov, úrovne hráčov, portréty hráčov);
V skutočnosti sa každá postava stáva prvkom hráčskeho poľa s vlastným poradovým číslom. Jeho parametre:

• playerNames - meno, náhodný výber z mien (bunka pod menom a číslo v playerNames);
• hráč Roles - trieda, náhodný výber z tried;
• playerLevels - trieda, náhodný výber úrovne v rozmedzí 60-70;
• playerPortraits - portrét, náhodný výber z portrétov.

Ako som uviedol vyššie, polia portrétov a tried musia byť identické, aby sa „obrázok zhodoval“; preto môžeme v oboch prípadoch použiť rovnakú náhodnosť.

Kontrolované náhodné

Finálny. Ak to necháte tak, ako to je, bude to fungovať. Dostaneme však skupinu postáv veľmi odlišných tried (napríklad 3 kúzelníkov a 2 zlodejov) s rovnakými menami. Aby ste tomu zabránili, stačí niekoľko jednoduchých krokov:

Hráči [i] = nový hráč (mená hráčov, roly hráčov, úrovne hráčov, portréty hráčov); playerMená.splice (namerand, 1); playerRoles.splice (rolerand, 1); playerPortraits.splice (rolerand, 1);
Ihneď po tom, čo znaku priradíme parametre, odstránime ich bunky z príslušných polí.

Presnejšie, playerNames.splice (namerand, 1) odstráni menorand s číslom slotu z poľa playerNames pomocou operácie spojenia. Jednotka za desatinnou čiarkou ukazuje, koľko buniek treba vymazať počnúc od zadanej; potrebujeme vymazať iba jednu, samotnú zadanú bunku.

Ďalej sa slučka znova opakuje a mohla by sa vrátiť ako nedefinovaná, ak by narazila na poslednú bunku poľa (napokon sme ju znížili o 1). Ale keďže náš Math.random používa playerNames.length a iné, priamo závisí od dĺžky poľa a vytvorí len nové, neduplikované hodnoty.

4. Záver

Dodatočne môžete opísať interakciu tohto skriptu so stránkou: zobrazovanie „kariet“ postáv, načítanie ich portrétov atď., ale to je celkom zrejmý proces spojený s hlavnými funkciami JS. Navyše som svoj jednoduchý manuál už trochu dotiahol. Takže môžete vidieť vizualizáciu procesu v príklade.

Technicky je pojem „generátor náhodných čísel“ absurdný, keďže samotné čísla nie sú náhodné. Je napríklad 100 náhodné číslo? A 25? Tento výraz v skutočnosti znamená, že vytvára postupnosť čísel, ktoré sa objavujú náhodne. To vyvoláva zložitejšiu otázku: Čo je to postupnosť náhodných čísel? Jediná správna odpoveď: postupnosť náhodných čísel je postupnosť, v ktorej všetky prvky nesúvisia. Táto definícia vedie k takému paradoxu, že akákoľvek sekvencia môže byť náhodná aj nenáhodná, v závislosti od toho, ako sa táto sekvencia získa. Napríklad nasledujúci riadok čísel
1 2 3 4 5 6 7 8 9 0
bola vygenerovaná napísaním horného riadku klávesnice v poradí, takže sekvenciu nemožno považovať za náhodne vygenerovanú. Ale čo keď získate rovnakú konzistenciu tým, že vyberiete očíslované tenisové loptičky zo súdka. V tomto prípade ide už o náhodne vygenerovanú sekvenciu. Tento príklad ukazuje, že náhodnosť sekvencie závisí od toho, ako bola získaná, a nie od nej samotnej.

Pamätajte, že postupnosť čísel vygenerovaných počítačom je deterministická: každé číslo okrem prvého závisí od predchádzajúcich čísel. Technicky to znamená, že počítač dokáže vygenerovať len kvázi náhodnú postupnosť čísel, t.j. v skutočnosti nie sú skutočne náhodné. Pre väčšinu úloh to však stačí a takéto sekvencie budeme pre jednoduchosť nazývať náhodné. Jednu veľmi zaujímavú metódu vyvinul John von Neumann; často sa označuje ako odmocnina. Pri tejto metóde sa predchádzajúce náhodné číslo odmocní a potom sa z výsledku extrahujú stredné číslice. Napríklad, ak vytvoríte čísla s tromi číslicami a predchádzajúce číslo bolo 121, potom umocnenie dáva 14641. Výberom prostredných troch číslic získate ďalšie náhodné číslo 464. Nevýhodou tejto metódy je, že má veľmi krátku periódu opakovania, tzv. slučka... Z tohto dôvodu sa dnes táto metóda nepoužíva. Moderné metódy generovania náhodných čísel sú oveľa komplikovanejšie.

Náhodné čísla v PHP

PHP má dve skupiny funkcií náhodných čísel. Navonok ich možno rozlíšiť predponou mt_ pre všetky funkcie jednej zo skupín.

Zastarané funkcie
Rand. Vráti celé číslo od nuly do RAND_MAX (čo je 32767). Môže mať dva voliteľné celočíselné parametre – ak sú špecifikované, potom sa od prvého parametra po druhý generuje náhodné číslo.

Echo rand (); echo rand (1 100); // Zadajte náhodné číslo od 1 do 100

Srand. Určuje postupnosť náhodných čísel vytvorených funkciou rand. Má celočíselný parameter - pre rôzne hodnoty tohto parametra rand vytvorí rôzne sekvencie čísel. Srand je potrebné zavolať iba raz pred všetkými výzvami na rand. Príklad použitia:

Srand (1288); // Inicializujte generátor náhodných čísel pre ($ i = 0; $ i<5;$i++){ echo rand(); echo "
"; }

Pozor! Od PHP 4.2.0 nemusíte volať srand () – PHP to robí automaticky.
Funkcia Getrandmax (). Vráti maximálne náhodné číslo (32767).

Funkcie druhej skupiny (s predponou mt_)
Ich názvy a akcie sú podobné funkciám prvej skupiny – mt_rand, mt_srand a mt_getrandmax. Hlavný rozdiel je v tom, že náhodné čísla sú prevzaté zo širšieho rozsahu: od 0 do 21937 - 1. Navyše tieto funkcie fungujú oveľa rýchlejšie ako ich staré náprotivky, pretože používajú generátor náhodných čísel Mersenne Twister, vyvinutý v roku 1997 japonskými vedcami. Odtiaľ pochádza predpona mt_ (Mersenne Twister).
Príklad použitia:

// Zadajte náhodné číslo od 1000 do 2000 echo mt_rand (1000, 2000);

Náhodné čísla v JavaScripte

Náhodné číslo v JavaScripte možno vygenerovať pomocou Math.random (). Bude to však zlomkové číslo medzi 0 a 1 (okrem 0 a 1). Ak chcete vygenerovať náhodné celé číslo v požadovanom rozsahu, musíte napísať svoju vlastnú funkciu

Výpočty v JavaScripte často nedávajú presne požadované výsledky. Samozrejme, s číslami môžeme robiť čokoľvek – zaokrúhľovať nahor alebo nadol, nastaviť rozsahy, odrezať 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 zvláštnych aspektov JavaScriptu je, že v skutočnosti neukladá celé čísla, okamžite pracujeme s číslami s pohyblivou rádovou čiarkou. To spolu so skutočnosťou, že mnohé zlomkové hodnoty nemožno vyjadriť v konečných počtoch desatinných miest, v JavaScripte môžeme získať výsledky, ako sú tieto:

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

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

Zaokrúhľovanie desatinných čísel

Ak chcete odstrániť desatinné číslo, použite metódu toFixed alebo toPrecision. Obaja majú 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ť:

1. Ak argument nie je definovaný pre toFixed (), predvolene sa nastaví na nulu, čo znamená 0 ​​desatinných miest, argument má maximálnu hodnotu 20.
2. Ak nie je zadaný žiadny argument pre presnosť, čí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"
ToFixed () aj toPrecision () vrátia reťazecovú reprezentáciu výsledku, nie číslo. To znamená, že keď je zaokrúhlená hodnota sčítaná s randNum, reťazce budú zreťazené, nie súčet čísel:

Nech randNum = 6,25; nech zaokrúhlené = randNum.toFixed (); // "6" console.log (randNum + zaokrúhlené); > "6,256"
Ak chcete, aby mal výsledok číselný typ údajov, budete musieť použiť parseFloat:

Nech randNum = 6,25; nech rounded = parseFloat (randNum.toFixed (1)); console.log (zaokrúhlené); > 6.3
Upozorňujeme, že 5 hodnôt je zaokrúhlených okrem zriedkavých prípadov.

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

Nech celéČíslo = 1 nech doláreCenty = celéČíslo.toFixed (2); console.log (dolárovCents); > "1,00"
Upozorňujeme, že toPrecision poskytne výsledok v exponenciálnom zápise, ak je počet celých čísel väčší ako samotná presnosť:

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

Ako sa vyhnúť chybám pri zaokrúhľovaní pri desatinných číslach

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

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

Zaokrúhlenie funkcie (hodnota, desatinné miesta) (vrátenie čísla (Math.round (hodnota + "e" + desatinné miesta) + "e -" + desatinné miesta);)
teraz:

kolo (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 správneho porovnania používame v našej funkcii Math.EPSILON:

Funkcia epsEqu (x, y) (návrat Math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Funkcia má dva argumenty: prvý je aktuálny výpočet, druhý je očakávaný výsledok. Vráti porovnanie týchto dvoch:

EpsEqu (0,1 + 0,2, 0,3)> pravda
Všetky moderné prehliadače už podporujú matematické funkcie ES6, ale ak chcete podporu v prehliadačoch ako IE 11, použite polyfilly.

Zlomkové orezanie

Všetky vyššie uvedené metódy vedia, ako zaokrúhliť na desatinné čísla. Aby ste číslo jednoducho odrezali na dve desatinné miesta, musíte ho najskôr vynásobiť 100 a potom vydeliť výsledok 100:

Funkcia skrátená (num) (návrat Math.trunc (num * 100) / 100;) skrátená (3,1416)> 3,14
Ak chcete umiestniť ľubovoľný počet desatinných miest, môžete použiť dvojitú bitovú 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úhľovanie na najbližšie číslo

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

Mat.kolo (4.3)> 4 Mat.kolo (4.5)> 5
Všimnite si, ž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.podla (36,93); > 36
Upozorňujeme, že zaokrúhlenie nadol funguje pre všetky čísla vrátane záporných. Predstavte si mrakodrap s nekonečným počtom poschodí, vrátane tých na nižšej úrovni (predstavujú záporné čísla). Ak sa nachádzate vo výťahu na nižšej úrovni medzi 2 a 3 (čo je hodnota -2,5), Math.floor vás vezme dole na -3:

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

Math.trunc (-41,43); > -41
Na MDN nájdete polyfill, ktorý bude poskytovať podporu pre Math.trunc v prehliadačoch a IE / Edge.

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

Na druhej strane, ak potrebujete vždy zaokrúhliť nahor, použite Math.ceil. Opäť si pamätajte na nekonečný výťah: Math.ceil bude vždy stúpať, 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 podľa potreby

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) (návrat Math.round (num / 5) * 5;)
teraz:

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

Funkcia roundToMultiple (počet, násobok) (návrat Math.round (počet / násobok) * násobok;)
teraz:

Nech zač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ť x v rámci rozsahu. Napríklad by sme mohli chcieť hodnotu medzi 1 a 100, ale dostaneme hodnotu 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 (lowBound, Math.min (numInput, highBound)); console.log (upnutý); > 100;
Opäť môžeme znova použiť operáciu a celé to zabaliť do funkcie, použime riešenie, ktoré navrhol Daniel X. Moore:

Number.prototype.clamp = funkcia (min, max) (návrat Math.min (Math.max (tento, min), max););
teraz:

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

Gaussovo zaokrúhľovanie

Gaussovské zaokrúhľovanie, známe aj ako bankové zaokrúhľovanie, je miesto, kde sa zaokrúhľuje na najbližšie párne. Tento spôsob zaokrúhľovania funguje bez štatistickej chyby. Najlepšie riešenie navrhol Tim Down:

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á čiarka v CSS:

Keďže JavaScript sa často používa na generovanie pozičných transformácií prvkov HTML, možno vás zaujíma, čo sa stane, ak pre naše prvky vygenerujeme desatinné hodnoty:

#box (šírka: 63,667731993px;)
Dobrou správou je, že moderné prehliadače budú brať do úvahy desatinné hodnoty v krabicovom modeli, a to aj v percentách alebo jednotkách 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 poradia hráčov. Bohužiaľ, štandardná metóda triedenia () má niekoľko prekvapivých obmedzení: funguje dobre s bežne používanými anglickými slovami, ale okamžite sa preruší, keď sa stretnete s číslami, jedinečnými znakmi alebo veľkými slovami.

Zoradiť podľa abecedy

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

Nech ovocie = ["butternut tekvica", "marhuľa", "cantaloupe"]; ovocie.roztriediť (); > "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 = ["maslová tekvica", "marhuľa", "Cantalopa"]; ovocie.roztriediť (); > "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. Ak sa napríklad 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ý sa nachádza skôr v Unicode tabuľka ako znak "A".

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

Funkcia alphaSort (arr) (arr.sort (funkcia (a, b) (návrat 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íte 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) (vrátenie a.na malé písmená (). LocaleCompare (b.na malé písmená ());));) nech ovocie = ["butternut 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 rade 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 vysoké skóre =; highScores.sort (); >
Faktom je, že metóda sort () vykonáva lexikografické porovnanie: čo znamená, že čísla sa prevedú na reťazec a porovnania sa vykonajú opäť zhodou prvého znaku tohto reťazca v poradí znakov tabuľky Unicode. Preto musíme opäť definovať naše poradie zoradenia:

Nech vysoké skóre =; highScores.sort (funkcia (a, b) (návrat 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

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) (návrat a.skóre - b.skóre));
Ako vidíte, triedenie v JavaScripte nie je samozrejmosťou, dúfam, že tieto príklady nejako uľahčia život.

Práca s napájacími funkciami

Umocňovanie je operácia, ktorá bola pôvodne definovaná ako výsledok viacnásobného násobenia prirodzeného čísla samo osebe, druhá odmocnina z a je číslo, ktoré pri odmocnení dáva a. Tieto funkcie by sme mohli neustále využívať v bežnom živote na hodinách matematiky, aj pri výpočte plôch, objemov alebo aj pri fyzikálnom modelovaní.

V JavaScripte je exponenciálna funkcia reprezentovaná ako Math.pow (), v novom štandarde ES7 je zavedený nový operátor umocňovania - "* *".

Umocňovanie

Na zvýšenie čísla na n-tú mocninu použite funkciu Math.pow (), kde prvý argument je číslo, ktoré sa má umocniť, 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ôžete samozrejme uviesť iný príklad:

Math.pow (5,3); > 125
To znamená, že 5 kociek alebo 5 x 5 x 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 pre tohto operátora značne obmedzená, preto sa neodporúča používať ju.

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

Štvorcová a kubická odmocnina

Math.sqrt () a Math.cbrt () sú opakom funkcie Math.pow (). Pamätajte, že druhá odmocnina z a je číslo, ktoré dáva a pri druhej mocnine.

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

Math.cbrt (125)> 5
Math.cbrt () bol zavedený do špecifikácie JavaScript veľmi nedávno, a preto je podporovaný iba v moderných prehliadačoch: Chrome 38+, Firefox a Opera 25+ a Safari 7.1+. Všimnete si, že v tomto zozname chýba Internet Explorer, na MDN však nájdete polyfill.

Príklady

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

Math.pow (1,25, 2); > 1,5625 Math.cbrt (56,57)> 3,8387991760286138
Všimnite si, že to funguje dobre aj pre záporné hodnoty argumentov:

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

Math.sqrt (-9)> NaN
Z matematickej analýzy vieme, že imaginárne číslo sa chápe ako druhá odmocnina záporných čísel. A to by nás mohlo priviesť k inej technike práce s komplexnými číslami, ale to je už iný príbeh.

Na nájdenie druhej mocniny a druhej mocniny čísel môžete použiť zlomkové hodnoty v Math.pow (). 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,000000000000001
V takýchto situáciách sa budete musieť uchýliť k skráteniu znakov z čísla alebo zaokrúhleniu na nejakú hodnotu.

Niektorí si z nejakého neznámeho dôvodu v JavaScripte mýlia funkciu Math.pow () s Math.exp (), čo je exponenciálna funkcia pre čísla vo všeobecnosti. Poznámka: V angličtine sa výraz „exponent“ prekladá ako „exponent“, takže sa to skôr vzťahuje na 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.

Do prieskumu sa môžu zapojiť iba registrovaní užívatelia. Vstúpte prosím.

Značky:

• javascript
• matematika

Pridať značky