Tere. Täna Javascripti veerus vaatleme, kuidas määrata javascriptis ujukomaarvudes kümnendkohtade arvu. Näiteks tuleb väljastamisel jätta 3 kohta pärast koma või ainult kaks kohta.

Ülesanne: javascript kümnendkohtade arv

Niisiis seisame silmitsi ülesandega: on arvutuste tulemus, milles on arvud enne koma ja pärast koma. Kümnend. Oletame, et tulemus on järgmine: 1538.9891200153. Aga väljastades peaks saama summat kajastava numbri, kus enne koma on rahatähtede arv ja pärast kopikate arv.

Selle probleemi lahendamiseks on mitu võimalust.

Lahendus 1: JavaScripti kümnendkohtade arv, kasutades meetodit toFixed

toFixed on sisseehitatud JavaScripti meetod, mis kehtib mis tahes arvu kohta, võttes parameetrina ümardamise täpsuse (st kümnendkohtade arvu).

Var number = 1538.9891200153; num_str=num.toFixed(); //num_str=1538; num_str=num.toFixed(2); //num_str=1538,98; num_str=num.toFixed(5); //num_str=1538.98912;

Selle funktsiooni täpsusparameeter ei tohi olla väiksem kui 0 (ei aktsepteeri negatiivseid väärtusi) ja mitte suurem kui 20.

Saate teha ka ilma muutujata, näiteks järgmiselt:

Num_str=(1538.9891200153).Fixed(2); //num_str=1538.98;

Lahendus 2: JavaScripti kümnendkohtade arv, kasutades meetodit toPrecision

See lahendus põhineb samal sisseehitatud javascripti meetodil. Iseloomulik omadus See meetod seisneb selles, et sisendiks võetud parameeter ei näita täpsust (komakohtade arv), vaid kümnendkohtade koguarvu (nii enne kui ka pärast koma).

Var number = 1538.9891200153; num_str=num.toPrecision(5); //num_str=1538.9; num_str=num.toPrecision(7); //num_str=1538.989;

Lahendus ilma kümnendkohtadeta: javascript kümnendkohtade arv

Kui komakohad tuleb täielikult eemaldada, st peate ümardama murdarv täisarvuni, siis saate funktsioone kasutada Matemaatika tund: ümmargune, lae ja põrand.
Ümar - ümardab üles või alla (olenevalt arvust). Kui komajärgne väärtus on suurem kui pool, ümardatakse see väärtuseni suur pool, kui vähem - vähemaks. See tähendab, et kui 0,51 saab sellest 1, kui 0,49 on see 0.

Lagi – inglise keelest. Lagi ümardub alati ülespoole.

Põrand – inglise keelest. Põrand ümardub alati allapoole.

Var number = 1538,9891200153; num_str=Math.round(arv); //num_str=1539; num_str=Math.floor(arv); //num_str=1538; num_str=Math.ceil(arv); //num_str=1539;

See on kõik. Loodan, et see märkus aitas teil probleemi lahendada. Kui midagi ei õnnestu, esitage küsimusi rohelise nupu "Küsi eksperdilt" abil või kommentaarides.

Sageli annavad arvutused tulemusi, mis jäävad väljapoole soovitud vahemikke. Selle tulemusena on vaja seda rakendada JavaScripti ümardamine kuni teatud väärtuseni.

Miks ümmargused numbrid?

JavaScript ei salvesta täisarve, kuna nende väärtused on esitatud ujukomaarvudena. Paljusid murde ei saa esitada arvuna, millel on kindel arv komakohti, seega võib JavaScript genereerida selliseid tulemusi:

0.1 * 0.2; > 0.020000000000000004

Praktikas pole sellel mingit vahet me räägime umbes 2 kvintiljoni suurune viga. Kuid see võib mõjutada tulemusi, kui töötate numbritega, mis esindavad valuuta väärtusi, protsente või faili suurust. Seetõttu peate tegema või teatud kümnendkohani.

Kümnendarvude ümardamine

Lõikama" kümnendnumber, kasutatakse meetodeid toFixed() või toPrecision(). Mõlemad kasutavad ühte argumenti, mis määrab tulemusesse kaasatavate oluliste ja kümnendkohtade arvu:

• kui toFixed() argumenti pole määratud, on vaikeväärtus 0, see tähendab, et kümnendkohti pole; maksimaalne väärtus argument on 20;
• kui toPrecision(ile) argumenti ei anta, siis arvu ei muudeta.

var randNum = 6,25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" var randNum = 87,335; randNum.toFixed(2); > "87,33" var randNum = 87,337; randNum.toPrecision(3); > "87,3"

Märge

Nii toFixed() kui ka toPrecision tagastavad tulemuse ümardatud stringi, mitte arvu. See tähendab, et randNum-i ümardamise lisamine toob kaasa stringide konkatenatsiooni, mitte ühe arvu:

console.log(randNum + ümardatud); > "6.256"

Kui soovite, et JavaScript ümardaks arvu lähima sajandikuni, kasutage parseFloat() :

var randNum = 6,25; var ümardatud = parseFloat(randNum.toFixed(1)); konsool.log(ümardatud); > 6.3

toFixed() ja toPrecision() on samuti kasulikud meetodid kärpimiseks suur kogus kümnendkohad. See on kasulik rahaühikuid tähistavate numbritega töötamisel:

var terveArv = 1 var dollaritSentide = terveArv.Fixed(2); console.log(dollaridSentide); > "1.00"

Pange tähele, et kui numbris on määratud täpsusest rohkem numbreid, väljastab toPrecision tulemuse teaduslikus vormingus:

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

Kuidas vältida vigu kümnendkohtade ümardamisel

Mõnel juhul Fixed ja to Precision tööseadised JavaScripti ümardamine 5 võrra allapoole ja mitte enamale:

var numTest = 1,005; numTest.toFixed(2); > 1;

Ülaltoodud näite tulemus peaks olema 1,01, mitte 1. Kui soovite seda viga vältida, soovitan kasutada eksponentsiaalnumbreid:

funktsioon round(väärtus, kümnendkohad) ( return Number(Math.round(value+"e"+decimals)+"e-"+decimals); )

Rakendus:

ring(1.005,2); > 1.01

Kui vajate ümardamisest veelgi jõulisemat lahendust, on see saadaval aadressil MDN.

Ümardamine epsiloniga

Alternatiivne meetod JavaScripti ümardamine kümnenditeni võeti kasutusele ES6-s ( tuntud ka kui JavaScript 2015). « Masina epsilon" annab kahe ujukomaarvu võrdlemisel mõistliku veamarginaali. Ilma ümardamiseta võivad võrdlused anda sarnaseid tulemusi:

0,1 + 0,2 === 0,3 > vale

Math.EPSILONI saab kasutada funktsioonis, et saada õiget võrdlust:

funktsioon epsEqu(x, y) ( tagastab Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

Funktsioon võtab kaks argumenti: üks sisaldab arvutusi, teine ​​eeldatavat (ümardatud) tulemust. See tagastab nende kahe parameetri võrdluse:

epsEqu(0,1 + 0,2; 0,3) > tõene

Kõik kaasaegsed brauserid toetavad matemaatilised funktsioonid ES6. Kuid kui teil on vaja vanemates brauserites tuge pakkuda, peate kasutama polütäiteid.

Kümnendarvude kärpimine

Kõik eelnevalt esitatud meetodid toimivad JavaScripti ümardamine kümnenditeni. Kärbimiseks positiivne arv kahe kümnendkoha täpsusega, korrutage see 100-ga, kärpige uuesti ja jagage tulemus 100-ga, vajate:

funktsioon truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3,1416) > 3,14

Kui vajate midagi paindlikumat, võite kasutada bitipõhist operaatorit:

funktsioon kärbitud(arv, kümnendkohad) ( var numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )

Kasutamine:

var randInt = 35,874993; kärbitud(randInt,3); > 35,874

Ümarda lähima numbrini

Rakendada JavaScripti ümardamine lähima täisarvuni, Math.round() kasutatakse:

Matemaatika.ring(4.3) > 4 Matemaatika.ring(4.5) > 5

Pange tähele, et " poole väärtused", näiteks 0,5, ümardatakse ülespoole.

Ümarda alla lähima täisarvuni

Kui soovite ümardada allapoole, kasutage meetodit Math.floor().

matemaatika.korrus(42,23); > 42 Math.floor(36.93); > 36

Allapoole ümardamisel on kõigi arvude, sealhulgas negatiivsete arvude jaoks üks suund. Seda võib ette kujutada pilvelõhkujana, millel on lõpmatu arv korruseid, sealhulgas allpool vundamenti ( esindavad negatiivseid numbreid). Kui olete liftis 2. ja 3. keldrikorruse vahel ( mis vastab väärtusele -2,5), Math.floor viib teid 3. korrusele:

Math.korrus(-2,5); > -3

Kui teil on vaja seda vältida, kasutage JavaScripti matemaatika ümardamist, kasutades Math.trunc() , mida kõik toetavad kaasaegsed brauserid(välja arvatud IE/Edge):

Math.trunc(-41,43); > -41

MDN pakub ka kolmerealine polütäide, et pakkuda Math.trunc'i tuge vanemates brauserites ja IE/Edge'is.

Ümarda üles lähima täisarvuni

Kui soovite kümnendarvu ülespoole ümardada, kasutage funktsiooni Math.ceil. Seda meetodit võib pidada ka lõpmatuks liftiks: Math.ceil viib teid alati "üles", olenemata sellest, kas arv on negatiivne või positiivne:

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

Ümarda lähima kordseni

Kui teil on vaja väärtus ümardada 5 lähima kordseni, looge funktsioon, mis jagab arvu 5-ga, ümardab selle ja seejärel korrutab tulemuse sama väärtusega:

funktsioon roundTo5(num) ( return Math.round(num/5)*5; )

Kasutamine:

ümmargune5(11); > 10

Kui teil on vaja kahe kümnendkohani ümardamiseks JavaScripti, saate funktsioonile edastada nii seemne kui ka kordse:

funktsioon roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )

Funktsiooni kasutamiseks lisage selle kõnesse ümardatav arv ja kordne:

var originArv = 11; var mitu = 10; roundToMultiple(algnearv, mitu); > 10;

Väärtuste ainult üles või alla ümardamiseks asendage funktsioonis ümmargune lae või põrandaga.

Vahemiku sidumine

Mõnikord peate saama x väärtuse, mis peab olema sees teatud vahemik. Näiteks vajame väärtust vahemikus 1 kuni 100, kuid saame väärtuse 123. Selle parandamiseks võite kasutada min() ( tagastab väikseima arvu) ja max ( tagastab maksimaalse lubatud arvu).

Kasutamine:

var madalpiir = 1; var highBound = 100; var numInput = 123; var clamped = Math.max(lowBound, Math.min(arvSisend, highBound)); console.log(clamped); > 100;

Saate luua numbriklassi funktsiooni või laienduse:

Number.prototype.clamp = funktsioon(min, max) ( return Math.min(Math.max(this, min), max); );

Kasutamine:

(numInput).clamp(lowBound, highBound);

Gaussi ümardamine

Gaussi ümardamine ("pangandus", koonduv või hollandlane) on statistilise veata ümardamismeetod. Standard JavaScripti ümardamine mõnikord annab vead suuremas suunas. Gaussi ümardamine väldib seda viga, ümardades lähima paarisarvuni. Parim otsus, mida ma tean.

Sageli annavad arvutused tulemusi, mis jäävad väljapoole soovitud vahemikke. Selle tulemusena on vaja seda rakendada JavaScripti ümardamine kuni teatud väärtuseni.

Miks ümmargused numbrid?

JavaScript ei salvesta täisarve, kuna nende väärtused on esitatud ujukomaarvudena. Paljusid murde ei saa esitada arvuna, millel on kindel arv komakohti, seega võib JavaScript genereerida selliseid tulemusi:

0.1 * 0.2; > 0.020000000000000004

Praktikas ei ole sellel mingit vahet, kuna me räägime 2 kvintiljondiku suurusest veast. Kuid see võib mõjutada tulemusi, kui töötate numbritega, mis esindavad valuuta väärtusi, protsente või faili suurust. Seetõttu peate tegema või teatud kümnendkohani.

Kümnendarvude ümardamine

" trimmi» kümnendnumber, kasutatakse meetodeid toFixed() või toPrecision(). Mõlemad kasutavad ühte argumenti, mis määrab tulemusesse kaasatavate oluliste ja kümnendkohtade arvu:

• kui toFixed() argumenti pole määratud, on vaikeväärtus 0, see tähendab, et kümnendkohti pole; argumendi maksimaalne väärtus on 20;
• kui toPrecision(ile) argumenti ei anta, siis arvu ei muudeta.

var randNum = 6,25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" var randNum = 87,335; randNum.toFixed(2); > "87,33" var randNum = 87,337; randNum.toPrecision(3); > "87,3"

Märge

Nii toFixed() kui ka toPrecision tagastavad tulemuse ümardatud stringi, mitte arvu. See tähendab, et randNum-i ümardamise lisamine toob kaasa stringide konkatenatsiooni, mitte ühe arvu:

Console.log(randNum + ümardatud); > "6.256"

Kui soovite, et JavaScript ümardaks arvu lähima sajandikuni, kasutage parseFloat() :

Var randNum = 6,25; var ümardatud = parseFloat(randNum.toFixed(1)); konsool.log(ümardatud); > 6.3

ToFixed() ja toPrecision() on samuti kasulikud meetodid suure arvu kümnendkohtade kärpimiseks. See on kasulik rahaühikuid tähistavate numbritega töötamisel:

Var koguarv = 1 var dollarSentide = terveArv.Fikseeritud(2); console.log(dollaridSentide); > "1.00"

Pange tähele, et kui numbris on määratud täpsusest rohkem numbreid, väljastab toPrecision tulemuse teaduslikus vormingus:

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

Kuidas vältida vigu kümnendkohtade ümardamisel

Mõnel juhul Fixed ja to Precision tööseadised JavaScripti ümardamine 5 võrra allapoole ja mitte enamale:

Var numTest = 1,005; numTest.toFixed(2); > 1;

Ülaltoodud näite tulemus peaks olema 1,01, mitte 1. Kui soovite seda viga vältida, soovitan kasutada eksponentsiaalnumbreid:

Funktsiooni ring(väärtus, kümnendkohad) ( tagastab Arv(Math.round(väärtus+"e"+kümnendkohad)+"e-"+kümnendkohad); )

Rakendus:

Round(1,005,2); > 1.01

Kui vajate ümardamisest veelgi jõulisemat lahendust, on see saadaval aadressil MDN.

Ümardamine epsiloniga

Alternatiivne meetod JavaScripti ümardamine kümnenditeni võeti kasutusele ES6-s ( tuntud ka kui JavaScript 2015). "Masina epsilon" annab kahe ujukomaarvu võrdlemisel mõistliku veamarginaali. Ilma ümardamiseta võivad võrdlused anda sarnaseid tulemusi:

0,1 + 0,2 === 0,3 > vale

Math.EPSILONI saab kasutada funktsioonis, et saada õiget võrdlust:

Funktsioon epsEqu(x, y) ( tagastab Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

Funktsioon võtab kaks argumenti: üks sisaldab arvutusi, teine ​​on eeldatav ( ümardatud) tulemus. See tagastab nende kahe parameetri võrdluse:

EpsEqu(0,1 + 0,2; 0,3) > tõene

Kõik kaasaegsed brauserid toetavad ES6 matemaatilisi funktsioone. Kuid kui teil on vaja vanemates brauserites tuge pakkuda, peate kasutama polütäiteid.

Kümnendarvude kärpimine

Kõik eelnevalt esitatud meetodid toimivad JavaScripti ümardamine kümnenditeni. Positiivse arvu kärpimiseks kahe kümnendkoha täpsusega korrutage see 100-ga, kärpige uuesti ja jagage tulemus 100-ga:

Funktsioon truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3,1416) > 3,14

Kui vajate midagi paindlikumat, võite kasutada bitipõhist operaatorit:

Funktsioon kärbitud(arv, kümnendkohad) ( var numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )

Kasutamine:

Var randInt = 35,874993; kärbitud(randInt,3); > 35,874

Ümarda lähima numbrini

Rakendada JavaScripti ümardamine lähima täisarvuni, Math.round() kasutatakse:

Matemaatika.ring(4.3) > 4 Matemaatika.ring(4.5) > 5

Pange tähele, et " poole väärtused", näiteks 0,5, ümardatakse ülespoole.

Ümarda alla lähima täisarvuni

Kui soovite ümardada allapoole, kasutage meetodit Math.floor().

matemaatika.korrus(42,23); > 42 Math.floor(36.93); > 36

Ümardamine" alla" on kõikidel numbritel, sealhulgas negatiivsetel, üks suund. Seda võib ette kujutada pilvelõhkujana, millel on lõpmatu arv korruseid, sealhulgas vundamendist allpool ( esindavad negatiivseid numbreid). Kui olete liftis 2. ja 3. keldrikorruse vahel ( mis vastab väärtusele -2,5), Math.floor viib teid 3. korrusele:

Math.korrus(-2,5); > -3

Kui teil on vaja seda vältida, kasutage JavaScripti matemaatika ümardamist, kasutades Math.trunc(), mida toetavad kõik kaasaegsed brauserid ( välja arvatud IE/Edge):

Math.trunc(-41,43); > -41

MDN pakub ka kolmerealine polütäide, et pakkuda Math.trunc'i tuge vanemates brauserites ja IE/Edge'is.

Ümarda üles lähima täisarvuni

Kui soovite kümnendarvu ülespoole ümardada, kasutage funktsiooni Math.ceil. Selle meetodi mõju võib käsitleda ka kui lõputut lifti: Math.ceil viib teid alati " üles", olenemata sellest, kas arv on negatiivne või positiivne:

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

Ümarda lähima kordseni

Kui teil on vaja väärtus ümardada 5 lähima kordseni, looge funktsioon, mis jagab arvu 5-ga, ümardab selle ja seejärel korrutab tulemuse sama väärtusega:

Funktsioon roundTo5(num) ( return Math.round(num/5)*5; )

Kasutamine:

RoundTo5(11); > 10

Kui teil on vaja kahe kümnendkohani ümardamiseks JavaScripti, saate funktsioonile edastada nii seemne kui ka kordse:

Funktsioon roundToMultiple(arv, mitu) ( tagasta Math.round(arv/mitu)*mitmekordne; )

Funktsiooni kasutamiseks lisage selle kõnesse ümardatav arv ja kordne:

Vari esialgne arv = 11; var mitu = 10; roundToMultiple(algnearv, mitu); > 10;

Väärtuste ainult üles või alla ümardamiseks asendage funktsioonis ümmargune lae või põrandaga.

Vahemiku sidumine

Mõnikord peate saama x väärtuse, mis peab jääma teatud vahemikku. Näiteks vajame väärtust 1 kuni 100, kuid saame väärtuse 123. Selle parandamiseks võite kasutada min() ( tagastab väikseima arvu) ja max ( tagastab maksimaalse lubatud arvu).

Kasutamine:

Var madalpiir = 1; var highBound = 100; var numInput = 123; var clamped = Math.max(lowBound, Math.min(arvSisend, highBound)); console.log(clamped); > 100;

Saate luua numbriklassi funktsiooni või laienduse:

Number.prototype.clamp = funktsioon(min, max) ( return Math.min(Math.max(this, min), max); );

Kasutamine:

(numInput).clamp(lowBound, highBound);

Gaussi ümardamine

Gaussi ümardamine (" pangandus", koonduv või hollandlane) on statistilise veata ümardamismeetod. Standard JavaScripti ümardamine mõnikord annab vead suuremas suunas. Gaussi ümardamine väldib seda viga, ümardades lähima paarisarvuni. Parim lahendus, mida ma tean, on:

Funktsioon gaussRound(arv, kümnendkohad) ( var 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; }

Kasutamise näited:

GaussRound(2.5) > 2 gaussRound(3.5) > 4 gaussRound(2.57,1) > 2.6

Kümnendkohad CSS-is

Kuna JavaScripti kasutatakse sageli asukohateabe hankimiseks või HTML-elementide teisendamiseks, võite küsida, mis juhtuks, kui genereeriksime elementide kümnendväärtused:

#box ( laius: 63,667731993px; )

Kaasaegsed brauserid toetavad kümnendväärtusi plokkmudelis, sealhulgas protsentides ja pikslites.

Artikli “JavaScripti ümardamise retseptid” tõlke koostas Veebisaidi loomise projekti A-lt Z sõbralik meeskond.

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 oleneb sellest, mida selle numbriga edaspidi teha tahad.

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 pettumuse 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

Kümnendarvu lõikamiseks 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) peavad sisaldama tulemust:

1. Kui toFixed() jaoks pole argumenti defineeritud, siis vaikimisi see on võrdne nulliga, mis tähendab 0 kohta pärast koma, argumendi maksimaalne väärtus on 20.
2. Kui toPrecisionile argumenti ei anta, jäetakse number puutumata

olgu randNum = 6,25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" randNum = 87,335; randNum.toFixed(2); > "87,33" randNum = 87,337; randNum.toPrecision(3); > "87,3"
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 tahad, 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 dollarsSentide = terveArv.Fikseeritud(2); console.log(dollaridSentide); > "1.00"
Pange tähele, et toPrecision annab tulemuse eksponentsiaalselt, kui täisarvude arv on suurem kui täpsus ise:

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

Kuidas vältida kümnendkohtade ümardamise vigu

Mõnel juhul ümardab toFixed ja toPrecision väärtuse 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.

Masina epsilon ümardamine

Alternatiivne meetod kümnendarvude ümardamiseks võeti kasutusele ES6-s. Masina epsiloni ümardamine annab kahe ujukomaarvu võrdlemisel mõistliku veamarginaali. Ilma ümardamiseta võivad võrdlused anda sarnaseid tulemusi:

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.

Murdosa kärpimine

Kõik ülaltoodud meetodid võivad ümardada kümnendarvuni. Arvu lihtsalt kahe kümnendkoha täpsusega lõikamiseks peate selle esmalt korrutama 100-ga ja seejärel jagama saadud tulemuse 100-ga:

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

Ümarda lähima numbrini

Kümnendarvu ümardamiseks lähima arvuni üles- või allapoole, olenevalt sellest, kummale oleme kõige lähemal, kasutage funktsiooni Math.round():

Matemaatika.ring(4.3) > 4 Matemaatika.ring(4.5) > 5
Pange tähele, et "pool väärtust", 0,5 ümardatakse vastavalt matemaatikareeglitele.

Ümarda alla lähima täisarvuni

Kui soovite alati ümardada allapoole, kasutage funktsiooni Math.floor:

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 korruseid (esindab negatiivseid numbreid). Kui olete liftis madalam tase 2 ja 3 vahel (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 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.

Ümarda üles lähima täisarvuni

Teisest küljest, kui teil on alati vaja ümardada, kasutage Math.ceili. Jällegi pidage meeles lõpmatut lifti: Math.ceil läheb alati "üles", olenemata sellest, kas arv on negatiivne või mitte:

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 me tahame saada väärtuse x, 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. 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 positsioonivasenduste 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.

Sorteerimine

Väga sageli peame mõned elemendid sorteerima, näiteks on meil rida mängukirjeid ja need tuleb korraldada mängija auastme kahanevas järjekorras. Kahjuks standardmeetod Sortil() on mõned üllatavad piirangud: see töötab hästi tavaliste ingliskeelsete sõnadega, kuid läheb kohe katki, kui see kohtab numbreid, unikaalseid märke või sõnu suurtähtedega.

Sorteerimine tähestiku järjekorras

Tundub, et massiivi sortimine tähestikulises järjekorras peaks olema lihtne ülesanne:

Las puuvili = ["võikõrvits", "aprikoos", "kantaluup"]; puuviljad.sort(); > "aprikoos", "suvikõrvits", "kantaluup"]
Siiski tekib probleem kohe, kui üks elementidest on suurtähtedega:

Olgu 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 mõningate argumentidega. Reeglina on sellisel juhul parem luua kohe funktsioon korduvaks kasutamiseks:

Funktsioon alphaSort(arr) ( arr.sort(funktsioon (a, b) ( tagastab a.localeCompare(b, "en", ("tundlikkus": "base")); )); ) let fruit = ["butternut squash ", "aprikoos", "Cantaloupe"]; alfaSort (puuvili) >
Kui soovite saada massiivi vastupidises järjekorras tähestikuline järjekord, lihtsalt vahetage 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.

JSON-i sarnase struktuuri sortimine

Ja lõpuks, kui meil on JSON-sarnane andmestruktuur, mis on esitatud mängukirjete massiivina:

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(function(a, b) ( tagastab a.skoor - b.skoor ));
Nagu näha, siis JavaScriptis sorteerimine on suht hämar asi, loodan, et need näited teevad elu kuidagi lihtsamaks.

Toitefunktsioonidega töötamine

Astendamine on algselt naturaalarvu endaga korduva korrutamise tulemus. A ruutjuur on arv, mis annab a ruudustamisel. Võiksime neid funktsioone pidevalt kasutada Igapäevane elu matemaatikatundides, sealhulgas pindalade, mahtude arvutamisel või isegi füüsilisel modelleerimisel.

JavaScriptis on võimsusfunktsioon esindatud kui Math.pow(), uues ES7 standardis võeti see kasutusele uus operaator astendamine - " * * ".

Astendamine

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 kuupjuured

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.

Näited

Muidugi saame ühes järgmistest funktsioonidest kasutada mittetäisarvulisi väärtusi:

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.

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: sisse inglise keel"astendaja" on tõlgitud kui "astendaja", seega kehtib see tõenäolisemalt inglise keele kõnelejatele, 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

Lisa märksõnu