Funcția de generator de numere aleatorii în javascript. Gestionat aleatoriu în JavaScript. Numere aleatorii în PHP
Din punct de vedere tehnic, termenul „generator de numere aleatoare” este un nonsens, deoarece numerele în sine nu sunt aleatorii. De exemplu, 100 este Număr aleatoriu? Ce zici de 25? Ceea ce înseamnă de fapt acest termen este că creează o secvență de numere care apar aleatoriu. Aceasta ridică o întrebare mai dificilă: ce este o succesiune de numere aleatorii? Singurul răspuns corect: o succesiune de numere aleatoare este o succesiune în care toate elementele nu au legătură. Această definiție duce la paradoxul că orice secvență poate fi fie aleatorie, fie non-aleatorie, în funcție de modul în care este obținută secvența. De exemplu, rândul următor numere
1 2 3 4 5 6 7 8 9 0
a fost primit prin tipar linia de sus tastaturile în ordine, astfel încât secvența nu poate fi considerată generată aleatoriu. Dar ce se întâmplă dacă obții aceeași secvență când scoți mingile de tenis numerotate din butoi. În acest caz, este deja o secvență generată aleatoriu. Acest exemplu arată că aleatoritatea unei secvențe depinde de modul în care a fost obținută, nu de ea însăși.
Amintiți-vă că o secvență de numere generată de computer este deterministă: fiecare număr, cu excepția primului, depinde de numerele dinainte. Din punct de vedere tehnic, aceasta înseamnă că doar o secvență cvasialeatorie de numere poate fi generată de un computer, adică. de fapt ele nu sunt cu adevărat aleatorii. Cu toate acestea, acest lucru este suficient pentru majoritatea sarcinilor și, pentru simplitate, astfel de secvențe vor fi numite aleatoare. O metodă foarte interesantă a fost dezvoltată de John von Neumann; este adesea numit rădăcină medie pătrată. În această metodă, numărul aleatoriu anterior este pătrat, iar apoi cifrele din mijloc sunt extrase din rezultat. De exemplu, dacă creați numere cu trei cifre, iar numărul anterior a fost 121, atunci pătratul dă rezultatul 14641. Izolarea celor trei cifre din mijloc dă următorul număr aleatoriu 464. Dezavantajul acestei metode este că are un perioadă scurtă de repetiție, numită ciclu. Din acest motiv aceasta metoda nefolosit astăzi. Metode moderne Generarea de numere aleatorii este mult mai dificilă.
Numere aleatorii în PHPPHP are două grupuri de funcții pentru a lucra cu numere aleatoare. Pur extern, ele pot fi distinse prin prefixul mt_ pentru toate funcțiile unuia dintre grupuri.
Caracteristici depreciate
funcția rand Returnează un număr întreg între zero și valoarea lui RAND_MAX (care este 32767). Poate avea doi parametri întregi opționali - dacă sunt specificați, se generează un număr aleator de la primul parametru la al doilea.
Echo rand(); echo rand(1.100); // Dați un număr aleatoriu de la 1 la 100
Funcția srand. Specifică succesiunea de numere aleatoare produse de funcția rand. Are un parametru întreg - când sensuri diferite Cu acest parametru, rand va produce diferite secvențe de numere. Funcția srand trebuie apelată o singură dată înainte de toate apelurile la funcția rand. Exemplu de utilizare:
Srand(1288); // Inițializați generatorul de numere aleatoare pentru ($i=0; $i 0,0200000000000000004 0,3 - 0,1 > 0,1999999999999998
În scopuri practice, această inexactitate nu contează, în cazul nostru vorbim despre o eroare în chintilioane, totuși, acest lucru poate dezamăgi pe unii. De asemenea, putem obține rezultate oarecum ciudate atunci când lucrăm cu numere care reprezintă monede, procente sau dimensiuni de fișiere. Pentru a corecta aceste inexactități, trebuie doar să putem rotunji rezultatele și este suficient să setăm precizia zecimală.
Rotunjirea numerelor are uz practic, este posibil să manipulăm un număr într-un anumit interval, de exemplu, dorim să rotunjim valoarea la cel mai apropiat număr întreg, în loc să lucrăm doar cu partea zecimală.
Rotunjirea numerelor zecimale Pentru a tăia numar decimal, utilizați metoda toFixed sau toPrecision. Ambele au un singur argument care specifică, respectiv, câte cifre semnificative (adică numărul total de cifre utilizate în număr) sau zecimale (numărul după virgulă) rezultatul ar trebui să includă:Ambele metode toFixed() și toPrecision() returnează o reprezentare șir a rezultatului, nu un număr. Aceasta înseamnă că atunci când însumăm o valoare rotunjită cu randNum, va produce o concatenare de șiruri de caractere mai degrabă decât o sumă de numere:
Fie randNum = 6,25; let rounded = randNum.toFixed(); // "6" console.log(randNum + rotunjit); > „6.256”
Dacă vrei ca rezultatul să fie tip numeric date, atunci va trebui să aplicați parseFloat:
Fie randNum = 6,25; let rounded = parseFloat(randNum.toFixed(1)); console.log(rotunjit); > 6.3
Vă rugăm să rețineți că valorile de 5 sunt rotunjite, cu excepția cazurilor rare.
Metodele toFixed() și toPrecision() sunt utile deoarece nu numai că pot tăia partea fracțională, ci și pot adăuga zecimale, ceea ce este convenabil atunci când lucrați cu moneda:
Let wholeNum = 1 let dollarsCents = wholeNum.toFixed(2); console.log(dollarsCents); > „1.00”
Rețineți că toPrecision va produce rezultatul în notație științifică dacă numărul de numere întregi este mai mare decât precizia în sine:
Fie num = 123,435 num.toPrecision(2); > „1.2e+2”
Cum să evitați erorile de rotunjire cu zecimale În unele cazuri, toFixed și toPrecision rotunjesc valoarea 5 în jos și în sus:Fie numTest = 1,005; numTest.toFixed(2); > „1.00”
Rezultatul calculului de mai sus ar fi trebuit să fie 1,01, nu 1. Dacă doriți să evitați eroare similară, putem folosi soluția propusă de Jack L Moore, care folosește numere exponențiale pentru a calcula:
Funcția rotund(valoare, zecimale) ( returnează Număr(Math.round(valoare+"e"+zecimale)+"e-"+zecimale); )
Acum:
Rotunzi (1,005,2); > 1.01
Dacă doriți o soluție mai robustă decât cea prezentată mai sus, puteți merge la MDN.
0,1 + 0,2 === 0,3 > fals
Folosim Math.EPSILON în funcția noastră pentru a obține o comparație validă:
Funcția epsEqu(x, y) ( returnează Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y));
}
Funcția are două argumente: primul este calculul curent, al doilea este rezultatul așteptat. Acesta returnează o comparație a celor două:
EpsEqu(0,1 + 0,2, 0,3) > adevărat
Toate browserele moderne acceptă deja ES6 functii matematice dar dacă doriți suport în browsere precum IE 11, utilizați polyfills.
Funcția trunchiat(num) ( return Math.trunc(num * 100) / 100; ) trunchiat(3.1416) > 3.14
Dacă doriți să adaptați metoda la orice număr de zecimale, puteți utiliza negația dublă pe biți:
Funcția trunchiată(num, decimalPlaces) (let numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Acum:
Fie randInt = 35,874993; trunchiat(randInt,3); > 35.874
Rotunjirea la cel mai apropiat număr Pentru a rotunji un număr zecimal la cel mai apropiat număr în sus sau în jos, oricare dintre ele ne aflăm cel mai aproape, utilizați Math.round():Math.round(4.3) > 4 Math.round(4.5) > 5
Rețineți că „jumătate din valoare”, 0,5 este rotunjit la latura mare conform regulilor matematicii.
Math.floor(42,23); > 42 Math.floor(36,93); > 36
Vă rugăm să rețineți că rotunjirea în jos funcționează pentru toate numerele, inclusiv pentru numerele negative. Imaginați-vă un zgârie-nori cu un număr infinit de etaje, inclusiv etaje la nivelul de jos (reprezentând numere negative). Dacă vă aflați într-un lift la cel mai jos nivel între 2 și 3 (care reprezintă o valoare de -2,5), Math.floor vă va duce la -3:
Math.floor(-2,5); > -3
Dar daca vrei sa eviti situație similară, utilizați Math.trunc , acceptat în toate browsere moderne(cu excepția IE/Edge):
Math.trunc(-41,43); > -41
Pe MDN veți găsi un polyfill care va oferi suport pentru Math.trunc în browsere și IE/Edge.
Math.ceil(42,23); > 43 Math.ceil(36,93); > 37 Math.ceil(-36,93); > -36
Rotunjirea în sus/în jos la numărul necesar Dacă dorim să rotunjim la cel mai apropiat multiplu de 5, cel mai simplu mod este de a crea o funcție care împarte numărul la 5, îl rotunjește și apoi îl înmulțește cu aceeași sumă:Funcția roundTo5(num) ( return Math.round(num/5)*5; )
Acum:
RoundTo5(11); > 10
Dacă doriți să rotunjiți la multipli ai valorii dvs., folosim mai mult functia generala, trecând valoarea inițială și un multiplu în ea:
Funcția roundToMultiple(num, multiple) ( returnează Math.round(num/multiple)*multiple; )
Acum:
Fie initialNumber = 11; fie multiplu = 10; roundToMultiple(initialNumber, multiple); > 10;
Fixarea unui număr într-un interval Există multe cazuri în care dorim să obținem o valoare a lui x care se află într-un interval. De exemplu, s-ar putea să avem nevoie de o valoare între 1 și 100, dar am ajuns la o valoare de 123. Pentru a remedia acest lucru, putem folosi min (returnează cel mai mic dintr-un set de numere) și max (returnează cel mai mare dintre orice set). de numere). În exemplul nostru, intervalul este de la 1 la 100:Fie lowBound = 1; lasă highBound = 100; fie numInput = 123; let clamped = Math.max(lowBound, Math.min(numInput, highBound)); console.log(blocat); > 100;
Din nou, putem reutiliza operația și înfășura totul într-o funcție, folosind soluția propusă de Daniel X. Moore:
Number.prototype.clamp = function(min, max) ( return Math.min(Math.max(this, min), max); );
Acum:
NumInput.clamp(lowBound, highBound); > 100;
Rotunjirea Gaussă Rotunjirea Gauss, cunoscută și sub denumirea de rotunjire bancară, implică rotunjirea la cel mai apropiat număr par. Această metodă de rotunjire funcționează fără erori statistice. Cea mai bună decizie a fost sugerat de Tim Down:Funcția gaussRound(num, decimalPlaces) ( fie 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;
}
Acum:
GaussRound(2,5) > 2 gaussRound(3,5) > 4 gaussRound(2,57,1) > 2,6
Decimală în CSS:
Deoarece JavaScript este adesea folosit pentru a crea mapări poziționale pentru elementele HTML, s-ar putea să vă întrebați ce s-ar întâmpla dacă am genera valori zecimale pentru elementele noastre:
#box ( lățime: 63,667731993px; )
Vestea bună este că browserele moderne vor respecta valorile zecimale în model bloc, inclusiv unități procentuale sau pixeli.
Lăsați fructe = [„dovleac”, „caise”, „cântăpân”]; fruct.sort(); > „caisă”, „dovleac”, „gustalup”]
Cu toate acestea, ne confruntăm cu o problemă de îndată ce unul dintre elemente este cu litere mari:
Lasa fructe = ["dovleac", "caise", "Cantalope"]; fruct.sort(); > „Cantalup”, „caise”, „dovleac”]
Acest lucru se datorează faptului că, în mod implicit, sortatorul compară primul caracter reprezentat în Unicode. Unicode este cod unic pentru orice simbol, indiferent de platformă, indiferent de program, indiferent de limbă. De exemplu, dacă te uiți la tabelul de coduri, caracterul „a” are valoarea U+0061 (in sistem hexazecimal 0x61), în timp ce caracterul „C” are codul U+0043 (0x43), care apare mai devreme în tabelul Unicode decât caracterul „a”.
Pentru a sorta o matrice care poate conține primele litere mixte cu majuscule, trebuie fie să convertim temporar toate elementele în minuscule, fie să definim ordinea noastră de sortare folosind metoda localeCompare() cu unele argumente. De regulă, pentru un astfel de caz, este mai bine să creați imediat o funcție pentru utilizare repetată:
Funcția alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("sensibilitate": "bază")); )); ) let fruit = ["dovleac butternut „, „caisă”, „Cantalup”]; alphaSort(fructe) >
Dacă doriți ca matricea să fie sortată în ordine alfabetică inversă, schimbați pur și simplu pozițiile lui a și b în funcție:
Funcția alphaSort(arr) ( arr.sort(function (a, b) ( return b.localeCompare(a, "en", ("sensibilitate": "bază")); )); ) let fruit = ["dovleac butternut „, „caisă”, „Cantalup”]; alphaSort(fructe) > ["Cantalupe", "dovleac", "caise"]
Aici este de remarcat faptul că localeCompare este folosit cu argumente, trebuie să ne amintim, de asemenea, că este suportat de IE11+, pentru versiunile mai vechi de IE, îl putem folosi fără argumente și cu litere mici:
Funcția caseSort(arr) ( arr.sort(funcție (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) let fruit = ["dovleac", "caise", "Pepene galben"]; caseSort(fructe) > ["caise", "dovleac", "Cantalup"]
Sortare numerică Toate acestea nu se aplică exemplului despre care am vorbit mai sus despre gama de înregistrări de joc. Cu unele matrice numerice, sortarea funcționează bine, dar la un moment dat rezultatul poate fi imprevizibil:Fie highScores = ; highScores.sort(); >
Chestia este că metoda sort() realizează o comparație lexicografică: ceea ce înseamnă că numerele vor fi convertite într-un șir și comparațiile se vor face din nou prin potrivirea primului caracter al acelui șir în ordinea caracterelor din tabelul Unicode. . Prin urmare, trebuie să definim din nou ordinea noastră de sortare:
Fie highScores = ; highScores.sort(function(a,b) ( return a - b; )); >
Din nou, pentru a sorta numerele în ordine inversă, schimbați pozițiile lui a și b în funcție.
Fiți scoruri = [ ( „nume”: „Daniel”, „scor”: 21768 ), ( „nume”: „Michael”, „scor”: 33579 ), ( „nume”: „Alison”, „scor”: 38395 ) ];
În ES6+, puteți utiliza funcții de săgeți:
Scores.sort((a, b) => b.score - a.score));
Pentru browserele mai vechi care nu au acest suport:
Scores.sort(funcție(a, b) ( returnează a.score - b.score ));
După cum puteți vedea, sortarea în JavaScript este un lucru destul de obscur, sper că aceste exemple vor face viața mai ușoară cumva.
În JavaScript functie de putere introdus ca Math.pow(), a fost introdus în noul standard ES7 nou operator exponentiație - " * * ".
Ridicarea la o putere Pentru a ridica un număr la a n-a putere, utilizați funcția Math.pow(), unde primul argument este numărul care va fi ridicat la putere, al doilea argument este exponentul:Math.pow(3,2) > 9
Această formă de notație înseamnă 3 pătrat, sau 3 × 3, ceea ce duce la rezultatul 9. Un alt exemplu poate fi dat, desigur:
Math.pow(5,3); > 125
Adică, 5 cuburi, sau 5 × 5 × 5, este egal cu 125.
ECMAScript 7 este următoarea versiune JavaScript, în principiu, putem folosi noul operator de exponențiere propus - * *, această formă de notație poate fi mai descriptivă:
3 ** 2
> 9
Pe acest moment Suportul pentru acest operator este destul de limitat, deci utilizarea lui nu este recomandată.
Funcția de putere poate fi utilă în cele mai multe situatii diferite. Un exemplu simplu, calcularea numărului de secunde într-o oră: Math.pow (60,2).
Rădăcina pătrată și cubă Math.sqrt() și Math.cbrt() sunt opusul Math.pow(). După cum ne amintim, rădăcina pătrată a lui a este numărul care dă a când este pătrat.Math.sqrt(9) > 3
În același timp, rădăcina cubă a lui a este un număr care dă a atunci când este ridicat la un cub.
Math.cbrt(125) > 5
Math.cbrt() a fost introdus doar recent în specificația JavaScript și, prin urmare, este acceptat doar în browserele moderne: Chrome 38+, Firefox și Opera 25+ și Safari 7.1+. Vei observa asta Internet Explorer nu se află pe această listă, dar veți găsi un polyfill pe MDN.
Math.pow(1,25, 2); > 1,5625 Math.cbrt(56,57) > 3,8387991760286138
Vă rugăm să rețineți că acest lucru funcționează destul de bine și atunci când utilizați valori negative ale argumentelor:
Math.pow(-5,2) > 25 Math.pow(10,-2) > 0,01
Cu toate acestea, acest lucru nu va funcționa pentru rădăcina pătrată:
Math.sqrt(-9) > NaN
Din analiză matematicăȘtim că prin număr imaginar înțelegem rădăcinile pătrate ale numerelor negative. Și asta ne poate conduce la o altă tehnică de lucru numere complexe, Dar asta este o altă poveste.
Puteți folosi fracții în Math.pow() pentru a găsi rădăcinile pătrate și cubice ale numerelor. Rădăcină pătrată folosește exponentul 0,5:
Math.pow(5, 0,5); // = Math.sqrt(5) = 5 ** (1/2) > 2,23606797749979
Cu toate acestea, din cauza capricilor virgulă mobilă, nu puteți ghici exact rezultatul corect:
Math.pow(2,23606797749979,2) > 5,000000000000001
În astfel de situații, va trebui să recurgeți la tăierea semnelor din număr sau rotunjirea la o anumită valoare.
Unii, de din motive necunoscute JavaScript confundă funcția Math.pow() cu Math.exp() , care este o funcție exponențială pentru numere în general. Notă: în Limba engleză„exponent” este tradus ca „exponent”, deci este mai probabil să se aplice vorbitorilor de engleză, deși există denumiri alternative pentru exponent, cum ar fi index, putere.
Constante matematice Lucrul cu matematica în JavaScript este facilitat de un număr de constante încorporate. Aceste constante sunt proprietăți ale obiectului Math. Este de remarcat faptul că constantele sunt scrise cu majuscule, nu cu notația CamelCase.Numai utilizatorii înregistrați pot participa la sondaj. , Vă rog.
Etichete: Adăugați eticheteExistă mai multe exemple:
/** * Returnează un număr aleatoriu între min (inclusiv) și max (exclusiv) */ function getRandomArbitrary(min, max) ( return Math.random() * (max - min) + min; ) /** * Returnează un întreg aleatoriu între min (inclusiv) și max (inclusiv). * Valoarea nu este mai mică decât min (sau următorul întreg mai mare decât min * dacă min nu este un întreg) și nu este mai mare decât max (sau următorul întreg * mai mic decât max dacă max nu este un întreg). * Utilizarea Math.round() vă va oferi o distribuție neuniformă! */ funcția getRandomInt(min, max) ( min = Math.ceil(min); max = Math.floor(max); return Math.floor(Math.random() * (max - min + 1)) + min; )
Iată logica din spatele ei. Este o regulă simplă de trei:
Math.random() returnează un număr între 0 (inclusiv) și 1 (exclusiv). Deci avem acest interval:
Atunci etajul n * 10 este răspunsul tău, iar dacă ai nevoie, atunci etajul n * 100 este răspunsul tău etc.
Acum introduceți rolul dvs.:
Ai cerut numere printre anumit interval. (În acest caz, sunteți părtinitor în acest interval. - Luând un număr de la , aruncând zarul, vă va influența spre , dar este totuși un caz aleatoriu dacă și numai dacă moartea este imparțială.)
Deci, să luăm în considerare intervalul == > numărul de elemente ale intervalului = 247 - 78 + 1 = 170; (deoarece ambele margini sunt incluse.
/*Mthod 1:*/ var i = 78, j = 247, k = 170, a = , b = , c, d, e, f, l = 0; pentru(; i 20) ( bool = adevărat; ) else ( bool = fals; ) ) returnează numărul; )
Aici este MS DotNet care implementează clasa aleatoare în javascript -
Var Random = (funcție () ( funcție Random(Seed) ( dacă (!Seed) ( Seed = this.milisecunde(); ) this.SeedArray = ; for (var i = 0; i< 56; i++) this.SeedArray.push(0); var num = (Seed == -2147483648) ? 2147483647: Math.abs(Seed); var num2 = 161803398 - num; this.SeedArray = num2; var num3 = 1; for (var i_1 = 1; i_1 < 55; i_1++) { var num4 = 21 * i_1 % 55; this.SeedArray = num3; num3 = num2 - num3; if (num3 < 0) { num3 += 2147483647; } num2 = this.SeedArray; } for (var j = 1; j < 5; j++) { for (var k = 1; k < 56; k++) { this.SeedArray[k] -= this.SeedArray; if (this.SeedArray[k] < 0) { this.SeedArray[k] += 2147483647; } } } this.inext = 0; this.inextp = 21; Seed = 1; } Random.prototype.milliseconds = function () { var str = new Date().valueOf().toString(); return parseInt(str.substr(str.length - 6)); }; Random.prototype.InternalSample = function () { var num = this.inext; var num2 = this.inextp; if (++num >= 56) ( num = 1; ) if (++num2 >= 56) ( num2 = 1; ) var num3 = this.SeedArray - this.SeedArray; dacă (num3 == 2147483647) ( num3--; ) dacă (num3< 0) { num3 += 2147483647; } this.SeedArray = num3; this.inext = num; this.inextp = num2; return num3; }; Random.prototype.Sample = function () { return this.InternalSample() * 4.6566128752457969E-10; }; Random.prototype.GetSampleForLargeRange = function () { var num = this.InternalSample(); var flag = this.InternalSample() % 2 == 0; if (flag) { num = -num; } var num2 = num; num2 += 2147483646.0; return num2 / 4294967293.0; }; Random.prototype.Next = function (minValue, maxValue) { if (!minValue && !maxValue) return this.InternalSample(); var num = maxValue - minValue; if (num = 0) { gen_num = parseInt((Math.random() * (max-min+1)) + min); } else { random_number.push(gen_num); is_exist = -2; } } while (is_exist >-1); ) document.getElementById("box").innerHTML = random_number; )
Pentru a obține un număr aleatoriu, să spunem între 1 și 6, mai întâi faceți:
0,5 + (Math.random() * ((6 - 1) + 1))
Acest lucru înmulțește numărul aleatoriu cu 6 și apoi îi adaugă 0,5. Apoi rotunjește numărul la un întreg pozitiv, făcând:
Math.round(0,5 + (Math.random() * ((6 - 1) + 1))
Aceasta rotunjește numărul la cel mai apropiat număr întreg.
Sau pentru a fi mai clar, procedați astfel:
Valoare var = 0,5 + (Math.random() * ((6 - 1) + 1)) var rol = Math.round(valoare); rola de retur;
În general, codul pentru aceasta folosind variabile este:
Valoare var = (Min - 0,5) + (Math.random() * ((Max - Min) + 1)) var rol = Math.round(valoare); rola de retur;
Motivul pentru a scădea 0,5 din valoarea minimă este că utilizarea numai a valorii minime vă va permite să obțineți un număr întreg care ar fi mai mare decât valoarea maximă. Prin eliminarea 0,5 din valoarea minimă, în esență împiedicați rotunjirea valorii maxime.
Sper că acest lucru vă ajută.
Număr întreg aleatoriu între cel mai mic și cel mai mare:
Funcția randomRange(l,h)( var range = (h-l); var random = Math.floor(Math.random()*range); if (random === 0)(random+=1;) return l+random; )
Nu cea mai elegantă soluție.. dar ceva rapid.
Aici îl folosesc pentru a genera numere aleatorii.
Funcția random(high,low) ( high++; return Math.floor((Math.random())*(high-low))+low; )
Facem high++ deoarece Math.random() generează un număr aleator între 0 (inclusiv) și 1 (exclusiv). Eliminat înseamnă că trebuie să creștem maximul cu unul înainte de a face orice matematică. Scădem apoi valoarea scăzută din valoarea mare, dându-ne cel mai mare număr pentru generație - scăzut, apoi + scăzut, care revine la normal și face cel mai mic număr cu macar scăzut. apoi returnăm numărul rezultat
random(7,3) poate returna 3,4,5,6 sau 7
/* presupunând că window.crypto.getRandomValues este disponibil, intervalul real ar fi de la 0 la 1.998 în loc de la 0 la 2.000 Consultați documentația javascript pentru explicații https://developer.mozilla.org/en-US/docs/Web/ API/ RandomSource/getRandomValues */ var array = nou Uint8Array(2); window.crypto.getRandomValues(array); console.log(matrice + matrice);
Uint8Array creează o matrice umplută cu până la trei cifre, care nu trebuie să fie mai mare de 999. Acest cod este foarte scurt.
Funcția getRandomInt(lower, upper) ( //pentru a crea o distribuție uniformă a eșantionului returnează Math.floor(lower + (Math.random() * (sus - jos + 1))); //pentru a produce o distribuție neuniformă a eșantionului // return Math.round(lower + (Math.random() * (sus - jos)) //pentru a exclude valoarea maximă din valorile posibile //return Math.floor(lower + (Math.random())); * ( inferior superior)));
Pentru a testa această caracteristică și variante ale acestei caracteristici, salvați HTML/JavaScript de mai jos într-un fișier și deschideți-l într-un browser. Codul va afișa un grafic care arată distribuția unui milion de apeluri de funcție. Codul va înregistra și cazuri de margine, așa că dacă funcția produce o valoare mai mare decât max sau mai mică decât min, veți.ști.despre.
funcția getRandomInt(lower, upper) ( //pentru a crea o distribuție uniformă a eșantionului returnează Math.floor(lower + (Math.random() * (sus - jos + 1))); //pentru a produce o distribuție neuniformă a eșantionului // return Math.round(lower + (Math.random() * (sus - jos)) //pentru a exclude valoarea maximă din valorile posibile //return Math.floor(lower + (Math.random())); * ( sus - inferior))); var max = 5; var array = nou Array(); for(var i = 0; i 2012 function isEmpty(value)( return (typeof value === "undefined)" || value === null);
}
var numSeq = new Array();
function add(num,seq){
var toAdd = new Object();
toAdd.num = num;
toAdd.seq = seq;
numSeq = toAdd;
}
function fillNumSeq (num,seq){
var n;
for(i=0;i!}
