Näiteid on mitu:
/** * Tagastab juhusliku arvu min (kaasa arvatud) ja max (välja arvatud) vahel */ funktsioon getRandomArbitrary(min, max) ( return Math.random() * (max - min) + min; ) /** * Tagastab juhuslik täisarv vahemikus min (kaasa arvatud) ja max (kaasa arvatud). * Väärtus ei ole väiksem kui min (või järgmine täisarv, mis on suurem kui min *, kui min ei ole täisarv) ega suurem kui max (või järgmine täisarv * väiksem kui max, kui max ei ole täisarv). * Math.round() kasutamine annab ebaühtlase jaotuse! */ funktsioon getRandomInt(min, max) ( min = Math.ceil(min); max = Math.floor(max); return Math.floor(Math.random() * (max - min + 1)) + min; )
Siin on selle loogika. See on lihtne reegel kolmest:
Math.random() tagastab arvu vahemikus 0 (kaasa arvatud) kuni 1 (välja arvatud). Nii et meil on selline intervall:
Siis on teie vastus korrus n * 10 ja kui vajate, siis korrus n * 100 on teie vastus jne.
Nüüd sisestage oma roll:
Olete taotlenud numbreid teatud vahemik. (Sel juhul olete selles vahemikus kallutatud. - Kui võtate numbrist , viskate täringut, kaldute teid poole, kuid see on siiski juhuslik juhtum siis ja ainult siis, kui surm on erapooletu.)
Seega võtame arvesse teie vahemikku ==> vahemiku elementide arv = 247 - 78 + 1 = 170; (kuna mõlemad äärised on kaasatud.
/*Meetod 1:*/ var i = 78, j = 247, k = 170, a = , b = , c, d, e, f, l = 0; for(; i 20) ( bool = true; ) else ( bool = false; ) ) tagastab numbri; )
Siin on MS DotNet Implementing Random klass javascriptis -
Muutuja Random = (funktsioon () ( funktsioon Random(Seed) ( if (!Seed) ( Seed = see.millisekundid(); ) 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) ( arv = 1; ) if (++num2 >= 56) ( num2 = 1; ) var num3 = this.SeedArray - see.SeedArray; if (arv3 == 2147483647) ( number3--; ) if (arv3< 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("kast").innerHTML = juhuslik_arv; )
Juhusliku arvu saamiseks, öelge 1 ja 6 vahel, tehke esmalt:
0,5 + (Math.random() * ((6 - 1) + 1))
See korrutab juhusliku arvu 6-ga ja lisab sellele 0,5. Seejärel ümardage arv positiivse täisarvuni, toimides järgmiselt.
Math.round(0,5 + (Math.random() * ((6 - 1) + 1))
See ümardab arvu lähima täisarvuni.
Muutuse väärtus = 0,5 + (Math.random() * ((6 - 1) + 1)) var roll = Math.round(väärtus); tagastusrull;
Üldiselt on selle muutujate kood järgmine:
Muutuse väärtus = (Min - 0,5) + (Math.random() * ((Max - Min) + 1)) var roll = Math.round(väärtus); tagastusrull;
Põhjusest lahutada 0,5 minimaalne väärtus on see, et ainult minimaalse väärtuse kasutamine võimaldab teil saada täisarvu, mis on suurem kui teie maksimaalne väärtus. Kui eemaldate minimaalsest väärtusest 0,5, takistate sisuliselt maksimaalse väärtuse ümardamist.
Loodan, et see aitab.
Juhuslik täisarv madalaima ja kõrgeima vahel:
Funktsioon randomRange(l,h)(var range = (h-l); var random = Math.floor(Math.random()*range);if (juhuslik === 0)(juhuslik+=1;) tagastab l+juhuslik; )
Mitte kõige parem elegantne lahendus.. aga midagi kiiret.
Siin ma kasutan genereerimiseks juhuslikud arvud.
Funktsioon juhuslik(kõrge,madal) ( kõrge++; tagasta Math.floor((Math.random())*(kõrge-madal))+madal; )
Me teeme high++, sest Math.random() genereerib juhusliku arvu vahemikus 0 (kaasa arvatud) kuni 1 (välja arvatud). Elimineeritud tähendab, et enne matemaatika tegemist peame maksimumi ühe võrra suurendama. Seejärel lahutame madala väärtuse kõrgest väärtusest, andes meile suurim arv põlvkonna jaoks - madal, siis + madal, mis naaseb normaalseks ja teeb väikseima numbri võrra vähemalt madal. siis tagastame saadud arvu
juhuslik (7, 3) võib tagastada 3, 4, 5, 6 või 7
/* eeldades, et window.crypto.getRandomValues on saadaval, oleks tegelik vahemik 0 kuni 1998, mitte 0 kuni 2000. Vaadake selgitust JavaScripti dokumentatsioonist https://developer.mozilla.org/en-US/docs/Web/ API/ RandomSource/getRandomValues*/ var array = new Uint8Array(2); window.crypto.getRandomValues(massiiv); console.log(massiiv + massiiv);
Uint8Array loob massiivi, mis on täidetud kuni kolme numbriga, mis ei tohi olla suurem kui 999. See kood on väga lühike.
Funktsioon getRandomInt(alumine, ülemine) ( //ühtlase valimijaotuse loomiseks tagastab Math.floor(lower + (Math.random() * (ülemine - alumine + 1))); //valimi ebaühtlase jaotuse loomiseks // return Math.round(lower + (Math.random() * (ülemine - alumine))) //maksimaalse väärtuse välistamiseks võimalikest väärtustest //return Math.floor(lower + (Math.random()); * ( ülemine alumine)));
Selle funktsiooni ja selle funktsiooni variatsioonide testimiseks salvestage allolev HTML/JavaScript faili ja avage see brauseris. Kood näitab graafikut, mis näitab ühe miljoni funktsioonikutse jaotust. Kood salvestab ka servajuhtumeid, nii et kui funktsioon annab väärtuse, mis on suurem kui max või väiksem kui min, siis tead.tead.about.it.
funktsioon getRandomInt(alumine, ülemine) ( //ühtlase valimijaotuse loomiseks tagastab Math.floor(lower + (Math.random() * (ülemine - alumine + 1))); //valimi ebaühtlase jaotuse loomiseks // return Math.round(lower + (Math.random() * (ülemine - alumine))) //maksimaalse väärtuse välistamiseks võimalikest väärtustest //return Math.floor(lower + (Math.random()); * ( ülemine - alumine))); var max = 5; var array = new Array(); for(var i = 0; i 2012 funktsioon isEmpty(value)( return (väärtuse tüüp === "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 0.020000000000000004
0.3 - 0.1
> 0.19999999999999998
!}
Praktilistel eesmärkidel pole sellel ebatäpsusel tähtsust, meie puhul räägime kvintiljondikes olevast veast, kuid see võib mõnele pettumust valmistada. Mõnevõrra kummalisi tulemusi võime saada ka siis, kui töötame numbritega, mis tähistavad valuutasid, protsente või failisuurusi. Nende ebatäpsuste parandamiseks peame lihtsalt suutma tulemusi ümardada ja piisab kümnendkoha täpsuse määramisest.
Numbrite ümardamine on praktiline kasutamine, võime manipuleerida mõnes vahemikus oleva arvuga, näiteks tahame ümardada väärtuse lähima täisarvuni, mitte töötada ainult kümnendosaga.
Kümnendarvude ümardamine Lõikamiseks kümnendnumber, kasutage meetodit toFixed või toPrecision. Mõlemad võtavad ühe argumendi, mis määrab vastavalt, kui palju märkimisväärsed arvud(st numbris kasutatud numbrite koguarv) või kümnendkohad (arv pärast koma) peaks sisaldama tulemust:Nii meetod toFixed() kui ka toPrecision() tagastavad tulemuse stringi, mitte arvu. See tähendab, et kui summeerida ümardatud väärtus randNumiga, tekitab see pigem stringide konkatenatsiooni kui arvude summa:
Olgu randNum = 6,25; olgu ümardatud = randNum.toFixed(); // "6" konsool.log(randNum + ümardatud); > "6.256"
Kui soovite, et tulemus oleks numbriline tüüp andmeid, siis peate rakendama parseFloati:
Olgu randNum = 6,25; olgu ümardatud = parseFloat(randNum.toFixed(1)); konsool.log(ümardatud); > 6.3
Pange tähele, et väärtused 5 on ümardatud, välja arvatud harvadel juhtudel.
Meetodid toFixed() ja toPrecision() on kasulikud, kuna need ei saa ainult klippida murdosa, aga ka kümnendkohtade lisamiseks, mis on valuutaga töötamisel mugav:
Olgu koguarv = 1 olgu dollariSentide = terveArv.Fikseeritud(2); console.log(dollaridSentide); > "1.00"
Pange tähele, et toPrecision annab tulemuse teaduslikul kujul, kui täisarvude arv on suurem kui täpsus ise:
Olgu num = 123,435 num.toPrecision(2); > "1.2e+2"
Kuidas vältida kümnendkohtadega ümardamise vigu Mõnel juhul ümardatakse toFixed ja toPrecision väärtus 5 alla ja üles:Olgu numTest = 1,005; numTest.toFixed(2); > "1.00"
Ülaltoodud arvutuse tulemus oleks pidanud olema 1,01, mitte 1. Kui soovite sarnast viga vältida, võime kasutada Jack L Moore'i pakutud lahendust, mis kasutab arvutamisel eksponentsiaalarve:
Funktsiooni ring(väärtus, kümnendkohad) ( tagastab Arv(Math.round(väärtus+"e"+kümnendkohad)+"e-"+kümnendkohad); )
Nüüd:
Round(1,005,2); > 1.01
Kui soovite ülaltoodud lahendusest tugevamat lahendust, võite minna MDN-i.
0,1 + 0,2 === 0,3 > vale
Õige võrdluse saamiseks kasutame oma funktsioonis Math.EPSILON:
Funktsioon epsEqu(x, y) ( tagastab Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y));
}
Funktsioonil on kaks argumenti: esimene on praegune arvutus, teine on oodatav tulemus. See tagastab nende kahe võrdluse:
EpsEqu(0,1 + 0,2; 0,3) > tõene
Kõik kaasaegsed brauserid toetavad juba ES6 matemaatilised funktsioonid aga kui soovite tuge sellistes brauserites nagu IE 11, kasutage polütäiteid.
Funktsioon truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3,1416) > 3,14
Kui soovite kohandada meetodit suvalise arvu kümnendkohtadega, võite kasutada bitipõhist topelteitust:
Funktsioon kärbitud(arv, kümnendkohad) ( olgu numPowerConverter = Math.pow(10, decimalPlaces); tagasta ~~(num * numPowerConverter)/numPowerConverter; )
Nüüd:
Olgu randInt = 35,874993; kärbitud(randInt,3); > 35,874
Ümardamine lähima arvuni Kümnendarvu ümardamiseks lähima arvuni üles või alla, olenevalt sellest, kummale oleme kõige lähemal, kasutage Math.round():Matemaatika.ring(4.3) > 4 Matemaatika.ring(4.5) > 5
Pange tähele, et "pool väärtusest", 0,5 ümardatakse suur pool matemaatika reeglite järgi.
matemaatika.korrus(42,23); > 42 Math.floor(36.93); > 36
Pange tähele, et allapoole ümardamine töötab kõigi arvude, sealhulgas negatiivsete arvude puhul. Kujutage ette pilvelõhkujat, millel on lõpmatu arv korruseid, sealhulgas alumise tasandi korrused (esindavad negatiivseid numbreid). Kui olete liftis madalam tase vahemikus 2 kuni 3 (mis tähistab väärtust -2,5), viib Math.floor teid väärtuseni -3:
Math.korrus(-2,5); > -3
Kuid kui soovite seda olukorda vältida, kasutage Math.trunc , mida kõik toetavad kaasaegsed brauserid(välja arvatud IE/Edge):
Math.trunc(-41,43); > -41
MDN-is leiate polüfilli, mis toetab Math.trunc'i brauserites ja IE/Edge'is.
matemaatika.lagi(42,23); > 43 Math.ceil(36,93); > 37 Math.ceil(-36,93); > -36
Ümardamine üles/alla vajaliku arvuni Kui tahame ümardada 5 lähima kordseni, on lihtsaim viis luua funktsioon, mis jagab arvu 5-ga, ümardab selle ja seejärel korrutab sama summaga:Funktsioon roundTo5(num) ( return Math.round(num/5)*5; )
Nüüd:
RoundTo5(11); > 10
Kui soovite ümardada oma väärtuse kordseteks, kasutame rohkem üldine funktsioon, edastades sellele algväärtuse ja kordse:
Funktsioon roundToMultiple(arv, mitu) ( tagasta Math.round(arv/mitu)*mitmekordne; )
Nüüd:
Olgu esialgne arv = 11; olgu mitmekordne = 10; roundToMultiple(algnearv, mitu); > 10;
Arvu fikseerimine vahemikus On palju juhtumeid, kus tahame saada x väärtust, mis jääb vahemikku. Näiteks võib meil vaja minna väärtust vahemikus 1 kuni 100, kuid saime väärtuseks 123. Selle parandamiseks saame kasutada väärtusi min (tagastab arvude hulgast väikseima) ja max (tagastab arvudest suurima numbritest). Meie näites on vahemik 1 kuni 100:Olgu madalpiir = 1; las highBound = 100; olgu numInput = 123; let clamped = Math.max(lowBound, Math.min(arvSisend, highBound)); console.log(clamped); > 100;
Jällegi saame toimingut uuesti kasutada ja kogu asja funktsiooniks mähkida, kasutades Daniel X. Moore'i pakutud lahendust:
Number.prototype.clamp = funktsioon(min, max) ( return Math.min(Math.max(this, min), max); );
Nüüd:
NumInput.clamp(lowBound, highBound); > 100;
Gaussi ümardamine Gaussi ümardamine, tuntud ka kui pankuri ümardamine, hõlmab ümardamist lähima paarisarvuni. See ümardamismeetod töötab ilma statistilise veata. Parim otsus soovitas Tim Down:Funktsioon gaussRound(arv, kümnendkohad) ( olgu d = kümnendkohad || 0, m = Math.pow(10, d), n = +(d ? arv * m: arv).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;
}
Nüüd:
GaussRound(2.5) > 2 gaussRound(3.5) > 4 gaussRound(2.57,1) > 2.6
Kümnend CSS-is:
Kuna JavaScripti kasutatakse sageli HTML-i elementide positsiooniliste vastenduste loomiseks, võite mõelda, mis juhtuks, kui genereeriksime oma elementide jaoks kümnendväärtused:
#box ( laius: 63,667731993px; )
Hea uudis on see, et kaasaegsed brauserid austavad plokkmudelis kümnendväärtusi, sealhulgas protsentides või pikslites.
Las puuvili = ["võikõrvits", "aprikoos", "kantaluup"]; puuviljad.sort(); > "aprikoos", "suvikõrvits", "kantaluup"]
Siiski tekib probleem niipea, kui üks elementidest on suurtähtedega:
Las puuviljad = ["võikõrvits", "aprikoos", "Cantalope"]; puuviljad.sort(); > "Cantaloupe", "aprikoos", "suvikõrvits"]
Selle põhjuseks on asjaolu, et vaikimisi võrdleb sortija Unicode'is esitatud esimest märki. Unicode on unikaalne kood iga märgi jaoks, olenemata platvormist, programmist, keelest. Näiteks kui vaatate kooditabelit, on märgi "a" väärtus U+0061 (in kuueteistkümnendsüsteem 0x61), samas kui märgil "C" on kood U+0043 (0x43), mis on Unicode'i tabelis varem kui märk "a".
Massiivi sortimiseks, mis võib sisaldada segatüüpi esitähti, peame kõik elemendid ajutiselt teisendama väiketähtedega, või määrake oma sortimise järjekord, kasutades meetodit localeCompare() koos teatud argumentidega. Reeglina on sellisel juhul parem luua kohe funktsioon korduvaks kasutamiseks:
Funktsioon alphaSort(arr) ( arr.sort(funktsioon (a, b) ( return a.localeCompare(b, "en", ("tundlikkus": "base")); )); ) let fruit = ["butternut squash ", "aprikoos", "Cantaloupe"]; alfaSort (puuvili) >
Kui soovite, et massiiv oleks järjestatud vastupidises tähestikulises järjekorras, vahetage lihtsalt funktsioonis a ja b positsioonid:
Funktsioon alphaSort(arr) ( arr.sort(funktsioon (a, b) ( return b.localeCompare(a, "en", ("tundlikkus": "base")); )); ) let fruit = ["võikõrvits ", "aprikoos", "Cantaloupe"]; alfaSort(puuvili) > ["Kantaloupe", "suvikõrvits", "aprikoos"]
Siinkohal väärib märkimist, et localeCompare'i kasutatakse argumentidega, samuti peame meeles pidama, et seda toetab IE11+, IE vanemate versioonide puhul saame seda kasutada argumentideta ja väiketähtedega:
Funktsioon caseSort(arr) ( arr.sort(funktsioon (a, b) ( tagastab a.toLowerCase().localeCompare(b.toLowerCase()); )); ) let fruit = ["butternut squash", "apricot", "Cantaloupe"]; caseSort(puuvili) > ["aprikoos", "kõrvitsakõrvits", "kantaluup"]
Numbriline sortimine Kõik see ei kehti näite kohta, millest me eespool rääkisime mängukirjete massiivi kohta. Mõnega numbrimassiivid sorteerimine toimib suurepäraselt, kuid ühel hetkel võib tulemus olla ettearvamatu:Olgu tipptulemused = ; rekordid.sort(); >
Asi on selles, et sort() meetod teostab leksikograafilist võrdlust: see tähendab, et numbrid teisendatakse stringiks ja võrdlused tehakse uuesti, sobitades selle stringi esimese märgi Unicode'i tabelis olevate märkide järjekorras. . Seetõttu peame uuesti määratlema oma sortimisjärjestuse:
Olgu tipptulemused = ; high Scores.sort(function(a,b) ( tagastab a - b; )); >
Jällegi, numbrite vastupidises järjekorras sortimiseks vahetage funktsioonis a ja b positsioonid.
Olgu hinded = [ ( "nimi": "Daniel", "skoor": 21768 ), ( "nimi": "Michael", "skoor": 33579 ), ( "nimi": "Alison", "skoor": 38395 ) ];
ES6+-s saate kasutada noolefunktsioone:
Scores.sort((a, b) => b.score - a.score));
Vanemate brauserite puhul, millel see tugi puudub:
Scores.sort(funktsioon(a, b) ( tagastab a.skoor - b.skoor ));
Nagu näha, siis JavaScriptis sorteerimine on üsna ähmane asi, loodan, et need näited teevad elu kuidagi lihtsamaks.
JavaScriptis on võimsusfunktsioon esindatud kui Math.pow(), uues ES7 standardis võeti see kasutusele uus operaator astendamine - " * * ".
Tõstmine astmeni Arvu tõstmiseks n-nda astmeni kasutage funktsiooni Math.pow(), kus esimene argument on arv, mis tõstetakse astmeni, teine argument on astendaja:Math.pow(3,2) > 9
Selline tähistus tähendab 3 ruutu ehk 3 × 3, mis annab tulemuseks 9. Muidugi võib tuua veel ühe näite:
Math.pow(5,3); > 125
See tähendab, et 5 kuubikut või 5 × 5 × 5 võrdub 125-ga.
Järgmine on ECMAScript 7 JavaScripti versioon, põhimõtteliselt saame kasutada uut pakutud astendamise operaatorit - * *, see tähistus võib olla kirjeldavam:
3 ** 2
> 9
Peal Sel hetkel Selle operaatori tugi on üsna piiratud, seetõttu pole selle kasutamine soovitatav.
Toitefunktsioon võib olla kasulik erinevates olukordades. Lihtne näide, sekundite arvu arvutamine tunnis: Math.pow (60,2).
Ruut- ja kuupjuur Math.sqrt() ja Math.cbrt() on Math.pow() vastandid. Nagu mäletame, on a ruutjuur arv, mis annab ruudustamisel a.Math.sqrt(9) > 3
Samas on a kuupjuur arv, mis kuubiks tõstmisel annab a.
Math.cbrt(125) > 5
Math.cbrt() võeti JavaScripti spetsifikatsioonis kasutusele alles hiljuti ja seetõttu toetatakse seda ainult kaasaegsetes brauserites: Chrome 38+, Firefox ja Opera 25+ ning Safari 7.1+. Sa märkad seda Internet Explorer pole selles loendis, kuid MDN-ist leiate polüfilli.
Math.pow(1,25, 2); > 1,5625 Math.cbrt(56,57) > 3,8387991760286138
Pange tähele, et see toimib üsna hästi ka negatiivsete argumentide väärtuste kasutamisel:
Math.pow(-5,2) > 25 Math.pow(10,-2) > 0,01
Ruutjuure puhul see aga ei tööta:
Math.sqrt(-9) > NaN
Alates matemaatiline analüüs Teame, et imaginaararvu all peame silmas negatiivsete arvude ruutjuuri. Ja see võib viia meid teise töömeetodi juurde kompleksarvud, Aga see on teine lugu.
Ruudu ja ruudu leidmiseks saate kasutada Math.pow() murdarvusid kuubiku juured numbrid. Ruutjuur kasutab eksponenti 0,5:
Math.pow(5; 0,5); // = Math.sqrt(5) = 5 ** (1/2) > 2,23606797749979
Kuid ujukoma kapriiside tõttu ei saa te õiget tulemust täpselt arvata:
Math.pow(2, 23606797749979,2) > 5,0000000000000001
Sellistes olukordades peate kasutama märkide arvult ära lõikamist või ümardamist mõne väärtuseni.
Mõned inimesed ajavad JavaScriptis teadmata põhjustel segamini funktsiooni Math.pow() ja Math.exp() , mis on üldiselt arvude eksponentsiaalne funktsioon. Märkus: sisse inglise keel"eksponent" on tõlgitud kui "astendaja", nii et see kehtib tõenäolisemalt inglise keele kõnelejate kohta, kuigi eksponendi jaoks on ka alternatiivseid nimetusi, näiteks indeks, võimsus.
Matemaatilised konstandid JavaScriptis matemaatikaga töötamise muudavad lihtsamaks mitmed sisseehitatud konstandid. Need konstandid on matemaatikaobjekti omadused. Väärib märkimist, et konstandid kirjutatakse suurtähtedega, mitte CamelCase tähistusega.Küsitluses saavad osaleda ainult registreerunud kasutajad. , Palun.
Sildid: Lisa silte Väga sageli ei anna JavaScripti arvutused täpselt soovitud tulemusi. Muidugi võime numbritega teha, mida tahame – ümardada üles või alla, seada vahemikke, lõigata ära mittevajalikud arvud teatud arvu komakohtadeni, kõik sõltub sellest, mida selle numbriga edaspidi teha tahate. Miks on ümardamine vajalik? JavaScripti üks huvitavaid aspekte on see, et see tegelikult ei salvesta täisarve, me töötame kohe ujukomaarvudega. Seda koos tõsiasjaga, et paljusid murdväärtusi ei saa väljendada piiratud arvu kümnendkohtadega, saame JavaScriptis selliseid tulemusi:0.1 * 0.2;
> 0.020000000000000004
0.3 - 0.1
> 0.19999999999999998
Praktilistel eesmärkidel pole sellel ebatäpsusel tähtsust, meie puhul räägime kvintiljondikes olevast veast, kuid see võib mõnele pettumust valmistada. Mõnevõrra kummalisi tulemusi võime saada ka siis, kui töötame numbritega, mis tähistavad valuutasid, protsente või failisuurusi. Nende ebatäpsuste parandamiseks peame lihtsalt suutma tulemusi ümardada ja piisab kümnendkoha täpsuse määramisest.
Arvude ümardamisel on praktilisi rakendusi, me saame manipuleerida arvuga teatud vahemikus, näiteks tahame ümardada väärtuse lähima täisarvuni, mitte töötada ainult kümnendosaga.
Kümnendkohtade ümardamine Kümnendarvu kärpimiseks kasutage meetodit toFixed või toPrecision. Mõlemad võtavad ühe argumendi, mis määrab vastavalt, mitu olulist numbrit (st numbris kasutatud numbrite koguarv) või kümnendkohti (arv pärast koma) peaks tulemus sisaldama:Nii meetod toFixed() kui ka toPrecision() tagastavad tulemuse stringi, mitte arvu. See tähendab, et kui summeerida ümardatud väärtus randNumiga, tekitab see pigem stringide konkatenatsiooni kui arvude summa:
Olgu randNum = 6,25; olgu ümardatud = randNum.toFixed(); // "6" konsool.log(randNum + ümardatud); > "6.256"
Kui soovite, et tulemus oleks numbriline andmetüüp, peate kasutama parseFloati:
Olgu randNum = 6,25; olgu ümardatud = parseFloat(randNum.toFixed(1)); konsool.log(ümardatud); > 6.3
Pange tähele, et väärtused 5 on ümardatud, välja arvatud harvadel juhtudel.
Meetodid toFixed() ja toPrecision() on kasulikud, kuna need ei saa mitte ainult murdosa ära lõigata, vaid lisada ka kümnendkohti, mis on valuutaga töötamisel mugav:
Olgu koguarv = 1 olgu dollariSentide = terveArv.Fikseeritud(2); console.log(dollaridSentide); > "1.00"
Pange tähele, et toPrecision annab tulemuse teaduslikul kujul, kui täisarvude arv on suurem kui täpsus ise:
Olgu num = 123,435 num.toPrecision(2); > "1.2e+2"
Kuidas vältida kümnendkohtadega ümardamise vigu Mõnel juhul ümardatakse toFixed ja toPrecision väärtus 5 alla ja üles:Olgu numTest = 1,005; numTest.toFixed(2); > "1.00"
Ülaltoodud arvutuse tulemus oleks pidanud olema 1,01, mitte 1. Kui soovite sarnast viga vältida, võime kasutada Jack L Moore'i pakutud lahendust, mis kasutab arvutamisel eksponentsiaalarve:
Funktsiooni ring(väärtus, kümnendkohad) ( tagastab Arv(Math.round(väärtus+"e"+kümnendkohad)+"e-"+kümnendkohad); )
Nüüd:
Round(1,005,2); > 1.01
Kui soovite ülaltoodud lahendusest tugevamat lahendust, võite minna MDN-i.
0,1 + 0,2 === 0,3 > vale
Õige võrdluse saamiseks kasutame oma funktsioonis Math.EPSILON:
Funktsioon epsEqu(x, y) ( tagastab Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y));
}
Funktsioonil on kaks argumenti: esimene on praegune arvutus, teine on oodatav tulemus. See tagastab nende kahe võrdluse:
EpsEqu(0,1 + 0,2; 0,3) > tõene
Kõik kaasaegsed brauserid toetavad juba ES6 matemaatilisi funktsioone, kuid kui soovite tuge sellistes brauserites nagu IE 11, kasutage polütäiteid.
Funktsioon truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3,1416) > 3,14
Kui soovite kohandada meetodit suvalise arvu kümnendkohtadega, võite kasutada bitipõhist topelteitust:
Funktsioon kärbitud(arv, kümnendkohad) ( olgu numPowerConverter = Math.pow(10, decimalPlaces); tagasta ~~(num * numPowerConverter)/numPowerConverter; )
Nüüd:
Olgu randInt = 35,874993; kärbitud(randInt,3); > 35,874
Ümardamine lähima arvuni Kümnendarvu ümardamiseks lähima arvuni üles või alla, olenevalt sellest, kummale oleme kõige lähemal, kasutage Math.round():Matemaatika.ring(4.3) > 4 Matemaatika.ring(4.5) > 5
Pange tähele, et "pool väärtust", 0,5 ümardatakse vastavalt matemaatikareeglitele.
matemaatika.korrus(42,23); > 42 Math.floor(36.93); > 36
Pange tähele, et allapoole ümardamine töötab kõigi arvude, sealhulgas negatiivsete arvude puhul. Kujutage ette pilvelõhkujat, millel on lõpmatu arv korruseid, sealhulgas alumise tasandi korrused (esindavad negatiivseid numbreid). Kui olete liftis madalaimal tasemel vahemikus 2 kuni 3 (mis tähistab väärtust -2,5), viib Math.floor teid -3:
Math.korrus(-2,5); > -3
Kuid kui soovite seda olukorda vältida, kasutage Math.trunc, mida toetavad kõik kaasaegsed brauserid (välja arvatud IE/Edge):
Math.trunc(-41,43); > -41
MDN-is leiate polüfilli, mis toetab Math.trunc'i brauserites ja IE/Edge'is.
matemaatika.lagi(42,23); > 43 Math.ceil(36,93); > 37 Math.ceil(-36,93); > -36
Ümardamine üles/alla vajaliku arvuni Kui tahame ümardada 5 lähima kordseni, on lihtsaim viis luua funktsioon, mis jagab arvu 5-ga, ümardab selle ja seejärel korrutab sama summaga:Funktsioon roundTo5(num) ( return Math.round(num/5)*5; )
Nüüd:
RoundTo5(11); > 10
Kui soovite ümardada oma väärtuse kordseteks, kasutame üldisemat funktsiooni, edastades algväärtuse ja kordse:
Funktsioon roundToMultiple(arv, mitu) ( tagasta Math.round(arv/mitu)*mitmekordne; )
Nüüd:
Olgu esialgne arv = 11; olgu mitmekordne = 10; roundToMultiple(algnearv, mitu); > 10;
Arvu fikseerimine vahemikus On palju juhtumeid, kus tahame saada x väärtust, mis jääb vahemikku. Näiteks võib meil vaja minna väärtust vahemikus 1 kuni 100, kuid saime väärtuseks 123. Selle parandamiseks saame kasutada väärtusi min (tagastab arvude hulgast väikseima) ja max (tagastab arvudest suurima numbritest). Meie näites on vahemik 1 kuni 100:Olgu madalpiir = 1; las highBound = 100; olgu numInput = 123; let clamped = Math.max(lowBound, Math.min(arvSisend, highBound)); console.log(clamped); > 100;
Jällegi saame toimingut uuesti kasutada ja kogu asja funktsiooniks mähkida, kasutades Daniel X. Moore'i pakutud lahendust:
Number.prototype.clamp = funktsioon(min, max) ( return Math.min(Math.max(this, min), max); );
Nüüd:
NumInput.clamp(lowBound, highBound); > 100;
Gaussi ümardamine Gaussi ümardamine, tuntud ka kui pankuri ümardamine, on koht, kus ümardatakse sel juhul lähima paarisarvuni. See ümardamismeetod töötab ilma statistilise veata. Tim Down pakkus välja parema lahenduse:Funktsioon gaussRound(arv, kümnendkohad) ( olgu d = kümnendkohad || 0, m = Math.pow(10, d), n = +(d ? arv * m: arv).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;
}
Nüüd:
GaussRound(2.5) > 2 gaussRound(3.5) > 4 gaussRound(2.57,1) > 2.6
Kümnend CSS-is:
Kuna JavaScripti kasutatakse sageli HTML-i elementide positsiooniliste vastenduste loomiseks, võite mõelda, mis juhtuks, kui genereeriksime oma elementide jaoks kümnendväärtused:
#box ( laius: 63,667731993px; )
Hea uudis on see, et kaasaegsed brauserid austavad plokkmudelis kümnendväärtusi, sealhulgas protsentides või pikslites.
Las puuvili = ["võikõrvits", "aprikoos", "kantaluup"]; puuviljad.sort(); > "aprikoos", "suvikõrvits", "kantaluup"]
Siiski tekib probleem niipea, kui üks elementidest on suurtähtedega:
Las puuviljad = ["võikõrvits", "aprikoos", "Cantalope"]; puuviljad.sort(); > "Cantaloupe", "aprikoos", "suvikõrvits"]
Selle põhjuseks on asjaolu, et vaikimisi võrdleb sortija Unicode'is esitatud esimest tähemärki. Unicode on unikaalne kood iga märgi jaoks, olenemata platvormist, programmist, keelest. Näiteks kui vaatate kooditabelit, on märgi "a" väärtus U+0061 (kuueteistkümnendsüsteemis 0x61), samas kui märgil "C" on kood U+0043 (0x43), mis on Unicode'is varem. tabelis kui märk "a".
Massiivi sortimiseks, mis võib sisaldada esitähti segamini, peame kas kõik elemendid ajutiselt teisendama väiketähtedeks või määrama sortimisjärjestuse, kasutades meetodit localeCompare() koos mõningate argumentidega. Reeglina on sellisel juhul parem korduvaks kasutamiseks kohe luua funktsioon:
Funktsioon alphaSort(arr) ( arr.sort(funktsioon (a, b) ( return a.localeCompare(b, "en", ("tundlikkus": "base")); )); ) let fruit = ["butternut squash ", "aprikoos", "Cantaloupe"]; alfaSort (puuvili) >
Kui soovite, et massiiv oleks järjestatud vastupidises tähestikulises järjekorras, vahetage lihtsalt funktsioonis a ja b positsioonid:
Funktsioon alphaSort(arr) ( arr.sort(funktsioon (a, b) ( return b.localeCompare(a, "en", ("tundlikkus": "base")); )); ) let fruit = ["võikõrvits ", "aprikoos", "Cantaloupe"]; alfaSort(puuvili) > ["Kantaloupe", "suvikõrvits", "aprikoos"]
Siinkohal väärib märkimist, et localeCompare'i kasutatakse argumentidega, samuti peame meeles pidama, et seda toetab IE11+, IE vanemate versioonide puhul saame seda kasutada argumentideta ja väiketähtedega:
Funktsioon caseSort(arr) ( arr.sort(funktsioon (a, b) ( tagastab a.toLowerCase().localeCompare(b.toLowerCase()); )); ) let fruit = ["butternut squash", "apricot", "Cantaloupe"]; caseSort(puuvili) > ["aprikoos", "kõrvitsakõrvits", "kantaluup"]
Numbriline sortimine Kõik see ei kehti näite kohta, millest me eespool rääkisime mängukirjete massiivi kohta. Mõne numbrimassiivi korral toimib sortimine hästi, kuid mingil hetkel võib tulemus olla ettearvamatu:Olgu tipptulemused = ; rekordid.sort(); >
Asi on selles, et sort() meetod teostab leksikograafilist võrdlust: see tähendab, et numbrid teisendatakse stringiks ja võrdlused tehakse uuesti, sobitades selle stringi esimese märgi Unicode'i tabelis olevate märkide järjekorras. . Seetõttu peame uuesti määratlema oma sortimisjärjestuse:
Olgu tipptulemused = ; high Scores.sort(function(a,b) ( tagastab a - b; )); >
Jällegi, numbrite vastupidises järjekorras sortimiseks vahetage funktsioonis a ja b positsioonid.
Olgu hinded = [ ( "nimi": "Daniel", "skoor": 21768 ), ( "nimi": "Michael", "skoor": 33579 ), ( "nimi": "Alison", "skoor": 38395 ) ];
ES6+-s saate kasutada noolefunktsioone:
Scores.sort((a, b) => b.score - a.score));
Vanemate brauserite puhul, millel see tugi puudub:
Scores.sort(funktsioon(a, b) ( tagastab a.skoor - b.skoor ));
Nagu näha, siis JavaScriptis sorteerimine on üsna ähmane asi, loodan, et need näited teevad elu kuidagi lihtsamaks.
JavaScriptis on võimsusfunktsioon esindatud kui Math.pow() ja uues ES7 standardis võeti kasutusele uus astendamise operaator - " * * ".
Tõstmine astmeni Arvu tõstmiseks n-nda astmeni kasutage funktsiooni Math.pow(), kus esimene argument on arv, mis tõstetakse astmeni, teine argument on astendaja:Math.pow(3,2) > 9
Selline tähistus tähendab 3 ruutu ehk 3 × 3, mis annab tulemuseks 9. Muidugi võib tuua veel ühe näite:
Math.pow(5,3); > 125
See tähendab, et 5 kuubikut või 5 × 5 × 5 võrdub 125-ga.
ECMAScript 7 on JavaScripti järgmine versioon, põhimõtteliselt saame kasutada uut pakutud astendamise operaatorit - * *, see märge võib olla kirjeldavam:
3 ** 2
> 9
Hetkel on selle operaatori tugi üsna piiratud, seega ei soovita seda kasutada.
Toitefunktsioon võib olla kasulik erinevates olukordades. Lihtne näide, sekundite arvu arvutamine tunnis: Math.pow (60,2).
Ruut- ja kuupjuur Math.sqrt() ja Math.cbrt() on Math.pow() vastandid. Nagu mäletame, on a ruutjuur arv, mis annab ruudustamisel a.Math.sqrt(9) > 3
Samas on a kuupjuur arv, mis kuubiks tõstmisel annab a.
Math.cbrt(125) > 5
Math.cbrt() võeti JavaScripti spetsifikatsioonis kasutusele alles hiljuti ja seetõttu toetatakse seda ainult kaasaegsetes brauserites: Chrome 38+, Firefox ja Opera 25+ ning Safari 7.1+. Märkate, et Internet Explorerit selles loendis pole, kuid MDN-is leiate polütäide.
Math.pow(1,25, 2); > 1,5625 Math.cbrt(56,57) > 3,8387991760286138
Pange tähele, et see toimib üsna hästi ka negatiivsete argumentide väärtuste kasutamisel:
Math.pow(-5,2) > 25 Math.pow(10,-2) > 0,01
Ruutjuure puhul see aga ei tööta:
Math.sqrt(-9) > NaN
Matemaatilisest analüüsist teame, et imaginaarne arv viitab negatiivsete arvude ruutjuurtele. Ja see võib viia meid teise kompleksarvudega töötamise tehnika juurde, kuid see on juba teine lugu.
Arvude ruut- ja kuupjuurte leidmiseks saate failis Math.pow() kasutada murde. Ruutjuur kasutab eksponenti 0,5:
Math.pow(5; 0,5); // = Math.sqrt(5) = 5 ** (1/2) > 2,23606797749979
Kuid ujukoma kapriiside tõttu ei saa te õiget tulemust täpselt arvata:
Math.pow(2, 23606797749979,2) > 5,0000000000000001
Sellistes olukordades peate kasutama märkide arvult ära lõikamist või ümardamist mõne väärtuseni.
Mõned inimesed ajavad JavaScriptis teadmata põhjustel segamini funktsiooni Math.pow() ja Math.exp() , mis on üldiselt arvude eksponentsiaalne funktsioon. Märkus. Inglise keeles tõlgitakse "astendaja" kui "astendaja", seega kehtib see tõenäolisemalt inglise keele kõnelejate kohta, kuigi eksponendi jaoks on ka alternatiivseid nimetusi, näiteks indeks, võimsus.
Matemaatilised konstandid JavaScriptis matemaatikaga töötamise muudavad lihtsamaks mitmed sisseehitatud konstandid. Need konstandid on matemaatikaobjekti omadused. Väärib märkimist, et konstandid kirjutatakse suurtähtedega, mitte CamelCase tähistusega.Küsitluses saavad osaleda ainult registreerunud kasutajad. Tulge sisse, palun.
Sildid:- javascript
- matemaatika
Tehniliselt on termin "juhuslike arvude generaator" jama, kuna arvud ise ei ole juhuslikud. Näiteks kas 100 on juhuslik arv? Aga 25? See termin tähendab tegelikult seda, et see loob juhuslikult ilmuvate numbrite jada. See tõstatab keerulisema küsimuse: mis on juhuslike arvude jada? Ainus õige vastus: juhuslike arvude jada on jada, milles kõik elemendid ei ole omavahel seotud. See määratlus viib paradoksini, et iga jada võib olla kas juhuslik või mittejuhuslik, olenevalt sellest, kuidas jada saadakse. Näiteks, järgmine rida numbrid
1 2 3 4 5 6 7 8 9 0
saadi trükkimise teel ülemine rida klaviatuurid järjekorras, nii et jada ei saa lugeda juhuslikult genereerituks. Aga mis siis, kui numbritega tennisepallid tünnist välja võttes saad sama jada. IN sel juhul see on juba juhuslikult genereeritud jada. See näide näitab, et jada juhuslikkus sõltub sellest, kuidas see on saadud, mitte endast.
Pidage meeles, et arvutiga loodud numbrijada on deterministlik: iga number, välja arvatud esimene, sõltub sellele eelnevatest arvudest. Tehniliselt tähendab see seda, et arvuti suudab genereerida vaid kvaasijuhusliku arvujada, s.t. tegelikult pole need päris juhuslikud. Kuid see on enamiku ülesannete jaoks piisav ja lihtsuse huvides nimetatakse selliseid järjestusi juhuslikeks. Ühe väga huvitava meetodi töötas välja John von Neumann; seda nimetatakse sageli ruutkeskmiseks. Selle meetodi puhul ruudustatakse eelmine juhuslik arv ja seejärel eraldatakse tulemusest keskmised numbrid. Näiteks kui loote kolmekohalisi numbreid ja eelmine arv oli 121, siis selle ruudustamisel saadakse tulemus 14641. Kolme keskmise numbri eraldamisel saadakse järgmine juhuslik arv 464. Selle meetodi puuduseks on see, et sellel on väga lühike kordusperiood, mida nimetatakse tsükliks. Sel põhjusel seda meetodit täna ei kasutata. Kaasaegsed meetodid Juhuslike arvude genereerimine on palju keerulisem.
Juhuslikud numbrid PHP-sPHP-l on juhuslike numbritega töötamiseks kaks funktsioonide rühma. Puhtalt väliselt saab neid eristada mt_ prefiksiga ühe rühma kõigi funktsioonide jaoks.
Aegunud funktsioonid
funktsiooni rand. Tagastab täisarvu nulli ja RAND_MAX väärtuse vahel (mis on 32767). Võib sisaldada kahte valikulist täisarvu parameetrit – kui need on määratud, genereeritakse juhuslik arv esimesest parameetrist teise.
Kaja rand(); kajarand(1100); // Andke välja juhuslik arv vahemikus 1 kuni 100
Funktsioon srand. Määrab randfunktsiooni poolt genereeritud juhuslike arvude jada. Sellel on terve parameeter - millal erinevaid tähendusi Selle parameetriga loob rand erinevaid numbrijadasid. Funktsiooni srand tuleb enne kõiki rand-funktsiooni väljakutseid kutsuda ainult üks kord. Kasutusnäide:
Srand(1288); // Initsialiseeri juhuslike arvude generaator for($i=0; $i
