javascript willekeurig getal. Het genereren van willekeurige gehele getallen in JavaScript binnen een specifiek bereik

Er zijn verschillende voorbeelden:

/** * Geeft een willekeurig getal terug tussen min (inclusief) en max (exclusief) */ function getRandomArbitrary(min, max) ( return Math.random() * (max - min) + min; ) /** * Geeft een willekeurig geheel getal tussen min (inclusief) en max (inclusief).

* De waarde is niet lager dan min (of het volgende gehele getal groter dan min * als min geen geheel getal is) en niet groter dan max (of het volgende gehele getal * lager dan max als max geen geheel getal is).

* Als je Math.round() gebruikt, krijg je een niet-uniforme verdeling!

*/ functie getRandomInt(min, max) ( min = Math.ceil(min); max = Math.floor(max); return Math.floor(Math.random() * (max - min + 1)) + min; )

Hier is de logica erachter. Het is een eenvoudige regel van drie:

Math.random() retourneert een getal tussen 0 (inclusief) en 1 (exclusief). We hebben dus dit interval: Dan is verdieping n*10 uw antwoord, en als u dat nodig heeft, dan is verdieping n*100 uw antwoord, enz. Voer nu uw rol in:

U heeft nummers opgevraagd onder

bepaald bereik

. (In dit geval ben je bevooroordeeld in dit bereik. - Als je een getal neemt van , en de dobbelsteen gooit, krijg je een voorkeur voor , maar het is nog steeds een willekeurig geval als en alleen als de dood onbevooroordeeld is.)

Laten we dus eens kijken naar uw bereik ==> aantal bereikelementen = 247 - 78 + 1 = 170; (aangezien beide randen zijn inbegrepen.< 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 >/*Mthode 1:*/ var i = 78, j = 247, k = 170, a = , b = , c, d, e, f, l = 0;< 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 >for(; i 20) ( bool = true; ) else ( bool = false; ) ) retournummer; )

Hier is MS DotNet die de willekeurige klasse in javascript implementeert -

Var Random = (functie () ( functie Random(Seed) ( if (!Seed) ( Seed = this.milliseconds(); ) this.SeedArray = ; for (var i = 0; i

= 56) ( num = 1; ) if (++num2 >= 56) ( num2 = 1; ) var num3 = this.SeedArray - this.SeedArray;

als (num3 == 2147483647) ( num3--; ) als (num3

-1);

) document.getElementById("box").innerHTML = willekeurig_getal;

Var-waarde = 0,5 + (Math.random() * ((6 - 1) + 1)) var roll = Math.round(waarde);

retourrol;

Over het algemeen is de code hiervoor met variabelen:

Var-waarde = (Min - 0,5) + (Math.random() * ((Max - Min) + 1)) var roll = Math.round(waarde); retourrol; De reden om 0,5 af te trekken

minimale waarde

is dat als je alleen de minimumwaarde gebruikt, je een geheel getal kunt krijgen dat groter is dan je maximale waarde. Door 0,5 van de minimumwaarde af te halen, voorkomt u feitelijk dat de maximumwaarde wordt afgerond.

Ik hoop dat dit helpt.

Willekeurig geheel getal tussen laagste en hoogste: Functie randomRange(l,h)( var range = (h-l); var random = Math.floor(Math.random()*range); if (willekeurig === 0)(willekeurig+=1;) retourneert l+willekeurig; ) Niet de beste

elegante oplossing .. maar iets snels..

Hier gebruik ik om te genereren

willekeurige getallen Functie willekeurig(hoog,laag) ( hoog++; return Math.floor((Math.random())*(hoog-laag))+laag; ) We doen high++ omdat Math.random() een willekeurig getal genereert tussen 0 (inclusief) en 1 (exclusief). Geëlimineerd betekent dat we het maximum met één moeten verhogen voordat we iets gaan berekenen. Vervolgens trekken we de lage waarde af van de hoge waarde, wat ons oplevert grootste aantal voor generatie - laag, dan + laag, wat terugkeert naar normaal en het kleinste getal haalt

ten minste

laag. dan retourneren we het resulterende getal

random(7,3) kan 3,4,5,6 of 7 retourneren

/* ervan uitgaande dat window.crypto.getRandomValues beschikbaar is, zou het echte bereik van 0 tot 1.998 zijn in plaats van 0 tot 2.000. Zie javascript-documentatie voor uitleg https://developer.mozilla.org/en-US/docs/Web/ API/ RandomSource/getRandomValues */ var array = new Uint8Array(2);

Om deze functie en varianten van deze functie te testen, slaat u het onderstaande HTML/JavaScript op in een bestand en opent u het in een browser. De code toont een grafiek die de verdeling van één miljoen functieaanroepen toont. De code registreert ook randgevallen, dus als de functie een waarde oplevert die groter is dan max, of kleiner dan min, weet je dat.

function getRandomInt(lower, upper) ( //om een gelijkmatige steekproefverdeling te creëren, retourneer Math.floor(lower + (Math.random() * (upper - lower + 1))); //om een ongelijkmatige steekproefverdeling te produceren // return Math.round(lower + (Math.random() * (upper - lower))) //om de maximale waarde uit te sluiten van de mogelijke waarden //return Math.floor(lower + (Math.random()) * (boven - onder)));" || 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 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998 !}
varmax = 5;

var array = nieuwe Array(); for(var i = 0; i 2012 functie isEmpty(waarde)( return (typewaarde === "undefined Voor praktische doeleinden doet deze onnauwkeurigheid er helemaal niet toe, in ons geval hebben we het over een fout in kwintiljoensten, maar dit kan sommigen teleurstellen. We kunnen ook enigszins vreemde resultaten krijgen als we werken met getallen die valuta's, percentages of bestandsgroottes vertegenwoordigen. Om deze onnauwkeurigheden te corrigeren, hoeven we alleen maar de resultaten af te ronden, en het is voldoende om de decimale precisie in te stellen.

Afrondingsgetallen hebben praktische toepassing, kunnen we een getal binnen een bepaald bereik manipuleren. We willen de waarde bijvoorbeeld afronden op het dichtstbijzijnde gehele getal in plaats van alleen met het decimale deel te werken. Decimale getallen afronden Om af te sluiten decimaal getal , gebruik toFixed of de toPrecision-methode. Beiden nemen één enkel argument, dat respectievelijk bepaalt hoeveel significante cijfers

(d.w.z. het totale aantal cijfers dat in een getal wordt gebruikt) of decimalen (het getal erna). decimaal punt) moet het resultaat bevatten: Als er geen argument is gedefinieerd voor toFixed(), wordt dit standaard ingesteld gelijk aan nul

, wat 0 decimalen betekent, heeft het argument

maximale waarde
Zowel de methoden toFixed() als toPrecision() retourneren een tekenreeksrepresentatie van het resultaat, geen getal. Dit betekent dat bij het optellen van een afgeronde waarde met randNum er een aaneenschakeling van tekenreeksen ontstaat in plaats van een som van getallen:

Stel randNum = 6,25; laat afgerond = randNum.toFixed(); // "6" console.log(randNum + afgerond); > "6.256"
Als je wilt dat het resultaat zo is numeriek type gegevens, dan moet u parseFloat toepassen:

Stel randNum = 6,25; laat afgerond = parseFloat(randNum.toFixed(1)); console.log(afgerond); > 6.3
Houd er rekening mee dat waarden van 5 worden afgerond, behalve in zeldzame gevallen.

De methoden toFixed() en toPrecision() zijn handig omdat ze niet alleen kunnen knippen fractioneel deel, maar ook om decimalen toe te voegen, wat handig is bij het werken met valuta:

Laat WholeNum = 1 laat dollarsCents = WholeNum.toFixed(2); console.log(dollarscent); > "1,00"
Merk op dat toPrecision het resultaat in wetenschappelijke notatie zal opleveren als het aantal gehele getallen groter is dan de precisie zelf:

Laat num = 123,435 num.toPrecision(2); > "1.2e+2"

Afrondingsfouten met decimalen voorkomen In sommige gevallen rondt toFixed en toPrecision de waarde 5 naar beneden en naar boven af:

Laat numTest = 1,005; numTest.toFixed(2); > "1,00"
Het resultaat van de bovenstaande berekening had 1,01 moeten zijn, en niet 1. Als je een soortgelijke fout wilt voorkomen, kunnen we de oplossing gebruiken die is voorgesteld door Jack L Moore, die exponentiële getallen gebruikt voor de berekening:

Functie round(waarde, decimalen) ( return Number(Wiskunde.round(waarde+"e"+decimalen)+"e-"+decimalen); )
Nu:

Rond(1.005,2); > 1,01
Als u een robuustere oplossing wilt dan hierboven weergegeven, kunt u naar MDN gaan.

Machine-epsilon-afronding In ES6 werd een alternatieve methode voor het afronden van decimale getallen geïntroduceerd. Machine-epsilon-afronding biedt een redelijke foutmarge bij het vergelijken van twee drijvende-kommagetallen. Zonder afronding kunnen vergelijkingen soortgelijke resultaten opleveren:

0,1 + 0,2 === 0,3 > onwaar
We gebruiken Math.EPSILON in onze functie om een geldige vergelijking te krijgen:

Functie epsEqu(x, y) ( retourneert Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
De functie heeft twee argumenten nodig: het eerste is de huidige berekening, het tweede is het verwachte resultaat. Het retourneert een vergelijking van de twee:

EpsEqu(0,1 + 0,2, 0,3) > waar
Alle moderne browsers ondersteunen al ES6 wiskundige functies maar als je ondersteuning wilt in browsers zoals IE 11, gebruik dan polyfills.

Het breukgedeelte afsnijden Alle hierboven gepresenteerde methoden kunnen worden afgerond op decimale getallen. Om een getal eenvoudigweg terug te brengen tot twee decimalen, moet u het eerst vermenigvuldigen met 100 en vervolgens het resulterende resultaat delen door 100:

Functie afgekapt(num) ( return Math.trunc(num * 100) / 100; ) afgekapt(3,1416) > 3,14
Als u de methode wilt aanpassen aan een willekeurig aantal decimalen, kunt u bitsgewijze dubbele ontkenning gebruiken:

Functie afgekapt(num, decimalPlaces) ( let numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Nu:

Laat randInt = 35,874993; afgekapt(randInt,3); > 35,874

Afronding naar het dichtstbijzijnde getal Om een decimaal getal naar boven of beneden af te ronden naar het dichtstbijzijnde getal, afhankelijk van wat we het dichtst in de buurt hebben, gebruikt u Math.round():

Rekenronde(4.3) > 4 Rekenronde(4.5) > 5
Houd er rekening mee dat "de helft van de waarde", 0,5, wordt afgerond naar grote kant volgens de regels van de wiskunde.

Naar beneden afronden op het dichtstbijzijnde gehele getal Als u altijd naar beneden wilt afronden, gebruikt u Math.floor:

Wiskundevloer(42.23); > 42 Wiskundevloer(36.93); > 36
Houd er rekening mee dat naar beneden afronden voor alle getallen geldt, ook voor negatieve getallen. Stel je een wolkenkrabber voor met een oneindig aantal verdiepingen, inclusief verdiepingen op het onderste niveau (die negatieve getallen vertegenwoordigen). Als je in een lift staat lager niveau tussen 2 en 3 (wat een waarde van -2,5 vertegenwoordigt), brengt Math.floor je naar -3:

Wiskundevloer(-2,5); > -3
Maar als u deze situatie wilt vermijden, gebruikt u Math.trunc, dat in alle gevallen wordt ondersteund moderne browsers(behalve IE/Edge):

Wiskunde.trunc(-41.43); > -41
Op MDN vindt u een polyfill die ondersteuning biedt voor Math.trunc in browsers en IE/Edge.

Naar boven afronden op het dichtstbijzijnde gehele getal Als u daarentegen altijd naar boven wilt afronden, gebruikt u Math.ceil. Nogmaals, onthoud de oneindige lift: Math.ceil gaat altijd "omhoog", ongeacht of het getal negatief is of niet:

Math.ceil(42.23); > 43 Wiskundig plafond(36,93); > 37 Math.ceil(-36.93); > -36

Naar boven/beneden afronden naar het benodigde getal Als we willen afronden naar het dichtstbijzijnde veelvoud van 5, is de eenvoudigste manier om een functie te maken die het getal door 5 deelt, het rondt en vervolgens met hetzelfde bedrag vermenigvuldigt:

Functie roundTo5(num) ( retourneert Math.round(num/5)*5; )
Nu:

RondTo5(11); > 10
Als u wilt afronden op veelvouden van uw waarde, gebruiken we meer algemene functie, waarbij de beginwaarde en een veelvoud erin worden doorgegeven:

Functie roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )
Nu:

Laat aanvankelijk getal = 11; laat meerdere = 10; roundToMultiple(beginnummer, meerdere); > 10;

Een getal in een bereik vaststellen Er zijn veel gevallen waarin we een waarde van x willen verkrijgen die binnen een bereik ligt. We hebben bijvoorbeeld misschien een waarde tussen 1 en 100 nodig, maar uiteindelijk kwamen we uit op een waarde van 123. Om dit op te lossen, kunnen we min (retourneert de kleinste van een reeks getallen) en max (retourneert de grootste van een reeks getallen) gebruiken. van cijfers). In ons voorbeeld loopt het bereik van 1 tot 100:

Laat ondergrens = 1; laat bovengrens = 100; laat numInput = 123; laat vastgeklemd = Math.max(lowBound, Math.min(numInput, highBound)); console.log (geklemd); > 100;
Nogmaals, we kunnen de bewerking opnieuw gebruiken en het geheel in een functie verpakken, met behulp van de oplossing voorgesteld door Daniel X. Moore:

Number.prototype.clamp = function(min, max) ( return Math.min(Math.max(this, min), max); );
Nu:

NumInput.clamp(ondergrens, bovengrens); > 100;

Gaussiaanse afronding Bij Gaussiaanse afronding, ook bekend als bankiersafronding, wordt in dit geval afgerond naar het dichtstbijzijnde even getal. Deze afrondingsmethode werkt zonder statistische fouten. De beste oplossing werd voorgesteld door Tim Down:

Functie gaussRound(num, decimalPlaces) ( let 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; }
Nu:

GaussRond(2,5) > 2 gaussRond(3,5) > 4 gaussRond(2,57,1) > 2,6
Decimaal in CSS:

Omdat JavaScript vaak wordt gebruikt om positionele mappings voor HTML-elementen te maken, vraag je je misschien af wat er zou gebeuren als we decimale waarden voor onze elementen zouden genereren:

#box ( breedte: 63.667731993px; )
Het goede nieuws is dat moderne browsers decimale waarden in het blokmodel zullen respecteren, inclusief percentage- of pixeleenheden.

Sorteren Heel vaak moeten we bepaalde elementen sorteren. We hebben bijvoorbeeld een reeks spelrecords en deze moeten worden georganiseerd in aflopende volgorde van spelersrang. Helaas, standaard methode sort() heeft een aantal verrassende beperkingen: het werkt goed met gewone Engelse woorden, maar valt onmiddellijk uit elkaar als het cijfers, unieke tekens of woorden tegenkomt in hoofdletter. Sorteer op alfabetische volgorde Het lijkt erop dat het alfabetisch sorteren van een array een eenvoudige taak zou moeten zijn:

Let fruit = ["pompoen", "abrikoos", "meloen"]; fruit.sort(); > "abrikoos", "pompoen", "meloen"]
We komen echter een probleem tegen zodra een van de elementen in hoofdletters staat:

Let fruit = ["pompoen", "abrikoos", "Cantalope"]; fruit.sort(); > "Cantaloupe", "abrikoos", "pompoen"]
Dit komt omdat de sorteerder standaard het eerste teken vergelijkt dat in Unicode wordt weergegeven. Unicode is een unieke code voor elk personage, ongeacht het platform, ongeacht het programma, ongeacht de taal. Als u bijvoorbeeld naar de codetabel kijkt, heeft het teken “a” de waarde U+0061 (in hexadecimaal systeem 0x61), terwijl het teken "C" de code U+0043 (0x43) heeft, die eerder in de Unicode-tabel voorkomt dan het teken "a".

Om een array te sorteren die hoofdletters met gemengde hoofdletters kan bevatten, moeten we alle elementen tijdelijk converteren naar kleine letters, of definieer uw eigen sorteervolgorde met behulp van de localeCompare() methode met enkele argumenten. In een dergelijk geval is het in de regel beter om onmiddellijk een functie te creëren voor herhaald gebruik:

Functie alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("gevoeligheid": "basis")); )); ) let fruit = ["pompoen ", "abrikoos", "meloen"]; alphaSort(fruit) >
Als u de array in omgekeerde alfabetische volgorde wilt sorteren, verwisselt u eenvoudigweg de posities van a en b in de functie:

Functie alphaSort(arr) ( arr.sort(function (a, b) ( return b.localeCompare(a, "en", ("gevoeligheid": "basis")); )); ) let fruit = ["pompoen ", "abrikoos", "meloen"]; alphaSort(fruit) > ["Cantaloupe", "pompoen", "abrikoos"]
Hier is het vermeldenswaard dat localeCompare wordt gebruikt met argumenten, we moeten ook onthouden dat het wordt ondersteund door IE11+, voor oudere versies van IE kunnen we het zonder argumenten gebruiken, en in kleine letters:

Functie caseSort(arr) ( arr.sort(function (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) let fruit = ["pompoen", "abrikoos", "meloen"]; caseSort(fruit) > ["abrikoos", "pompoen", "meloen"]

Numeriek sorteren Dit alles is niet van toepassing op het voorbeeld waar we het hierboven over hadden over de reeks spelrecords. Met sommigen numerieke arrays sorteren werkt gewoon perfect, maar op een gegeven moment kan het resultaat onvoorspelbaar zijn:

Laat highScores = ; hogeScores.sort(); >
Het punt is dat de sort()-methode een lexicografische vergelijking uitvoert: wat betekent dat de getallen worden omgezet in een string en dat de vergelijkingen opnieuw worden gemaakt door het eerste teken van die string te matchen in de volgorde van de tekens in de Unicode-tabel . Daarom moeten we opnieuw onze sorteervolgorde definiëren:

Laat highScores = ; highScores.sort(function(a,b) ( retourneert a - b; )); >
Nogmaals, om getallen in omgekeerde volgorde te sorteren, verwisselt u de posities van a en b in de functie.

Een JSON-achtige structuur sorteren Als we ten slotte een JSON-achtige datastructuur hebben die wordt weergegeven als een reeks spelrecords:

Laat scores = [ ( "naam": "Daniel", "score": 21768 ), ( "naam": "Michael", "score": 33579 ), ( "naam": "Alison", "score": 38395 ];
In ES6+ kunt u pijlfuncties gebruiken:

Scores.sort((a, b) => b.score - a.score));
Voor oudere browsers die deze ondersteuning niet hebben:

Scores.sort(functie(a, b) ( retourneer a.score - b.score ));
Zoals je kunt zien, is sorteren in JavaScript nogal obscuur. Ik hoop dat deze voorbeelden het leven op de een of andere manier gemakkelijker zullen maken.

Werken met machtsfuncties Machtsverheffing is een bewerking die oorspronkelijk werd gedefinieerd als het resultaat van het herhaaldelijk vermenigvuldigen van een natuurlijk getal met zichzelf; We zouden deze functies voortdurend kunnen gebruiken het dagelijks leven in wiskundelessen, inclusief het berekenen van gebieden, volumes of zelfs fysieke modellering.

In JavaScript wordt de machtsfunctie weergegeven als Math.pow(), in de nieuwe ES7-standaard werd deze geïntroduceerd nieuwe exploitant machtsverheffen - " * * ".

Verheffen tot een macht Om een getal tot de macht nde te verheffen, gebruikt u de functie Math.pow(), waarbij het eerste argument het getal is dat tot de macht wordt verheven, en het tweede argument de exponent:

Wiskunde.pow(3,2) > 9
Deze notatievorm betekent 3 kwadraat, oftewel 3×3, wat leidt tot het resultaat 9. Er kan uiteraard nog een ander voorbeeld worden gegeven:

Wiskunde.pow(5,3); > 125
Dat wil zeggen, 5 in blokjes, of 5 × 5 × 5, is gelijk aan 125.

ECMAScript 7 is de volgende JavaScript-versie In principe kunnen we de nieuwe voorgestelde machtsverheffingsoperator gebruiken - * *, deze vorm van notatie kan beschrijvender zijn:

3 ** 2 > 9
Op op dit moment Ondersteuning voor deze operator is vrij beperkt, dus het gebruik ervan wordt niet aanbevolen.

De power-functie kan in verschillende situaties nuttig zijn. Een eenvoudig voorbeeld, het berekenen van het aantal seconden in een uur: Math.pow (60,2).

Vierkantswortel en derdemachtswortel Math.sqrt() en Math.cbrt() zijn het tegenovergestelde van Math.pow(). Zoals we ons herinneren, is de vierkantswortel van a het getal dat a geeft in het kwadraat.

Wiskunde.sqrt(9) > 3
Tegelijkertijd is de derdemachtswortel van a een getal dat a geeft als het wordt verheven tot een kubus.

Math.cbrt(125) > 5
Math.cbrt() is pas onlangs geïntroduceerd in de JavaScript-specificatie en wordt daarom alleen ondersteund in moderne browsers: Chrome 38+, Firefox en Opera 25+ en Safari 7.1+. Dat zul je merken Internet Explorer staat niet op deze lijst, maar je vindt een polyfill op MDN.

Voorbeelden Natuurlijk kunnen we niet-gehele waarden gebruiken in een van deze functies:

Wiskunde.pow(1,25, 2); > 1,5625 Math.cbrt(56,57) > 3,8387991760286138
Houd er rekening mee dat dit ook redelijk goed werkt bij het gebruik van negatieve argumentwaarden:

Wiskunde.pow(-5,2) > 25 Wiskunde.pow(10,-2) > 0,01
Dit werkt echter niet voor vierkantswortel:

Wiskunde.sqrt(-9) > NaN
Van wiskundige analyse We weten dat we met denkbeeldig getal de vierkantswortels van negatieve getallen bedoelen. En dit kan ons leiden naar een andere techniek om mee te werken complexe getallen, maar dat is een ander verhaal.

Je kunt fractionele waarden gebruiken in Math.pow() om vierkante en te vinden kubus wortels cijfers. Vierkantswortel gebruikt exponent 0,5:

Wiskunde.pow(5, 0,5); // = Math.sqrt(5) = 5 ** (1/2) > 2,23606797749979
Vanwege de grillen van drijvende komma kun je het juiste resultaat echter niet precies raden:

Wiskunde.pow(2,23606797749979,2) > 5,000000000000001
In dergelijke situaties zult u uw toevlucht moeten nemen tot het afsnijden van tekens van het getal of het afronden naar een bepaalde waarde.

Sommige mensen verwarren om onbekende redenen in JavaScript de functie Math.pow() met Math.exp() , wat de exponentiële functie is voor getallen in het algemeen. Let op: binnen Engels"exponent" wordt vertaald als "exponent", dus dit is waarschijnlijker van toepassing op Engelssprekenden, hoewel er alternatieve namen voor exponent zijn, zoals index, macht.

Wiskundige constanten Werken met wiskunde in JavaScript wordt eenvoudiger gemaakt door een aantal ingebouwde constanten. Deze constanten zijn eigenschappen van het Math-object. Het is vermeldenswaard dat constanten in hoofdletters worden geschreven en niet in de CamelCase-notatie.

Alleen geregistreerde gebruikers kunnen deelnemen aan het onderzoek. , Alsjeblieft.

Tags: Tags toevoegen Heel vaak geven berekeningen in JavaScript niet precies de gewenste resultaten. Natuurlijk kunnen we met getallen doen wat we willen: naar boven of naar beneden afronden, bereiken instellen, onnodige getallen afsnijden tot een bepaald aantal decimalen, het hangt allemaal af van wat je in de toekomst met dit getal wilt doen.

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
varmax = 5;

Waarom is afronding nodig?

Een van de interessante aspecten van JavaScript is dat het eigenlijk geen gehele getallen opslaat; we werken meteen met drijvende-kommagetallen. Dit, gecombineerd met het feit dat veel fractionele waarden niet in een eindig aantal decimalen kunnen worden uitgedrukt, kunnen we in JavaScript de volgende resultaten krijgen:

Het afronden van getallen heeft praktische toepassingen. We kunnen een getal binnen een bepaald bereik manipuleren. We willen bijvoorbeeld een waarde afronden naar het dichtstbijzijnde gehele getal in plaats van alleen met het decimale deel te werken.

, wat 0 decimalen betekent, heeft het argument

Stel randNum = 6,25; laat afgerond = randNum.toFixed(); // "6" console.log(randNum + afgerond); > "6.256"
Decimalen afronden Om een decimaal af te ronden, gebruikt u de methode toFixed of toPrecision. Beiden gebruiken één argument dat respectievelijk specificeert hoeveel significante cijfers (dat wil zeggen het totale aantal cijfers dat in het getal wordt gebruikt) of decimalen (het getal na de komma) het resultaat moet bevatten:

Stel randNum = 6,25; laat afgerond = parseFloat(randNum.toFixed(1)); console.log(afgerond); > 6.3
Houd er rekening mee dat waarden van 5 worden afgerond, behalve in zeldzame gevallen.

Als er geen argument is gedefinieerd voor toFixed(), wordt het standaard ingesteld op nul, wat betekent dat er 0 cijfers achter de komma staan. Het argument heeft een maximale waarde van 20.

Laat num = 123,435 num.toPrecision(2); > "1.2e+2"

Afrondingsfouten met decimalen voorkomen In sommige gevallen rondt toFixed en toPrecision de waarde 5 naar beneden en naar boven af:

Functie round(waarde, decimalen) ( return Number(Wiskunde.round(waarde+"e"+decimalen)+"e-"+decimalen); )
Nu:

Rond(1.005,2); > 1,01
Als u een robuustere oplossing wilt dan hierboven weergegeven, kunt u naar MDN gaan.

0,1 + 0,2 === 0,3 > onwaar
We gebruiken Math.EPSILON in onze functie om een geldige vergelijking te krijgen:

EpsEqu(0,1 + 0,2, 0,3) > waar
Als u wilt dat het resultaat een numeriek gegevenstype is, moet u parseFloat gebruiken:

Functie afgekapt(num, decimalPlaces) ( let numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Nu:

Laat randInt = 35,874993; afgekapt(randInt,3); > 35,874

Rekenronde(4.3) > 4 Rekenronde(4.5) > 5
De methoden toFixed() en toPrecision() zijn handig omdat ze niet alleen het breukgedeelte kunnen afsnijden, maar ook decimalen kunnen toevoegen, wat handig is bij het werken met valuta:

Naar beneden afronden op het dichtstbijzijnde gehele getal Als u altijd naar beneden wilt afronden, gebruikt u Math.floor:

Wiskundevloer(42.23); > 42 Wiskundevloer(36.93); > 36
Houd er rekening mee dat naar beneden afronden voor alle getallen geldt, ook voor negatieve getallen. Stel je een wolkenkrabber voor met een oneindig aantal verdiepingen, inclusief verdiepingen op het onderste niveau (die negatieve getallen vertegenwoordigen). Als je in een lift zit op het laagste niveau tussen 2 en 3 (wat een waarde van -2,5 vertegenwoordigt), brengt Math.floor je naar -3:

Wiskundevloer(-2,5); > -3
Maar als je deze situatie wilt vermijden, gebruik dan Math.trunc, ondersteund in alle moderne browsers (behalve IE/Edge):

Wiskunde.trunc(-41.43); > -41
Op MDN vindt u een polyfill die ondersteuning biedt voor Math.trunc in browsers en IE/Edge.

Math.ceil(42.23); > 43 Wiskundig plafond(36,93); > 37 Math.ceil(-36.93); > -36

Functie roundTo5(num) ( retourneert Math.round(num/5)*5; )
Nu:

RondTo5(11); > 10
Als u wilt afronden op veelvouden van uw waarde, gebruiken we een meer algemene functie, waarbij we de beginwaarde en het veelvoud doorgeven:

Functie roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )
Nu:

Laat aanvankelijk getal = 11; laat meerdere = 10; roundToMultiple(beginnummer, meerdere); > 10;

Number.prototype.clamp = function(min, max) ( return Math.min(Math.max(this, min), max); );
Nu:

NumInput.clamp(ondergrens, bovengrens); > 100;

GaussRond(2,5) > 2 gaussRond(3,5) > 4 gaussRond(2,57,1) > 2,6
Decimaal in CSS:

Omdat JavaScript vaak wordt gebruikt om positionele mappings voor HTML-elementen te maken, vraag je je misschien af wat er zou gebeuren als we decimale waarden voor onze elementen zouden genereren:

#box ( breedte: 63.667731993px; )
Het goede nieuws is dat moderne browsers decimale waarden in het blokmodel zullen respecteren, inclusief percentage- of pixeleenheden.

Sorteren Heel vaak moeten we bepaalde elementen sorteren. We hebben bijvoorbeeld een reeks spelrecords en deze moeten worden georganiseerd in aflopende volgorde van spelersrang. Helaas heeft de standaardmethode sort() een aantal verrassende beperkingen: deze werkt goed met gewone Engelse woorden, maar valt onmiddellijk uiteen als er cijfers, unieke tekens of hoofdletters worden aangetroffen. Alfabetisch sorteren Het lijkt erop dat het alfabetisch sorteren van een array een eenvoudige taak zou moeten zijn:

Let fruit = ["pompoen", "abrikoos", "meloen"]; fruit.sort(); > "abrikoos", "pompoen", "meloen"]
We komen echter een probleem tegen zodra een van de elementen in hoofdletters staat:

Let fruit = ["pompoen", "abrikoos", "Cantalope"]; fruit.sort(); > "Cantaloupe", "abrikoos", "pompoen"]
Dit komt omdat de sorteerder standaard het eerste teken vergelijkt dat in Unicode wordt weergegeven. Unicode is een unieke code voor elk personage, ongeacht het platform, ongeacht het programma, ongeacht de taal. Als je bijvoorbeeld naar de codetabel kijkt, heeft het teken "a" de waarde U+0061 (in hexadecimaal 0x61), terwijl het teken "C" de code U+0043 (0x43) heeft, die eerder voorkomt in de Unicode-versie. tabel dan het teken "a".

Om een array te sorteren die beginletters met gemengde hoofdletters kan bevatten, moeten we alle elementen tijdelijk naar kleine letters converteren, of onze sorteervolgorde definiëren met behulp van de localeCompare() methode met enkele argumenten. In een dergelijk geval is het in de regel beter om onmiddellijk een functie te creëren voor herhaald gebruik:

Numeriek sorteren Dit alles is niet van toepassing op het voorbeeld waar we het hierboven over hadden over de reeks spelrecords. Bij sommige numerieke arrays werkt sorteren prima, maar op een gegeven moment kan het resultaat onvoorspelbaar zijn:

Laat highScores = ; highScores.sort(function(a,b) ( retourneert a - b; )); >
Nogmaals, om getallen in omgekeerde volgorde te sorteren, verwisselt u de posities van a en b in de functie.

Een JSON-achtige structuur sorteren Als we ten slotte een JSON-achtige datastructuur hebben die wordt weergegeven als een reeks spelrecords:

Laat scores = [ ( "naam": "Daniel", "score": 21768 ), ( "naam": "Michael", "score": 33579 ), ( "naam": "Alison", "score": 38395 ];
In ES6+ kunt u pijlfuncties gebruiken:

Scores.sort((a, b) => b.score - a.score));
Voor oudere browsers die deze ondersteuning niet hebben:

Werken met machtsfuncties Machtsverheffing is een bewerking die oorspronkelijk werd gedefinieerd als het resultaat van het herhaaldelijk vermenigvuldigen van een natuurlijk getal met zichzelf; We zouden deze functies in het dagelijks leven voortdurend kunnen gebruiken in wiskundelessen, ook bij het berekenen van gebieden, volumes of zelfs bij fysieke modellering.

In JavaScript wordt de machtsfunctie weergegeven als Math.pow(), en in de nieuwe ES7-standaard is een nieuwe machtsverheffingsoperator geïntroduceerd - " * * ".

Wiskunde.pow(3,2) > 9
Deze notatievorm betekent 3 kwadraat, oftewel 3×3, wat leidt tot het resultaat 9. Er kan uiteraard nog een ander voorbeeld worden gegeven:

Wiskunde.pow(5,3); > 125
Dat wil zeggen, 5 in blokjes, of 5 × 5 × 5, is gelijk aan 125.

ECMAScript 7 is de volgende versie van JavaScript. In principe kunnen we de nieuwe voorgestelde machtsverheffingsoperator gebruiken - * *, deze vorm van notatie kan beschrijvender zijn:

3 ** 2 > 9
Op dit moment is de ondersteuning voor deze operator vrij beperkt, dus het wordt niet aanbevolen om deze te gebruiken.

De power-functie kan in verschillende situaties nuttig zijn. Een eenvoudig voorbeeld, het berekenen van het aantal seconden in een uur: Math.pow (60,2).

Vierkantswortel en derdemachtswortel Math.sqrt() en Math.cbrt() zijn het tegenovergestelde van Math.pow(). Zoals we ons herinneren, is de vierkantswortel van a het getal dat a geeft in het kwadraat.

Wiskunde.sqrt(9) > 3
Tegelijkertijd is de derdemachtswortel van a een getal dat a geeft als het wordt verheven tot een kubus.

Math.cbrt(125) > 5
Math.cbrt() is pas onlangs geïntroduceerd in de JavaScript-specificatie en wordt daarom alleen ondersteund in moderne browsers: Chrome 38+, Firefox en Opera 25+ en Safari 7.1+. U zult merken dat Internet Explorer niet op deze lijst staat, maar u zult een polyfill op MDN vinden.

Voorbeelden Natuurlijk kunnen we niet-gehele waarden gebruiken in een van deze functies:

Wiskunde.pow(1,25, 2); > 1,5625 Math.cbrt(56,57) > 3,8387991760286138
Houd er rekening mee dat dit ook redelijk goed werkt bij het gebruik van negatieve argumentwaarden:

Wiskunde.pow(-5,2) > 25 Wiskunde.pow(10,-2) > 0,01
Dit werkt echter niet voor vierkantswortel:

Wiskunde.sqrt(-9) > NaN
Uit wiskundige analyse weten we dat een denkbeeldig getal verwijst naar de vierkantswortels van negatieve getallen. En dit kan ons leiden naar een andere techniek voor het werken met complexe getallen, maar dat is een ander verhaal.

Je kunt breuken in Math.pow() gebruiken om de vierkants- en derdemachtswortels van getallen te vinden. Vierkantswortel gebruikt een exponent van 0,5:

Wiskunde.pow(5, 0,5); // = Math.sqrt(5) = 5 ** (1/2) > 2,23606797749979
Vanwege de grillen van drijvende komma kun je het juiste resultaat echter niet precies raden:

Wiskunde.pow(2,23606797749979,2) > 5,000000000000001
In dergelijke situaties zult u uw toevlucht moeten nemen tot het afsnijden van tekens van het getal of het afronden naar een bepaalde waarde.

Sommige mensen verwarren om onbekende redenen in JavaScript de functie Math.pow() met Math.exp() , wat de exponentiële functie is voor getallen in het algemeen. Opmerking: in het Engels wordt "exponent" vertaald als "exponent", dus dit is waarschijnlijker van toepassing op Engelssprekenden, hoewel er alternatieve namen voor exponent zijn, zoals index, macht.

Alleen geregistreerde gebruikers kunnen deelnemen aan het onderzoek. Meld u aan.

Tags:

javascript
wiskunde

Tags toevoegen

Technisch gezien is de term 'generator voor willekeurige getallen' onzin, aangezien getallen zelf niet willekeurig zijn. Is 100 bijvoorbeeld een willekeurig getal? Hoe zit het met 25? Wat deze term eigenlijk betekent, is dat er een reeks getallen ontstaat die willekeurig verschijnen. Dit roept een moeilijkere vraag op: wat is een reeks willekeurige getallen? Het enige juiste antwoord: een reeks willekeurige getallen is een reeks waarin alle elementen geen verband houden. Deze definitie leidt tot de paradox dat elke reeks willekeurig of niet-willekeurig kan zijn, afhankelijk van hoe de reeks wordt verkregen. Bijvoorbeeld, volgende regel cijfers
1 2 3 4 5 6 7 8 9 0
werd ontvangen door middel van afdrukken bovenste regel toetsenborden op volgorde, zodat de reeks niet als willekeurig gegenereerd kan worden beschouwd. Maar wat als je dezelfde volgorde krijgt als je de genummerde tennisballen uit de ton haalt? IN in dit geval dit is al een willekeurig gegenereerde reeks. Dit voorbeeld laat zien dat de willekeur van een reeks afhangt van hoe deze is verkregen, en niet van zichzelf.

Bedenk dat een door de computer gegenereerde reeks getallen deterministisch is: elk getal, behalve het eerste, hangt af van de getallen ervoor. Technisch gezien betekent dit dat alleen een quasi-willekeurige reeks getallen door een computer kan worden gegenereerd, d.w.z. in feite zijn ze niet echt willekeurig. Dit is echter voldoende voor de meeste taken en voor de eenvoud zullen dergelijke reeksen willekeurig worden genoemd. Een zeer interessante methode werd ontwikkeld door John von Neumann; het wordt vaak het root mean square genoemd. Bij deze methode wordt het vorige willekeurige getal gekwadrateerd en worden vervolgens de middelste cijfers uit het resultaat gehaald. Als u bijvoorbeeld getallen maakt met drie cijfers en het vorige getal was 121, geeft het kwadrateren van het resultaat het resultaat 14641. Het kwadrateren van de middelste drie cijfers levert het volgende willekeurige getal 464 op. Het nadeel van deze methode is dat deze een zeer korte herhalingsperiode, een zogenaamde cyclus. Om deze reden deze methode vandaag niet gebruikt. Moderne methoden Het genereren van willekeurige getallen is veel moeilijker.

Willekeurige getallen in PHP

PHP heeft twee groepen functies voor het werken met willekeurige getallen. Puur extern kunnen ze worden onderscheiden door het voorvoegsel mt_ voor alle functies van een van de groepen.

Verouderde functies
rand-functie Retourneert een geheel getal tussen nul en de waarde van RAND_MAX (dit is 32767). Kan twee optionele gehele parameters hebben. Als deze zijn opgegeven, wordt er een willekeurig getal gegenereerd van de eerste parameter naar de tweede.

Echo-rand(); echorand(1.100); // Geef een willekeurig getal van 1 tot 100

Functie streng. Specificeert de reeks willekeurige getallen die door de randfunctie worden geproduceerd. Heeft een hele parameter - wanneer verschillende betekenissen Met deze parameter produceert rand verschillende reeksen getallen. De srand-functie hoeft slechts één keer te worden aangeroepen voordat alle oproepen naar de rand-functie plaatsvinden. Gebruiksvoorbeeld:

Srand(1288); // Initialiseer de generator voor willekeurige getallen voor($i=0; $i