Jquery véletlenszám a tartománytól. JavaScript által vezérelt véletlenszerű. Szám javítása egy tartományban

Miután véletlen számot generáltak egy számítógépes program segítségével, véletlenszerű számnak tekintjük, ha a kiválasztott szám az eredeti része vagy teljes része. De ha megváltoztatták, akkor a matematikusok ne fogadja el véletlenszerű számként, és elfogult számnak hívhatják. De ha egy egyszerű feladatra fejlesztesz programot, akkor ezt nem vesszük figyelembe. De ha olyan programot fejlesztesz, amely véletlenszerű számot állít elő értékes anyagokhoz, például lottóprogramhoz vagy szerencsejátékhoz, akkor a menedzsment elutasítja a programodat, ha nem veszi figyelembe ezt az esetet.

Tehát azoknak, akik ilyen emberek, íme a javaslatom:

Véletlen számok generálása a Math.random () segítségével (tegyük fel, hogy ez n)

Most akkor az n * 10 emelet a válaszod, és ha szükséges, az n * 100 emelet a válaszod, és így tovább.

Most lépj be a szerepedbe:

Számokat kért egy adott tartományon belül. (Ebben az esetben abban a tartományban kényszerül elköltözni. - Ha kiveszi a számot, és dobja a kockát, akkor rabja lesz, de akkor is csak véletlen, ha a halál elfogulatlan.)

Tehát vegye figyelembe a tartományát ==> a tartományban lévő elemek száma = 247 - 78 + 1 = 170; (Mivel mindkét határ magában foglalja

/ * Mthod 1: * / var i = 78, j = 247, k = 170, a =, b =, c, d, e, f, l = 0; mert (; i<= j; i++){ a.push(i); } while(l < 170){ c = Math.random()*100; c = Math.floor(c); d = Math.random()*100; d = Math.floor(d); b.push(a[c]); e = c + d; if((b.length != k) && (e < k)){ b.push(a[e]); } l = b.length; } console.log("Method 1:"); console.log(b); /*Method 2:*/ var a, b, c, d = , l = 0; while(l < 170){ a = Math.random()*100; a = Math.floor(a); b = Math.random()*100; b = Math.floor(b); c = a + b; if(c <= 247 || c >= 78) (d.push (c);) else (d.push (a);) l = d.hossz; ) console.log ("2. módszer:"); console.log (d);

Megjegyzés: .. Az első módszerben először létrehoztam egy tömböt, amely tartalmazza a szükséges számokat, majd véletlenszerűen elhelyeztem őket egy másik tömbben. A második módszerben generáljon véletlenszerűen számokat, és ellenőrizze, hogy azok a kívánt tartományba tartoznak-e, és majd tedd egy tömbbe. Itt két véletlenszerű számot generáltam, és az összeget felhasználva maximalizáltam a program sebességét, miközben minimalizáltam a visszafordulási arányt, miközben hasznos számot kaptam. Javasolom az első módszeremet véletlenszámok generálására egy adott tartományban.

Mindkét módszer esetén az e konzol megmutatja az eredményt. (A konzol megnyitásához nyomja meg az f12 billentyűt a Chrome-ban)

Az Math.random () A function egy lebegőpontos, ál-véletlenszerű számot ad vissza a 0–1 tartományban (beleértve a 0-t, de nem 1-et), megközelítőleg egyenletes eloszlással ezen a tartományon - amelyet ezután a kívánt tartományra méretezhet. A megvalósítás kiválasztja a kezdeti magot a véletlenszám-generáló algoritmushoz; a felhasználó nem választhatja ki és nem állíthatja vissza.

Math.random () nem adjon meg kriptográfiailag biztonságos véletlenszámokat. Ne használja semmire, ami a biztonsághoz kapcsolódik. Használja helyette a Web Crypto API-t, pontosabban a módszert.

Szintaxis

Math.random ()

Visszatérési érték

Lebegőpontos, ál-véletlenszerű szám 0 (beleértve) és 1 (kizáró) között.

Példák

Vegye figyelembe, hogy mivel a JavaScript-ben szereplő számok az IEEE 754 lebegőpontos számok, amelyek kerek-legközelebbi-egyenletes viselkedést mutatnak, az alábbi függvényekre igényelt tartományok (kivéve magát a Math.random () esetében) nem pontosak. Ha rendkívül nagy határok vannak választják (2 53 vagy annál magasabb), akkor ez lehetséges rendkívül ritka esetek az általában kizárt felső határ kiszámításához.

Véletlen szám megszerzése 0 (beleértve) és 1 (kivétel) között

függvény getRandom () (return Math.random ();)

Véletlen szám megszerzése két érték között

Ez a példa egy véletlen számot ad vissza a megadott értékek között. A visszaküldött érték nem alacsonyabb (és esetleg egyenlő) min, és kisebb (és nem egyenlő) max.

GetRandomArbitrary (min, max) függvény (return Math.random () * (max - min) + min;)

Véletlen egész szám megszerzése két érték között

Ez a példa egy véletlenszerű értéket ad vissza egész szám a megadott értékek között. Az érték nem kisebb, mint min (vagy a következő minnél nagyobb egész szám, ha min nem "egész szám"), és kisebb (de nem egyenlő) max.

Függvény getRandomInt (min, max) (min = Math.ceil (min); max = Math.floor (max); return Math.floor (Math.random () * (max - min)) + min; // A maximális kizárólagos, a minimum pedig befogadó)

Csábító lehet a Math.round () használatával ennek elérése, de ha így tenné, akkor a véletlenszerű számai nem egyenletes eloszlást követnének, ami nem biztos, hogy elfogadható az Ön igényeinek megfelelően.

Véletlenszerű egész szám megszerzése két érték között, beleértve

Míg a fenti getRandomInt () függvény minimálisan inkluzív, maximálisan kizárólagos. Mi van akkor, ha az eredményeknek minimumra és maximumra egyaránt be kell vonniuk? Az alábbi getRandomIntInclusive () függvény ezt teljesíti.

Függvény getRandomIntInclusive (min, max) (min = Math.ceil (min); max = Math.floor (max); return Math.floor (Math.random () * (max - min + 1)) + min; // A maximum befogadó és a minimum befogadó)

Specifikációk

Leírás	Állapot	Megjegyzés
ECMAScript 1. kiadás (ECMA-262)	Alapértelmezett	Kezdeti meghatározás. JavaScript 1.0 (csak UNIX) / JavaScript 1.1 (minden platform).
ECMAScript 5.1 (ECMA-262)	Alapértelmezett
ECMAScript 2015 (6. kiadás, ECMA-262) A "Math.random" meghatározása ebben a specifikációban.	Alapértelmezett
ECMAScript legújabb tervezet (ECMA-262) A "Math.random" meghatározása ebben a specifikációban.	Piszkozat

Böngésző kompatibilitás

Az ezen az oldalon található kompatibilitási táblázat strukturált adatokból származik. Ha hozzá szeretne járulni az adatokhoz, kérjük, nézze meg a https://github.com/mdn/browser-compat-data webhelyet, és küldjön nekünk egy lekérési kérelmet.

Frissítse a kompatibilitási adatokat a GitHubon

	Asztal						Mobil						szerver
	Króm	Él	Firefox	internet böngésző	Opera	Szafari	Android webnézete	Chrome Androidhoz	Firefox Androidra	Opera Androidra	Safari iOS rendszeren	Samsung Internet	Node.js
véletlen	Chrome teljes támogatás Igen	Edge Teljes támogatás 12	Firefox teljes támogatás 1	IE Teljes támogatás Igen	Opera teljes támogatás Igen	A Safari teljes támogatása Igen	WebView Android Teljes támogatás Igen	Chrome Android Teljes támogatás: Igen	Firefox Android Teljes támogatás 4	Opera Android Teljes támogatás Igen	Safari iOS Teljes támogatás: Igen	Samsung Internet Android Teljes támogatás Igen	nodejs teljes támogatás Igen

Nagyon gyakran a JavaScript-számítások nem adják meg pontosan azokat az eredményeket, amelyeket szeretnénk. Természetesen bármit megtehetünk számokkal - felfelé vagy lefelé, tartományokat állíthatunk be, a felesleges számokat levághatjuk egy bizonyos tizedesjegyig, minden attól függ, hogy mit akarunk kezdeni ezzel a számmal a jövőben.

Miért szükséges a kerekítés?

A JavaScript egyik érdekessége, hogy valójában nem tárol egész számokat, azonnal lebegőpontos számokkal dolgozunk. Ez azzal a ténnyel kombinálva, hogy sok törtérték nem fejezhető ki véges számú tizedesjegyig, a JavaScript-ben ilyen eredményeket kaphatunk:

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Gyakorlati célokból ez a pontatlanság egyáltalán nem számít, esetünkben kvintmillió rész hibájáról beszélünk, ez azonban csalódást okozhat valakinek. Kissé furcsa eredményt kaphatunk, ha olyan számokkal dolgozunk, amelyek a pénznemek, százalékok vagy fájlméretek értékét képviselik. Ezen pontatlanságok kijavításához csak képesnek kell lenniünk az eredmények kerekítésére, miközben elegendő a tizedes pontosság megadásához.

A számok kerekítésének gyakorlati alkalmazása van, manipulálhatunk egy számot egy bizonyos tartományban, például szeretnénk az értéket a legközelebbi egész számra kerekíteni, és nem csak a tizedes résszel dolgozni.

Tizedesjegyek kerekítése

Tizedes szám törléséhez használja a toFixed vagy a toPrecision metódust. Mindkettő egyetlen argumentumot vesz fel, amely meghatározza, hogy az eredménynek hány jelentős számjegynek (azaz a számban használt összes számjegy számának) vagy tizedesjegynek (a tizedesjegy utáni számnak) kell tartalmaznia:

1. Ha az argumentum nincs definiálva a toFixed () számára, akkor alapértelmezés szerint nulla lesz, ami 0 tizedesjegyet jelent, az argumentum maximális értéke 20.
2. Ha a toPrecision mellett nem adunk meg argumentumot, akkor a szám érintetlen marad

legyen 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"
A toFixed () és a toPrecision () karakterek az eredmény karakterlánc-ábrázolását adják vissza, nem számot. Ez azt jelenti, hogy amikor a kerekített összeget összegezzük a randNummal, a karakterláncok összefűznek, nem pedig a számok összege:

Legyen randNum = 6,25; legyen kerekítve = randNum.toFixed (); // "6" konzol.log (randNum + kerekítve); > "6.256"
Ha azt szeretné, hogy az eredmény numerikus adattípussal rendelkezzen, akkor a parseFloat parancsot kell használnia:

Legyen randNum = 6,25; legyen kerekítve = parseFloat (randNum.toFixed (1)); console.log (kerekítve); > 6.3
Ne feledje, hogy az 5 érték kerek, kivéve ritka eseteket.

A toFixed () és toPrecision () metódusok azért hasznosak, mert nem csak a töredékes részt képesek leválasztani, hanem a tizedesjegyeket is kitölthetik, ami kényelmes, ha valutával dolgozik:

Legyen egészNum = 1 legyen dollárCents = egészNum.toFixed (2); console.log (dollárCents); > "1.00"
Felhívjuk figyelmét, hogy a toPrecision exponenciális jelöléssel adja az eredményt, ha az egész számok nagyobbak, mint maga a pontosság:

Legyen a num = 123.435 szám a Precision (2) -ig; > "1.2e + 2"

Hogyan lehet elkerülni a tizedes számokkal való kerekítési hibákat

Bizonyos esetekben a toFixed és aPrecision az 5. lefelé és felfelé kerekíti:

Legyen a numTest = 1.005; numTest.toFixed (2); > "1.00"
A fenti számítási eredménynek 1,01-nek kellett volna lennie, nem pedig 1. Ha el akarja kerülni ezt a hibát, használhatjuk Jack L Moore által javasolt megoldást, amely exponenciális számokat használ a számításhoz:

Funkciókör (érték, tizedesjegyek) (visszatérési szám (Math.round (érték + "e" + tizedesjegyek) + "e -" + tizedesjegyek);)
Most:

Forduló (1.005,2); > 1.01
Ha a fentieknél robusztusabb megoldást szeretne, akkor az MDN-hez fordulhat.

Gépi epsilon kerekítés

Alternatív módszert vezettek be a tizedesjegyek kerekítésére az ES6-ban. A gépi epsilon kerekítés ésszerű hibahatárt biztosít két lebegőpontos szám összehasonlításakor. Kerekítés nélkül az összehasonlítások a következőkhöz hasonló eredményeket hozhatnak:

0,1 + 0,2 === 0,3> hamis
A Math.EPSILON funkciót használjuk a megfelelő összehasonlítás érdekében:

EpsEqu (x, y) függvény (adja vissza Math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
A függvénynek két argumentuma van: az első az aktuális számítás, a második a várt eredmény. Visszaadja a kettő összehasonlítását:

EpsEqu (0,1 + 0,2, 0,3)> igaz
Minden modern böngésző már támogatja az ES6 matematikai függvényeket, de ha támogatást szeretne az olyan böngészőkben, mint az IE 11, használja a többszörös kitöltéseket.

Töredékes nyírás

A fenti módszerek mindegyike tudja, hogyan kell kerekíteni a tizedesjegyekre. Annak érdekében, hogy egyszerűen levágja a számot két tizedesjegyre, először meg kell szoroznia 100-mal, majd el kell osztani az eredményt 100-mal:

Csonkított függvény (szám) (visszatérő Math.trunc (szám * 100) / 100;) csonkolt (3.1416)> 3.14
Ha tetszőleges számú tizedesjegyre szeretné igazítani a módszert, használhat kettős bitenkénti tagadást:

Csonka függvény (num, decimalPlaces) (legyen numPowerConverter = Math.pow (10, decimalPlaces); return ~~ (num * numPowerConverter) / numPowerConverter;)
Most:

Legyen randInt = 35.874993; csonka (randInt, 3); > 35,874

Kerekítés a legközelebbi számra

A tizedes szám felfelé vagy lefelé kerekítéséhez, amelyik a legközelebb van, használja a Math.round () parancsot:

Math.round (4.3)> 4 Math.round (4.5)> 5
Vegye figyelembe, hogy az "érték felét", 0,5-et felfelé kerekítik a matematika szabályai szerint.

Kerekítsen lefelé a legközelebbi egész számra

Ha mindig lefelé akar kerekíteni, használja a Math.floor alkalmazást:

Math.floor (42,23); > 42 Math.floor (36.93); > 36
Vegye figyelembe, hogy a lefelé kerekítés minden számra érvényes, beleértve a negatív számokat is. Képzeljünk el egy felhőkarcolót, amelynek végtelen sok emelete van, beleértve az alsó szintet (negatív számokat képvisel). Ha a liftben van az alsó szinten 2 és 3 között (ami -2,5 érték), akkor a Math.floor -3-ra visz:

Math.floor (-2,5); > -3
De ha el akarja kerülni ezt a helyzetet, használja a Math.trunc fájlt, amelyet minden modern böngésző támogat (kivéve az IE / Edge-t):

Math.trunc (-41,43); > -41
Az MDN-en található egy olyan polifill, amely támogatást nyújt a Math.trunc böngészőkben és az IE / Edge-ben.

Kerekítse fel a legközelebbi egész számra

Másrészt, ha mindig fel kell kerekednie, használja a Math.ceil fájlt. Ismét emlékezve a végtelen emelésre: a Math.ceil mindig emelkedni fog, függetlenül attól, hogy a szám negatív-e vagy sem:

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

Szükség szerint fel / le kerekítés

Ha az 5 legközelebbi többszörösére akarunk kerekíteni, akkor a legegyszerűbb módszer egy olyan függvény létrehozása, amely elosztja a számot 5-tel, kerekíti, majd megszorozza ugyanezzel az összeggel:

Funkció roundTo5 (num) (visszatér Math.round (num / 5) * 5;)
Most:

RoundTo5 (11); > 10
Ha értékének többszörösére akarja kerekíteni, akkor egy általánosabb függvényt használunk, beírva egy kezdeti értéket és egy többszöröset:

Funkció roundToMultiple (szám, többszörös) (adja vissza a Math.round (szám / többszörös) * többszöröset;)
Most:

Legyen kezdeti szám = 11; legyen többszörös = 10; roundToMultiple (kezdőszám, többszörös); > 10;

Szám javítása egy tartományban

Sok esetben x-et szeretnénk elérni egy tartományon belül. Például lehet, hogy 1 és 100 közötti értéket akarunk, de 123. értéket kaptunk. Ennek kijavításához használhatjuk a min (a számhalmaz közül a legkisebbet adja vissza) és a max (a számhalmazból a legnagyobbat adja ). Példánkban a tartomány 1 és 100 között van:

Legyen lowBound = 1; legyen highBound = 100; legyen numInput = 123; let clamped = Math.max (lowBound, Math.min (numInput, highBound)); console.log (befogva); > 100;
Ismét felhasználhatjuk a műveletet, és az egészet egy függvénybe csomagolhatjuk, használjuk a Daniel X. Moore által javasolt megoldást:

Number.prototype.clamp = function (min, max) (return Math.min (Math.max (ez, min), max););
Most:

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

Gauss-kerekítés

A Gauss-féle kerekítés, más néven banki kerekítés, ahol a kerekítés a legközelebbi párosra történik. Ez a kerekítési módszer statisztikai hiba nélkül működik. A legjobb megoldást Tim Down javasolta:

Funkció gaussRound (num, decimalPlaces) (legyen d = decimalPlaces || 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; }
Most:

GaussRound (2.5)> 2 gaussRound (3.5)> 4 gaussRound (2.57,1)> 2.6
Tizedespont a CSS-ben:

Mivel a JavaScript-et gyakran használják a HTML elemek helyzetbeli transzformációinak létrehozására, elgondolkodhat azon, mi történik, ha tizedes értékeket állítunk elő elemeink számára:

#box (szélesség: 63.667731993px;)
Jó hír, hogy a modern böngészők a dobozmodellben figyelembe veszik a tizedes értékeket, beleértve a százalékos vagy képpontos egységeket is.

Válogató

Nagyon gyakran válogatnunk kell néhány elemet, például van egy tömb játékrekordunk, és ezeket a játékosok rangjának csökkenő sorrendjében kell rendezni. Sajnos a standard sort () metódusnak meglepő korlátai vannak: jól működik az általánosan használt angol szavakkal, de számokkal, egyedi karakterekkel vagy nagybetűvel szembesülve azonnal elszakad.

Rendezés ábécé sorrendben

Úgy tűnik, hogy a tömb betűrend szerinti rendezése legyen a legegyszerűbb feladat:

Legyen gyümölcs = ["butternut squash", "barack", "sárgadinnye"]; gyümölcs.válogatás (); > "barack", "butternut squash", "sárgadinnye"]
Azonban problémába ütközünk, amint az egyik elem nagybetűvel jelenik meg:

Legyen gyümölcs = ["butternut squash", "barack", "Cantalope"]; gyümölcs.válogatás (); > "Sárgadinnye", "sárgabarack", "butternut tök"]
Ennek oka, hogy a válogató alapértelmezés szerint összehasonlítja az Unicode-ban ábrázolt első karaktert. Az Unicode minden karakter egyedi kódja, platformtól függetlenül, programtól és nyelvtől függetlenül. Például, ha megnézzük a kódtáblát, az "a" karakter U + 0061 értékkel rendelkezik (0x61 hexadecimális rendszerben), míg a "C" karakter U + 0043 (0x43) kóddal rendelkezik, amely korábban a Unicode tábla, mint az "A" karakter.

Egy tömb rendezéséhez, amely vegyes betűket tartalmazhat az első betűkből, vagy át kell alakítanunk az összes elemet kisbetűvé, vagy meg kell határoznunk saját rendezési sorrendünket a localeCompare () metódus segítségével, néhány argumentummal. Általános szabály, hogy ilyen esetekben jobb, ha azonnal létrehozunk egy funkciót ismételt használatra:

Függvény alphaSort (arr) (arr.sort (függvény (a, b) (visszatér a.localeCompare (b, "en", ("érzékenység": "alap"));));) hagyja gyümölcs = ["butternut squash "," barack "," sárgadinnye "]; alphaSort (gyümölcs)>
Ha egy tömböt fordított alfabetikus sorrendbe szeretne rendezni, akkor egyszerűen cserélje ki az a és b pozíciókat a függvényben:

Függvény alphaSort (arr) (arr.sort (függvény (a, b) (return b.localeCompare (a, "en", ("érzékenység": "alap"));));) hagyja gyümölcs = ["butternut squash "," barack "," sárgadinnye "]; alphaSort (gyümölcs)> ["sárgadinnye", "butternut tök", "sárgabarack"]
Itt érdemes megjegyezni, hogy a localeCompare argumentumokkal van használva, emlékeznie kell arra is, hogy az IE11 + támogatja, az IE régebbi verziói esetén argumentumok nélkül használhatjuk kisbetűvel:

Funkció caseSort (arr) (arr.sort (függvény (a, b) (adja vissza a.toLowerCase (). LocaleCompare (b.toLowerCase ());)););) let fruit = ["butternut squash", "barack" "Kantalup dinnye"]; caseSort (gyümölcs)> ["barack", "butternut squash", "sárgadinnye"]

Numerikus rendezés

Mindez nem vonatkozik arra a példára, amelyről fentebb a játékrekordok tömbjéről beszéltünk. Egyes numerikus tömböknél a rendezés rendben működik, de valamikor az eredmény kiszámíthatatlan lehet:

Legyen highScores =; highScores.sort (); >
Az a tény, hogy a sort () módszer lexikográfiai összehasonlítást hajt végre: ez azt jelenti, hogy a számokat karakterláncokká konvertáljuk, és az összehasonlításokat újra elvégezzük, ha a karakterlánc első karakterét az Unicode tábla karaktereinek sorrendjében illesztjük össze. Ezért ismét meg kell határoznunk a rendezési sorrendünket:

Legyen highScores =; highScores.sort (függvény (a, b) (visszatér a - b;)); >
Ismét fordított sorrendben rendezheti a számokat, cserélje ki a és b pozícióit a függvényben.

JSON-szerű struktúra rendezése

Végül, ha van egy JSON-szerű adatstruktúra, amelyet játékrekordok tömbjeként ábrázolunk:

Legyen pontszám = [("név": "Daniel", "pontszám": 21768), ("név": "Michael", "pontszám": 33579), ("név": "Alison", "pontszám": 38395 )];
Az ES6 + rendszerben nyílfüggvényeket használhat:

Scores.sort ((a, b) => b.score - a.score));
Régebbi böngészők számára, amelyek nem rendelkeznek ezzel a támogatással:

Scores.sort (függvény (a, b) (return a.score - b.score));
Mint láthatja, a JavaScript-ben történő válogatás nem nyilvánvaló dolog, remélem, hogy ezek a példák valahogy megkönnyítik az életet.

Az energiafüggvényekkel való munka

A hatványozás egy olyan művelet, amelyet eredetileg egy természetes szám többszörös szorzásának eredményeként határoztak meg, az a négyzetgyöke az a szám, amely négyzetre ad. Ezeket a funkciókat folyamatosan használhatnánk a mindennapi életben a matematika órákon, beleértve a területek, a térfogatok kiszámításakor vagy akár a fizikai modellezés során is.

A JavaScript-ben az exponenciális függvény Math.pow () néven jelenik meg, az új ES7 szabványban egy új hatványozási operátor kerül bevezetésre - "* *".

Hatványozás

Ha egy számot az n-edik hatványra szeretne emelni, használja a Math.pow () függvényt, ahol az első argumentum a hatványra emelendő szám, a második argumentum a kitevő:

Math.pow (3,2)> 9
Ez a jelölési forma 3 négyzetet vagy 3 × 3-at jelent, ami a 9. eredményhez vezet. Természetesen adhatsz még egy példát:

Math.pow (5,3); > 125
Vagyis 5 kockás vagy 5 × 5 × 5 egyenlő 125-tel.

Az ECMAScript 7 a JavaScript következő verziója, elvileg használhatjuk az új javasolt hatványozási operátort - * *, ez a jelölési forma leíróbb lehet:

3 ** 2 > 9
Jelenleg ennek az operátornak a támogatása meglehetősen korlátozott, ezért nem ajánlott használni.

A teljesítmény funkció sokféle helyzetben jól jöhet. Egyszerű példa az másodpercek számának kiszámítására egy órában: Math.pow (60,2).

Négyzet és kocka gyökér

A Math.sqrt () és a Math.cbrt () ellentéte a Math.pow () függvénynek. Ne felejtsük el, hogy az a négyzetgyöke az a szám, amely négyzetet ad.

Math.sqrt (9)> 3
Ugyanakkor az a szám kocka gyöke az a szám, amely a kockára emelve a-t adja.

Math.cbrt (125)> 5
A Math.cbrt () a közelmúltban került bevezetésre a JavaScript specifikációba, ezért csak a modern böngészőkben támogatott: Chrome 38+, Firefox és Opera 25+, valamint Safari 7.1+. Észre fogja venni, hogy az Internet Explorer nem szerepel ezen a listán, azonban az MDN-n talál polifillet.

Példák

Természetesen nem egész értékeket is használhatunk az alábbi függvények egyikében:

Math.pow (1,25, 2); > 1,5625 Math.cbrt (56,57)> 3,8387991760286138
Vegye figyelembe, hogy ez a negatív argumentumértékek esetében is jól működik:

Math.pow (-5,2)> 25 Math.pow (10, -2)> 0,01
Négyzetgyök esetén azonban ez nem fog működni:

Math.sqrt (-9)> NaN
Matematikai elemzésből tudjuk, hogy egy képzeletbeli számot a negatív számok négyzetgyökeként értünk. És ez vezethet egy másik technikához a komplex számokkal való munkavégzéshez, de ez egy másik történet.

A Math.pow () töredékértékeit használhatja a számok négyzet- és kocka gyökereinek megtalálásához. A négyzetgyök 0,5 kitevőt használ:

Math.pow (5, 0,5); // = Math.sqrt (5) = 5 ** (1/2)> 2,23606797749979
A lebegőpont szeszélye miatt azonban nem tudja pontosan kitalálni a helyes eredményt:

Math.pow (2.23606797749979.2)> 5.000000000000001
Ilyen helyzetekben a jelek számtól való csonkolásához vagy valamilyen értékre kerekítéshez kell folyamodnia.

Egyesek valamilyen ismeretlen okból a JavaScript-ben összekeverik a Math.pow () függvényt a Math.exp () függvénnyel, amely általában a számok exponenciális függvénye. Megjegyzés: angolul az "exponent" fordítás "exponens", tehát ez inkább az angolul beszélőkre vonatkozik, bár vannak olyan alternatív nevek a kitevőnek, mint például index, power.

Matematikai állandók

A matematika használatát a JavaScript-ben számos beépített állandó megkönnyíti. Ezek az állandók a Math objektum tulajdonságai. Érdemes megjegyezni, hogy az állandókat nagybetűvel írjuk, nem a CamelCase jelöléssel.

Csak regisztrált felhasználók vehetnek részt a felmérésben. , kérem.

Címkék: Címkék hozzáadása

Technikailag a "véletlenszám-generátor" kifejezés abszurd, mivel maguk a számok sem véletlenszerűek. Például 100 véletlenszerű szám? És 25? Ez a kifejezés valójában azt jelenti, hogy véletlenszerűen megjelenő számok sorozatát hozza létre. Ez egy összetettebb kérdést vet fel: Mi a véletlen számok sorrendje? Az egyetlen helyes válasz: a véletlenszámok sorozata olyan sorrend, amelyben az összes elem nincs kapcsolatban. Ez a definíció olyan paradoxonhoz vezet, hogy bármely szekvencia lehet véletlenszerű és nem véletlenszerű is, attól függően, hogy ez a szekvencia hogyan jön létre. Például a következő számsor
1 2 3 4 5 6 7 8 9 0
a billentyűzet felső vonalának sorrendbe történő beírásával nyertük, így a sorrend nem tekinthető véletlenszerűen generáltnak. De mi van, ha ugyanolyan következetességet kap, ha kiveszi a hordóból a számozott teniszlabdákat. Ebben az esetben ez már véletlenszerűen generált szekvencia. Ez a példa azt mutatja, hogy egy szekvencia véletlenszerűsége attól függ, hogy hogyan nyerték, és nem önmagától.

Ne feledje, hogy a számítógép által generált számok sorrendje meghatározó: az első kivételével minden szám az előző számoktól függ. Technikailag ez azt jelenti, hogy a számítógép csak kvázi véletlenszerű szekvenciát generálhat, azaz. valójában nem igazán véletlenszerűek. Ez azonban a legtöbb feladathoz elegendő, és az ilyen szekvenciákat az egyszerűség kedvéért véletlenszerűnek nevezzük. Az egyik nagyon érdekes módszert John von Neumann dolgozta ki; gyakran középtörzsnek nevezik. Ennél a módszernél az előző véletlenszám négyzetre kerül, majd a középső számjegyeket kivonjuk az eredményből. Például, ha három számjegyből állít elő számokat, és az előző szám 121 volt, akkor a négyzetre állítással 14641-et kapunk. A középső három számjegy kiválasztásával a következő véletlenszerű számot kapjuk: 464. Ennek a módszernek az a hátránya, hogy nagyon rövid ismétlődési periódusú, ún. egy hurok ... Emiatt ezt a módszert ma nem alkalmazzák. A véletlenszámok előállításának modern módszerei sokkal bonyolultabbak.

Véletlen számok PHP-ben

A PHP a véletlenszám-függvények két csoportját tartalmazza. Kívülről megkülönböztethetők az egyik csoport összes funkciójának mt_ előtagjával.

Elavult funkciók
A rand. Visszatér egy nullától RAND_MAX-ig (ami 32767). Két opcionális egészparamétere lehet - ha meg vannak adva, akkor véletlenszám jön létre az első paramétertől a másodikig.

Echo rand (); visszhang rand (1100); // Adjon meg egy véletlen számot 1-től 100-ig

Srand. Megadja a Rand függvény által előállított véletlen számok sorrendjét. Van egy egész paramétere - ennek a paraméternek a különböző értékeihez a rand különböző számsorozatot állít elő. Az srand függvényt csak egyszer kell meghívni, mielőtt a Rand függvény minden hívást megadna. Használati példa:

Srand (1288); // Inicializálja a ($ i = 0; $ i<5;$i++){ echo rand(); echo "
"; }

Figyelem! A PHP 4.2.0 verziótól kezdve nem kell meghívni az srand () -t - a PHP ezt automatikusan elvégzi.
Getrandmax () függvény. Visszaadja a maximális véletlenszerű számot (32767).

A második csoport funkciói (mt_ előtaggal)
Nevük és műveleteik hasonlóak az első csoport funkcióihoz - mt_rand, mt_srand és mt_getrandmax. A fő különbség az, hogy a véletlenszerű számokat szélesebb tartományból veszik: 0-tól 21937-ig - 1. Ezenfelül ezek a funkciók sokkal gyorsabban működnek, mint régi társaik, mivel a japán tudósok által 1997-ben kifejlesztett Mersenne Twister véletlenszám-generátort használják. Ezért az mt_ előtag (Mersenne Twister).
Használati példa:

// Készítsen véletlenszerű számot 1000-től 2000-ig echo mt_rand (1000, 2000);

Véletlen számok JavaScript-ben

Véletlen szám a JavaScript-ben a Math.random () segítségével generálható. Ez azonban egy tört szám lesz 0 és 1 között (a 0 és 1 nélkül. A véletlenszerű egész szám előállításához a kívánt tartományban meg kell írnia a saját függvényét

Leírás

A Math.random () módszer 0 és 1 közötti álvéletlen számot ad vissza.

Álvéletlen véletlen számot generálnak a 0-tól (beleértve) és 1-ig (kizárva), vagyis a visszaküldött szám lehet nulla, de mindig kevesebb, mint egy.

Ha lebegőpontos számot akar egész számra kerekíteni, használhatja például a Math.floor () metódust.

Szintaxis

Math.random ()

Visszatérési érték

• Lebegőpontos szám 0-tól (beleértve) és 1-ig (kizárólagos).

A Math.random () metódust főleg egy álvéletlenszám előállítására használják egy adott tartományban. Például számot kell kapnunk az 50 és 100 közötti tartományban (beleértve). Ehhez a következő kódot kell megírnunk:

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

Vizsgáljuk meg részletesen, hogyan működik a példánk, és miért használják ezt a bizonyos formát. Először meg kell adnunk a kívánt tartományból kapott minimális értéket, példánkban ez az 50-es szám. Most valahogyan meg kell szereznünk egy véletlenszerű számot, amely az 50-es számhoz hozzáadva nem fogja összeadni a 100-as szám. Mint a matematikából tudjuk, az ismeretlen kifejezés megtalálása az ismert kifejezés levonásával történik az összegből. 100 - 50: 50-es különbséget kapunk. Most annak ellenőrzésére, hogy ez a szám alkalmas-e számunkra, vagy nem, megszorozzuk a Math.random () módszerrel kapott lehetséges minimális és maximális számmal. Megszorozzuk a minimális 0,004704564176082244 * 50 = 0,2 ... és a maximális 0,9999999999746223 * 50 = 49,9 ... És így azt látjuk, hogy ha a különbséget megszorozzuk a lehető legnagyobb véletlenszerű számmal, akkor az eredmény az első szám egész számát adja meg kevesebb, mint szükséges. A helyzet kijavításához csak egy egységet kell hozzáadni 50-hez, azaz. 50 + 1 = 51, most ha az eredményül kapott számot megszorozzuk a módszer által adott lehetséges maximális számmal, akkor megkapjuk az 50,9 számot ... - erre van szükségünk, miután összeadtuk az 50,9 + 50 számokat, akkor 100,9-et kapunk . Ha egy számot egész számra kíván kerekíteni, használja a Math.floor () metódust. Így a kívánt szám megszerzésének képlete a következő: max - min + 1. Írjuk át a fenti példát:

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

Ez a képlet különösen akkor hasznos, ha nem tudja előre, hogy milyen tartományban szeretne véletlenszerű számot kapni.

Példa

Álvéletlen véletlen szám az 1 és 10 közötti tartományban.