Parsefloat javascript 2 desimaalin tarkkuudella. Yksinkertaiset pyöristyssäännöt javascriptissä. Tutkimme menetelmiä ja käytämme niitä käytännössä. Eksponentointi

Usein laskelmat tuottavat tuloksia, jotka ovat haluttujen rajojen ulkopuolella. Seurauksena on, että se on pantava täytäntöön JavaScript pyöristys tiettyyn arvoon asti.

Miksi pyöreät numerot?

JavaScript ei tallenna kokonaislukuja, koska niiden arvot esitetään liukulukuina. Monia murtolukuja ei voida esittää lukuina, joissa on tietty rajallinen määrä desimaalipaikkoja, joten JavaScript voi tuottaa seuraavanlaisia ​​tuloksia:

0.1 * 0.2; > 0.020000000000000004

Käytännössä tällä ei ole mitään merkitystä, koska puhumme 2 kvintiljoonasosan virheestä. Tämä voi kuitenkin vaikuttaa tuloksiin käytettäessä lukuja, jotka edustavat valuuttaarvoja, prosentteja tai tiedostokokoa. Siksi sinun on tehtävä tai tietyn desimaalin tarkkuudella.

Desimaalilukujen pyöristys

"Leikkaa" desimaalilukua käyttämällä toFixed()- tai toPrecision()-menetelmiä. Molemmat ottavat yhden argumentin, joka määrittää tulokseen sisällytettävien merkitsevien ja desimaalien määrän:

• jos toFixed():lle ei ole määritetty argumenttia, oletusarvo on 0, eli ei desimaalipaikkoja; argumentin enimmäisarvo on 20;
• jos toPrecision(:lle) ei anneta argumenttia, numeroa ei muuteta.

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"

Huomautus

Sekä toFixed() että toPrecision palauttavat tuloksen pyöristetyn merkkijonoesityksen luvun sijaan. Tämä tarkoittaa, että pyöristettyjen lisääminen randNumiin johtaa merkkijonojen ketjuun yhden luvun sijaan:

console.log(randNum + pyöristetty); > "6.256"

Jos haluat JavaScriptin pyöristävän luvun lähimpään sadasosaan, käytä parseFloat() -funktiota:

var randNum = 6,25; var pyöristetty = parseFloat(randNum.toFixed(1)); console.log(pyöristetty); > 6.3

toFixed() ja toPrecision() ovat myös hyödyllisiä menetelmiä useiden desimaalien lyhentämiseen. Tämä on hyödyllistä, kun työskentelet rahayksikköjä edustavien lukujen kanssa:

var kokonaisluku = 1 var dollariaSentti = kokonaisluku.Kiinteä(2); console.log(dollarsCents); > "1.00"

Huomaa, että jos numerossa on enemmän numeroita kuin määritetty tarkkuus, toPrecision tulostaa tuloksen tieteellisessä muodossa:

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

Kuinka välttää virheet desimaalien pyöristämisessä

Joissakin tapauksissa Kiinteään ja Precision-koneeseen JavaScript pyöristää 5 alaspäin, eikä enempää:

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

Yllä olevan esimerkin tuloksen tulisi olla 1,01, ei 1. Jos haluat välttää tämän virheen, suosittelen eksponentiaalilukujen käyttöä:

funktio round(arvo, desimaalit) ( return Number(Math.round(arvo+"e"+desimaalit)+"e-"+desimaalit); )

Sovellus:

kierros(1,005,2); > 1.01

Jos tarvitset pyöristystäkin kestävämmän ratkaisun, se on saatavilla osoitteessa MDN.

Pyöristys epsilonilla

Vaihtoehtoinen menetelmä JavaScript pyöristetään kymmenesosiksi otettiin käyttöön ES6:ssa ( tunnetaan myös nimellä JavaScript 2015). « Kone epsilon" tarjoaa kohtuullisen virhemarginaalin verrattaessa kahta liukulukua. Ilman pyöristystä vertailut voivat tuottaa seuraavanlaisia ​​tuloksia:

0,1 + 0,2 === 0,3 > epätosi

Math.EPSILON:ia voidaan käyttää funktiossa kelvollisen vertailun saamiseksi:

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

Funktiolla on kaksi argumenttia: yksi sisältää laskelmat, toinen odotetun (pyöristetyn) tuloksen. Se palauttaa näiden kahden parametrin vertailun:

epsEqu(0.1 + 0.2; 0.3) > tosi

Kaikki nykyaikaiset selaimet tukevat ES6:n matemaattisia toimintoja. Mutta jos sinun on tarjottava tukea vanhemmissa selaimissa, sinun on käytettävä polyfills.

Desimaalilukujen katkaisu

Kaikki aiemmin esitetyt menetelmät toimivat JavaScript pyöristetään kymmenesosiksi. Katkaistaksesi positiivisen luvun kahden desimaalin tarkkuudella, kerro se 100:lla, katkaise se uudelleen ja jaa tulos 100:lla:

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

Jos tarvitset jotain joustavampaa, voit käyttää bittikohtaista operaattoria:

funktio typistetty(num, desimaalipaikat) ( var numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )

Käyttö:

var randInt = 35,874993; katkaistu(randInt,3); > 35,874

Pyöristä lähimpään numeroon

Toteuttaa JavaScript pyöristys lähimpään kokonaislukuun, Math.round():ta käytetään:

Math.round(4.3) > 4 Math.round(4.5) > 5

Ota huomioon, että " puolet arvoista", kuten .5, pyöristetään ylöspäin.

Pyöristä alaspäin lähimpään kokonaislukuun

Jos haluat pyöristää alaspäin, käytä Math.floor()-menetelmää:

Math.floor(42.23); > 42 Math.floor(36.93); > 36

Pyöristämisellä alaspäin on yksi suunta kaikille luvuille, myös negatiivisille. Tämä voidaan kuvitella pilvenpiirtäjänä, jossa on ääretön määrä kerroksia, mukaan lukien perustustason alapuolella ( edustavat negatiivisia lukuja). Jos olet hississä kellarikerrosten 2 ja 3 välissä ( joka vastaa arvoa -2,5), Math.floor vie sinut kerrokseen -3:

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

Jos haluat välttää tämän, käytä JavaScript Math pyöristystä käyttämällä Math.trunc() , jota tuetaan kaikissa nykyaikaisissa selaimissa (paitsi IE/Edge):

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

MDN tarjoaa myös kolmirivinen polyfill, joka tarjoaa tuen Math.truncille vanhemmissa selaimissa ja IE/Edgessä.

Pyöristä ylöspäin lähimpään kokonaislukuun

Jos haluat pyöristää desimaalilukuja ylöspäin, käytä Math.ceiliä. Tätä menetelmää voidaan pitää myös äärettömänä hissinä: Math.ceil vie sinut aina “ylös”, riippumatta siitä, onko luku negatiivinen vai positiivinen:

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

Pyöristä lähimpään kerrannaiseen

Jos sinun on pyöristettävä arvo lähimpään 5:n kerrannaiseen, luo funktio, joka jakaa luvun 5:llä, pyöristää sen ja kertoo sitten tuloksen samalla arvolla:

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

Käyttö:

roundTo5(11); > 10

Jos tarvitset JavaScriptin pyöristämään kahteen desimaaliin, voit välittää sekä siemen- että kerrannaisarvon funktiolle:

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

Käytä funktiota lisäämällä pyöristettävä numero ja kerrannainen sen kutsuun:

var alkuperäinenNumber = 11; var moninkertainen = 10; roundToMultiple(alkuperäinennumero, useat); > 10;

Pyöristääksesi arvot vain ylös tai alas, vaihda pyöreä toiminnossa kattoon tai lattiaan.

Aluesidonta

Joskus sinun on saatava x:n arvo, jonka on oltava tietyllä alueella. Tarvitsemme esimerkiksi arvon 1-100, mutta saamme arvon 123. Voit korjata tämän käyttämällä min() ( palauttaa pienimmän luvun) ja max ( palauttaa suurimman sallitun määrän).

Käyttö:

var alaraja = 1; var highBound = 100; var numInput = 123; var clamped = Math.max(alaraja, matemaattinen.min(numInput, highBound)); console.log(clamped); > 100;

Voit luoda Numero-luokasta funktion tai laajennuksen.

Tässä artikkelissa tarkastellaan yksityiskohtaisesti numeroita, matemaattisia operaattoreita, tapoja muuntaa luku merkkijonoksi ja päinvastoin sekä monia muita tärkeitä kohtia.

isFinite-funktio

IsFinite-funktiolla voit tarkistaa, onko argumentti äärellinen luku.

Vastauksena tämä funktio palauttaa arvon false, jos argumentti on Infinity, -Infinity, NaN tai se heitetään johonkin näistä erityisistä numeerisista arvoista. Muussa tapauksessa tämä funktio palauttaa tosi.

IsFinite(73); // tosi isFinite(-1/0); // false isFinite(Infinite); // väärä isFinite(NaN); // false isFinite("Teksti"); // väärä

Globaalin isFinite-funktion lisäksi JavaScriptissä on myös Number.isFinite-menetelmä. Toisin kuin isFinite, se ei pakota argumenttia muuttamaan luvuksi.

IsFinite("73"); // tosi Number.isFinite("73"); // väärä

isNaN-funktio

IsNaN-funktio on suunniteltu määrittämään, onko argumentti luku vai voidaanko se muuntaa luvuksi. Jos näin on, isNaN-funktio palauttaa epätosi. Muuten se palaa todeksi.

IsNaN(NaN); //tosi isNaN("25px"); //totta, koska 20px ei ole numero isNaN(25,5); //väärä isNaN("25,5"); //väärä isNaN(" "); //väärin, koska välilyönti tai useita välilyöntejä muunnetaan arvoksi 0 isNaN(null); //väärin, koska nolla muunnetaan arvoksi 0 isNaN(tosi); //väärin, koska tosi muunnetaan 1 isNaN(epätosi); //väärin, koska false muunnetaan 0:ksi

Jos tämä toiminto on suoritettava ilman tyyppisuoraa, käytä Number.isNaN-menetelmää. Tämä menetelmä otettiin käyttöön kielessä alkaen ECMAScript 6:sta.

Kuinka muuntaa merkkijono nimenomaisesti numeroksi?

Voit muuntaa merkkijonon nimenomaisesti numeroksi seuraavilla tavoilla:

1. Käytä yksipuolinen operaattori +, joka on sijoitettava ennen arvoa.

+"7,35"; // 7.35 +"teksti"; // NaN

Tämä menetelmä jättää huomioimatta välilyönnit rivin alussa ja lopussa sekä \n (rivinvaihto).

+" 7,35"; //7.35 +"7.35 \n "; //7.35

Tätä menetelmää käytettäessä sinun on kiinnitettävä huomiota siihen, että tyhjä merkkijono tai merkkijono, joka koostuu välilyönnistä ja \n, muunnetaan luvuksi 0. Lisäksi se muuntaa myös nollatietotyypin ja Boolen arvot numeroiksi .

Tyhjä; //0 +tosi; //1 +false; //0 +" "; //0

2. ParseInt-funktio. Tämä toiminto on suunniteltu muuntamaan argumentti kokonaisluvuksi. Toisin kuin käytössä yksipuolinen operaattori +, tämän menetelmän avulla voit muuntaa merkkijonon numeroksi, jossa kaikki merkit eivät ole numeerisia. Se alkaa muuntaa merkkijonoa ensimmäisestä merkistä alkaen. Ja heti kun se kohtaa ei-numeerisen merkin, tämä toiminto lopettaa toimintansa ja palauttaa tuloksena olevan luvun.

ParseInt("18px"); //18 parseInt("33,3%"); //33

Tämä toiminto voi toimia erilaisten lukujärjestelmien kanssa (binääri, oktaali, desimaali, heksadesimaali). Numerojärjestelmän kanta määritetään kahdella argumentilla.

ParseInt("18px", 10); //18 parseInt("33,3%, 10); //33 parseInt("101",2); //5 parseInt("B5",16); //181

ParseInt-funktion lisäksi JavaScriptillä on Number.parseInt-menetelmä. Tämä menetelmä ei eroa parseInt-funktiosta, ja se lisättiin JavaScriptiin ECMASCRIPT 2015 (6) -spesifikaatiolla.

3. parseFloat-toiminto. ParseFloat-funktio on samanlainen kuin parseInt, paitsi että sen avulla voit muuntaa argumentin murtoluvuksi.

ParseFloat("33,3%"); //33.3

Lisäksi parseFloat-funktiolla, toisin kuin parseIntillä, ei ole kahta argumenttia, ja siksi se yrittää aina käsitellä merkkijonoa numerona desimaalimerkintäjärjestelmässä.

ParseFloat("3.14"); parseFloat("314e-2"); parseFloat("0.0314E+2");

ParseFloat-funktion lisäksi JavaScriptillä on Number.parseFloat-menetelmä. Tämä menetelmä ei eroa parseFloat-funktiosta, ja se lisättiin JavaScriptiin ECMASCRIPT 2015 (6) -spesifikaatiolla.

Luvun muuntaminen merkkijonoksi

Voit muuttaa luvun merkkijonoksi käyttämällä toString-menetelmää.

(12.8).toString(); //"12,8"

ToString-metodin avulla voit myös määrittää numerojärjestelmän perustan, ottaen huomioon, että sinun on muutettava numero nimenomaisesti merkkijonoksi:

(255).toString(16); //"ff"

Kuinka tarkistaa, onko muuttuja numero

Voit määrittää, onko muuttujan arvo numero jollakin seuraavista tavoista:

1. IsNaN- ja isFinite-funktioiden käyttäminen:

// myVar on muuttuja if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //omaMuut on numero tai se voidaan lähettää siihen);

Toiminnona:

// funktiofunktio isNumeric(value) ( ​​return !isNaN(parseFloat(value)) && isFinite(parseFloat(value)); ) // use var myVar = "12px"; console.log(isNumeric(myVar)); //totta

Tämän menetelmän avulla voit määrittää, onko määritetty arvo numero vai voidaanko se muuntaa luvuksi. Tämä vaihtoehto ei laske tyhjää merkkijonoa, välilyöntejä, nollaa, ääretöntä, ääretöntä, tosi ja epätosi numeroina.

2. Operaattorityyppiä ja isFinitea käyttämällä isNaN-funktiot:

// funktio, joka tarkistaa onko arvo numerofunktio isNumber(value) (palautus arvon tyyppi === "number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Tämä toiminto määrittää, onko määritetty arvo tyyppiä Number ja onko se jokin erikoisarvoista Infinity, -Infinity ja NaN. Jos näin on, tämä funktio palauttaa tosi.

3. ECMAScript 6 Number.isInteger(value) -menetelmän käyttäminen. Tämän menetelmän avulla voit määrittää, onko määritetty arvo kokonaisluku.

Number.isInteger("20"); //väärin, koska tämä menetelmä ei muunna merkkijonoa numeroksi Number.isInteger(20); //totta, koska tämä arvo on numero

Parilliset ja parittomat luvut

Voit tarkistaa, onko luku parillinen vai pariton käyttämällä seuraavia toimintoja:

// Parillisen pariteettifunktion luvun tarkistusfunktio isEven(n) ( paluu n % 2 == 0; ) // Pariton pariteettifunktion luvun tarkistusfunktio isOdd(n) ( paluu Math.abs(n % 2) == 1;)

Mutta ennen tällaisen tarkistuksen suorittamista on suositeltavaa varmistaa, että määritetty arvo on numero:

Arvo = 20; if (Luku.isKokonaisluku(arvo)) ( if (onParillinen(arvo)) ( console.log("Luku" + arvo.String() + " - parillinen"); ) )

Alkuluvut Javascriptissä

Katsotaanpa esimerkkiä, jossa näytämme alkuluvut 2-100 Javascriptin avulla.

// Funktio, joka tarkistaa, onko luku alkulukufunktio isPrime(arvo) (if (isNaN(arvo) || !isFinite(arvo) || arvo%1 || arvo< 2) return false; var max=Math.floor(Math.sqrt(value)); for (var i = 2; i< = max; i++) { if (value%i==0) { return false; } } return true; } // создать массив, который будет содержать простые числа от 2 до 100 var primaryNumber = ; for (var i = 2; i <= 100; i++) { if(isPrime(i)) primaryNumber.push(i); } // вывести в консоль простые числа от 2 до 100 console.log(primaryNumber);

Numeron pyöristys Javascriptissä

On olemassa useita tapoja pyöristää murtoluku kokonaislukuun JavaScriptissä.

1. Käytä erityisesti tähän tarkoitukseen suunniteltuja Math.floor-, Math.ceil- ja Math.round-menetelmiä. Math.floor-menetelmä pyöristää murto-osan alaspäin lähimpään kokonaislukuun, ts. yksinkertaisesti hylkää murto-osan. Math.ceil pyöristää murtoluvun ylöspäin lähimpään kokonaislukuun. Math.round pyöristää luvun ylös- tai alaspäin murto-osan arvon mukaan. Jos murto-osa on suurempi tai yhtä suuri kuin 0,5, niin ylös, muuten kierre on alaspäin.

Console.log(Math.floor(7.9)); //7 console.log(Math.ceil(7.2)); //8 console.log(Math.round(7.5)); //8

2. Käyttämällä toFixed(tarkkuus) -menetelmää. Tämä menetelmä pyöristää luvun murto-osan tiettyyn tarkkuuteen. Pyöristystulos palautetaan merkkijonona.

Console.log(7.987.toFixed(2)); //"7,99"

Jos desimaalipisteitä ei ole tarpeeksi luvun määritetyn tarkkuuden muodostamiseksi, se täytetään nolilla.

Console.log(7.987.toFixed(5)); //"7.98700"

3. ToPrecision(accuracy)-menetelmän käyttäminen. Tämä menetelmä edustaa lukua tietyllä tarkkuudella. Samalla hän voi pyöristää paitsi murto-osan myös koko luvun. Tuloksesta riippuen tämä menetelmä voi esittää tuloksena olevan luvun kiinteällä pisteellä tai eksponentiaalisessa muodossa.

Console.log((1001).toPrecision(2)); //"1.0e+3" console.log((1001).toPrecision(5)); //"1001.0" console.log((12.4).toPrecision(1)); //"1e+1" console.log((12.4).toPrecision(2)); //"12" console.log((12.4).toPrecision(3)); //"12.4" console.log((12.4).toPrecision(5)); //"12.400"

4. Käytä loogisia operaattoreita NOT tai OR.

//kaksinkertaisen loogisen negation kautta console.log(~~7.9); //7 // käyttämällä loogista TAI nollaa: console.log(7.9^0); //7

Luvun kokonaisluku ja murto-osa

Voit saada luvun kokonaislukuosan käyttämällä Math.floor()- ja parseInt()-menetelmiä:

Console.log(Math.floor(7.21)); // 7 console.log(parseInt(7.21)); // 7

Voit saada luvun murto-osan käyttämällä prosenttioperaattoria (%). Tämä operaattori palauttaa jäännöksen, joka saadaan jakamalla ensimmäinen luku toisella. Tässä tapauksessa sinun on käytettävä 1:tä toisena numerona.

Console.log(7,21%1); // 0.20999999999999996 // 2 desimaalin tarkkuudella console.log((7.21%1).toFixed(2)); // "0.21"

Lisäksi murto-osa voidaan saada myös laskelmilla:

Muuttujan luku = 7,21; var fractionNumber = numero - Math.floor(Math.abs(luku)); console.log(fractionNumber); // 0.20999999999999996

Onko luku jaollinen kokonaisluvulla?

Voit määrittää, onko luku jaollinen kokonaisluvulla käyttämällä prosenttioperaattoria:

Muuttujan numero = 9; // jos luvun jäännös jaettuna 3:lla on 0, niin kyllä, muuten ei if (luku%3==0) ( console.log ("Luku " + numero + " on jaollinen kolmella"); ) else ( konsoli log("Luku " + numero + " ei ole jaollinen 3:lla");

Numeroiden muotoilu

JavaScriptissä toLocaleString()-menetelmän avulla voit muotoilla numeron tulosteen alueellisten standardien mukaisesti (käyttöjärjestelmän kieliasetukset).

Muotoillaan esimerkiksi numero järjestelmään oletuksena asennettujen alueellisten standardien mukaisesti:

Muuttujan luku = 345,46; console.log(number.toLocaleString()); //"345.46"

Esimerkiksi muotoillaan numero Venäjän alueellisten standardien mukaisesti (ru):

Console.log((108.1).toLocaleString("ru-RU")); //"108.1"

Tätä menetelmää voidaan käyttää myös numeron muotoilemiseen valuutaksi:

Console.log((2540.125).toLocaleString("ru-RU",(tyyli:"valuutta", valuutta:"RUB"))); //"2 540.13 ₽" console.log((89.3).toLocaleString("ru-RU",(tyyli:"valuutta", valuutta:"USD"))); //"89,30 dollaria" console.log((2301.99).toLocaleString("ru-RU",(tyyli:"valuutta", valuutta:"EUR"))); //"2 301,99 €"

Esittää lukua prosentteina:

Console.log((0.45).toLocaleString("ru-RU",(tyyli:"prosentti"))); //"45%"

Jaa luku numeroiksi (useGrouping-ominaisuus):

Console.log((125452.32).toLocaleString("ru-RU",(useGrouping:true))); //"125 452.32"

Tulosta luku, jossa on tietty määrä numeroita (2) desimaalipilkun jälkeen:

Console.log((1240.4564).toLocaleString("ru-RU",(vähimmäismurtonumerot:2, enimmäismurtonumerot:2))); //"1 240,46"

Numeroiden vertailu

Seuraavia operaattoreita käytetään lukujen vertailuun JavaScriptissä: == (saa), != (ei yhtä suuri), > (suurempi kuin),< (меньше), >= (suurempi tai yhtä suuri kuin),<= (меньше или равно).

Verrataan esimerkiksi kahta numeroa:

Console.log(2>3); //false console.log(5>=3); //totta

Kun verrataan lukuja murto-osaan, on otettava huomioon näiden laskelmien aikana mahdollisesti ilmenevät virheet.

Esimerkiksi JavaScriptissä numeroiden summa (0,2 + 0,4) ei ole yhtä suuri kuin 0,6:

Console.log((0,2+0,4)==0,6); //väärä

Virheitä ilmenee, koska tietokone tai muu elektroninen laite suorittaa kaikki laskut 2. numerojärjestelmässä. Nuo. Ennen toimintojen suorittamista tietokoneen on ensin muutettava lausekkeessa esitetyt luvut 2. numerojärjestelmään. Mutta jokaista desimaalilukua ei voida esittää tarkasti 2. numerojärjestelmässä.

Esimerkiksi luku 0,25 10 muunnetaan täsmälleen binääriarvoksi.

0,125 × 2 = 0,25 | 0 0,25 × 2 = 0,5 | 0 0,5 × 2 = 1 | 1 0,125 10 = 0,001 2

Esimerkiksi luku 0,2 10 voidaan muuntaa 2-järjestelmäksi vain tietyllä tarkkuudella:

0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 ... 0,2 10 = 0,001100110011... 2

Tämän seurauksena nämä virheet vaikuttavat kahden luvun summan laskemiseen ja vertailutuloksiin. Nuo. Osoittautuu, että JavaScript itse asiassa näkee tämän merkinnän seuraavasti:

0.6000000000000001==0.6

Kun lasket tai näytät lukuja murto-osilla, sinun on aina ilmoitettava, millä tarkkuudella haluat tehdä sen.

Vertaa esimerkiksi lukuja enintään 2 desimaalin tarkkuudella käyttämällä toFixed()- ja toPrecision()-menetelmiä:

//method toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //method to Precision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //totta

Matemaattiset perustoiminnot

Seuraavat matemaattiset operaattorit ovat JavaScriptissä: + (lisäys), - (vähennys), * (kerto), / (jako), % (modulo), ++ (lisää arvoa yhdellä), -- (pienennä arvoa 1).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, so. 6:3=2 => 6-3*2 => lepo(0) 5%2 //1, ts. 5:2=2(.5) => 5-2*2 => lepo(1) 7.3%2 //1.3, so. 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //%-operaation tuloksen etumerkki on yhtä suuri kuin ensimmäisen arvon etumerkki -9%2.5 //-1.5 , eli 9:2.5=3(.6) => 9-2.5*3 => lepo(1.5) -9%-2.5 //-1.5, so. 9:2.5=3(.6) => 9-2.5*3 => lepo(1.5) -2%5 //-2, so. 2:5=0(.4) => 2-5*0 => lepo(2) x = 3; console.log(x++); //tulostaa 3, sitten asettaa 4 console.log(x); //4 x = 3; konsoli.log(++x); //asettaa 4 ja tulostaa x = 5; console.log(x--); //tulostaa 5 ja asettaa sitten 4 console.log(x); //4 x = 5; console.log(--x); //asettaa 4 ja tulostaa Lisäksi JavaScriptissä on yhdistelmäoperaattoreita: x+=y (x=x+y), x-=y (x=x-y), x*=y (x=x*y), x/= y (x=x/y), x%=y (x=x%y). x = 3; y = 6; x+=y; console.log(x); //9 x = 3; y = 6; x-=y; console.log(x); //-3 x = 3; y = 6; x*=y; console.log(x); //18 x = 3; y = 6; x/=y; console.log(x); //0,5 x = 3; y = 6; x%=y; console.log(x); //3

Hei JavaScriptin ystävät. Olet jo huomannut, että tämä kieli on erittäin poikkeuksellinen ja jokaisessa osiossa se erottuu ominaisuuksistaan ​​ja epätavallisista teknisistä ratkaisuistaan. Siksi tämän päivän julkaisu on omistettu aiheelle: "JavaScriptin pyöristäminen".

Luettuasi tämänhetkisen artikkelin opit, miksi lukuja on pyöristettävä, mitkä menetelmät ja ominaisuudet js:ssä suorittavat tämän toiminnon, ja myös mikä erottaa jakamisen nollalla. Muuttamatta periaatteitani, liitän esimerkkejä luvun avainkohtiin. materiaalia ja kuvaile jokainen toimenpide yksityiskohtaisesti. Nyt aloitetaan oppiminen!

Tärkeitä huomautuksia numeroista

Muista ensin, että js:ssä kaikki luvut (murto- ja kokonaisluvut) kuuluvat tyyppiin Määrä. Lisäksi ne ovat kaikki 64-bittisiä, koska ne on tallennettu "double precision" -muotoon, joka tunnetaan myös IEEE-754-standardina.

Numeeriset muuttujat luodaan tavalliseen tapaan:

var numb = 35; // luonnollinen luku

var drob = 0,93; //desimaaliesitys

var numb16 = 0xFF; //Heksadesimaalilukujärjestelmä

Tukee muita numeerisia esityksiä. Joten voit myös luoda liukulukuja (niitä kutsutaan joskus "tieteellisiksi luvuiksi").

Nyt on olemassa tuki erittäin mielenkiintoiselle menetelmälle toLocaleString(), joka muotoilee kaikki numeeriset parametrit ECMA 402:n määrittelyjen mukaisesti. Tämän ansiosta suuret numerot, puhelinnumerot, valuutat ja jopa prosentit näkyvät kauniisti valintaikkunassa.

var num = 714000,80;

alert(num.toLocaleString());

Number-tyypin elementtien kanssa työskentelyä varten koko globaali objekti varustettiin joukolla erilaisia ​​matemaattisia funktioita, joiden nimi Matematiikka.

Lisäksi on olemassa muita menetelmiä, joilla numeeriset arvot pyöristetään kokonaislukuihin, kymmenesosiin, sadasosiin jne. Katsotaanpa niitä kaikkia yksityiskohtaisemmin.

Suuri ja mahtava matematiikka

Globaali Math-objekti sisältää valtavan valikoiman matemaattisia ja trigonometrisiä funktioita. Tämä on erittäin tarpeellinen kohde ja auttaa usein kehittäjiä työskennellessään digitaalisten tietojen kanssa.

Matematiikasta on analogeja muilla alustoilla. Esimerkiksi suosituilla kielillä, kuten Java ja C#, Math on luokka, joka tukee kaikkia samoja vakiotoimintoja. Joten kuten näet, tämä instrumentti on todella mahtava ja voimakas.

Nyt haluan käydä läpi tietyt pyöristämisestä vastaavat menetelmät ja puhua niistä yksityiskohtaisesti.

Math.floor()

Aloitan siitä Matematiikka.lattia. Kiinnitä huomiota menetelmän nimeen. Loogisesti käy selväksi, että koska puhumme pyöristyksestä ja sanan "lattia" kirjaimellinen käännös tarkoittaa "lattia", tämä työkalu pyöristää käsitellyt arvot alaspäin.

On myös mahdollista, että tällä funktiolla käsitelty numero pysyy samana. Tämä johtuu siitä, että pyöristys suoritetaan ei-tiukan epätasa-arvon mukaan (<=). Таким образом, при отработке этой строчки кода:

hälytys(Math.floor(4.5));

vastaus on numero 4.

Math.ceil()

Katso uudelleen nimeä (näin materiaali imeytyy nopeammin). Jos joku ei tiedä, "katto" tarkoittaa "kattoa". Tämä tarkoittaa, että numeeriset tiedot pyöristetään ylöspäin käyttämällä ei-tiukkaa epäyhtälöä (>=).

hälytys(Math.ceil(4.5));

Kuten ehkä arvasit, vastaus on numero 5.

Math.round()

Tämä menetelmä pyöristää murtoluvun lähimpään kokonaislukuun. Joten jos murto-osa on alueella 0 - 0,5, ei sisällä, pyöristetään pienempään arvoon. Ja jos murto-osa on alueella 0,5 mukaan lukien seuraavaan kokonaislukuun, se pyöristetään ylöspäin suurempaan kokonaislukuun.

hälytys(Math.round(4.5));

Toivottavasti kaikki ajattelivat tai sanoivat, että oikea vastaus on 5.

Muutama menetelmä lisää

JavaScriptillä on myös kaksi muuta menetelmää, jotka käsittelevät numeeristen esitysten pyöristämistä. Ne ovat kuitenkin hieman erilaisia.

Puhumme työkaluista, kuten tofixed() Ja tarkkuus(). He eivät ole vastuussa vain pyöristyksestä, vaan sen tarkkuudesta tiettyihin merkkeihin. Kaivetaan syvemmälle.

tofixed()

Tällä mekanismilla voit määrittää, kuinka moneen desimaaliin arvo pyöristetään. Metodi palauttaa tuloksen merkkijonona. Alla olen liittänyt vaihtoehdon, jossa on kolme eri vaihtoehtoa. Analysoi saadut vastaukset.

var num = 5656,9393;

document.writeln(num.toFixed()); // 5657

document.writeln(nm.toFixed(2)); // 5656.94

document.writeln(nm.toFixed(7)); // 5656.9393000

Kuten näet, jos et määritä argumenttia, toFixed ()) pyöristää murtoluvun kokonaisuuteen numeroita. Kolmas rivi on pyöristetty enintään 2 merkkiä, ja neljännessä parametrin "7" vuoksi lisättiin kolme muuta nollaa.

tarkkuus()

Tämä menetelmä toimii hieman eri tavalla. Argumentin sijasta voit joko jättää tyhjän tilan tai asettaa parametrin. Jälkimmäinen kuitenkin pyöristää luvut määritettyyn määrään numeroita pilkusta riippumatta. Tässä ovat ohjelman tuottamat tulokset, jotka on kirjoitettu uudelleen edellisestä esimerkistä:

var num = 5656,9393;

document.writeln(num.toPrecision()); // 5656.9393

document.writeln(num.toPrecision(2)); // 5,7e+3

document.writeln(num.toPrecision(7)); // 5656.939

Ominaisuus jakaa 0:lla js:ssä

Kuten matematiikan tunneista tiedät, et voi jakaa nollalla. Useimmat ohjelmointikielten luojat ottivat tämän säännön perustana. Siksi kaikki ohjelmat luovat virheen, kun jaetaan nollalla.

JavaScript on kuitenkin erinomainen tässäkin. Joten tällaisen toiminnon suorittamisen aikana ei tule virheilmoituksia... koska tällainen toiminto palaa "ääretön"!

Miksi näin on? Kuten samoista matemaattisista tieteistä tiedetään, mitä pienempi jakaja, sitä suurempi luku saadaan. Siksi tämän prototyyppisuuntautuneen kielen luojat päättivät hylätä mallit ja kulkea omaa tietä.

Niille, jotka kohtaavat Infinity-arvon ensimmäistä kertaa, olen selittänyt sen ominaisuuksia alla.

Infinity – tarkoittaa ääretöntä ja vastaa täysin matemaattista merkkiä ∞.

Voi olla negatiivinen. Myös kaikki aritmeettisten operaattoreiden kanssa työskentelyn vakiosäännöt säilyvät.

hälytys (12/ 0); // Ääretön

hälytys(12.34/ 0); // Ääretön

hälytys (-3/0); // - Ääretön

Taidan lopettaa tähän. Jos pidit julkaisusta, muista tilata blogini. Älä ahne linkkejä kiinnostaviin artikkeleihin ja jaa ne ystäviesi kanssa. Hei hei!

JavaScript-matematiikka, pyöristys kahteen desimaaliin (9)

Minulla on seuraava JavaScript-syntaksi:

Muutt alennus = Math.round(100 - (hinta / listahinta) * 100);

Tämä pyöristetään lähimpään kokonaislukuun. Kuinka voin palauttaa tuloksen kahdella desimaalilla?

Tässä toimiva esimerkki

Muuttujan arvo = 200,2365455; tulos=Math.round(arvo*100)/100 //tulos on 200.24

Pyöristyksen käsittelemiseksi mihin tahansa määrään desimaaleja riittää useimpiin tarpeisiin funktio, jossa on 2 riviä koodia. Tässä on pelin esimerkkikoodi.

Var testiNum = 134,9567654; var decPl = 2; var testiRes = roundDec(testNum,decPl); alert(testNum + " pyöristetty " + decPl + " desimaaleihin on " + testRes); funktio roundDec(nbr,dec_places)( var mult = Math.pow(10,dec_places); return Math.round(nbr * mult) / mult; )

Paras ja yksinkertaisin ratkaisu jonka löysin on tämä

Funktio round(arvo, desimaalit) ( return Number(Math.round(arvo+"e"+desimaalit)+"e-"+desimaalit); ) round(1.005, 2); // 1.01

Pieni vaihtelu hyväksyttyyn vastaukseen. toFixed(2) palauttaa merkkijonon ja saat aina kaksi desimaaleja. Nämä voivat olla nollia. Jos haluat estää loppunollat, tee tämä:

Muutt-alennus = + ((hinta / listahinta).kiinteään(2));

Muokattu: Löysin juuri virheen Firefox 35.0.1:ssä, mikä tarkoittaa, että yllä oleva saattaa antaa NaN:lle joitain arvoja.
Vaihdoin koodini muotoon

Muutt alennus = Math.round(hinta / listahinta * 100) / 100;

Tämä antaa luvun kahden desimaalin tarkkuudella. Jos tarvitset kolme, kerrot ja jaat 1000:lla ja niin edelleen.
OP haluaa aina kahden desimaalin, mutta jos toFixed() on rikki Firefoxissa, se on ensin korjattava.
Katso https://bugzilla.mozilla.org/show_bug.cgi?id=1134388

Voit saada tuloksen kahdella desimaalilla seuraavasti:

Muutt-alennus = Math.round((100 - (hinta / listahinta) * 100) * 100) / 100;

Pyöristettävä arvo kerrotaan 100:lla, jotta kaksi ensimmäistä numeroa säilyy, ja jaetaan sitten 100:lla saadaksesi todellisen tuloksen.

Mielestäni paras tapa, jonka olen nähnyt, on kertoa 10:llä numeroiden määrällä, suorittaa sitten Math.round ja lopuksi jakaa 10:llä numeroiden lukumäärällä. Tässä on yksinkertainen funktio, jota käytän konekirjoituksessa:

Funktio roundToXDigits(arvo: numero, numerot: numero) ( arvo = arvo * Math.pow(10, numeroa); arvo = Math.round(arvo); arvo = arvo / Math.pow(10, numeroa); paluuarvo; )

Tai yksinkertainen javascript:

Funktio roundToXDigits(arvo, numerot) ( if(!numerot)( numerot = 2; ) arvo = arvo * Math.pow(10, numeroa); arvo = Math.round(arvo); arvo = arvo / Math.pow(10 , numerot)

HUOMAUTUS. - Katso Edit 4, jos 3-numeroinen tarkkuus on tärkeää.

Muutt-alennus = (hinta / listahinta).toFixed(2);

Kiinteät pyöristykset ylös tai alas puolestasi riippuen arvoista, jotka ovat suurempia kuin 2 desimaalin tarkkuutta.

Muuttaa. Kuten muut ovat maininneet, tämä muuntaa tuloksen merkkijonoksi. Tämän välttämiseksi:

Muutt-alennus = +((hinta / listahinta).kiinteään(2));

Editointi 2- Kuten kommenteissa mainittiin, tämä toiminto ei toimi tietyllä tarkkuudella, esimerkiksi tapauksessa 1.005 se palauttaa 1.00 arvon 1.01 sijaan. Jos tarkkuus on niin tärkeää, löysin tämän vastauksen: https://.com/a/32605063/1726511 Joka näyttää toimivan hyvin kaikissa kokeilemissani testeissä.

Yksi pieni muutos tarvitaan, mutta yllä olevan vastauksen funktio palauttaa kokonaislukuja pyöristettynä yhteen, joten esimerkiksi 99.004 palauttaisi arvon 99 99.00:n sijaan, mikä ei ole ihanteellinen hintojen näyttämiseen.

Muokkaa 3- Näyttää siltä, ​​että toFixed varsinaiseen STILL-palautukseen sotki joitakin numeroita, tämä viimeinen muokkaus näyttää toimivan. Voi kuinka paljon korvauksia!

Muutt alennus = roundTo((hinta / listahinta), 2); funktio roundTo(n, numerot) ( if (numerot === määrittelemätön) ( numerot = 0; ) var kertoja = Math.pow(10, numerot); n = parseFloat((n * kertoja).toFixed(11)); var testi =(Math.round(n) / kertoja return +(test.toFixed(digits));

Muokkaa 4- Te tapatte minut. Muokkaus 3 epäonnistuu negatiivisissa luvuissa pohtimatta sitä, miksi on helpompi tehdä negatiivinen luku positiiviseksi ennen pyöristystä ja muuttaa se sitten takaisin ennen tuloksen palauttamista.

Funktio roundTo(n, numerot) ( var negatiivinen = epätosi; if (numerot === määrittelemätön) ( numerot = 0; ) if(n< 0) { negative = true; n = n * -1; } var multiplicator = Math.pow(10, digits); n = parseFloat((n * multiplicator).toFixed(11)); n = (Math.round(n) / multiplicator).toFixed(2); if(negative) { n = (n * -1).toFixed(2); } return n; }

Nopein tapa- nopeampi kuin toFixed():

KAKSI TARRAA

x = .123456 tulos = Math.round(x * 100) / 100 // tulos .12

KOLME DESIMAALIA

x = .123456 tulos = Math.round(x * 1000) / 1000 // tulos .123

Funktio pyöreä(nm,dec) ( num = Math.round(num+"e"+dec) return Number(nm+"e-"+dec) ) //Pyöristys valitsemaasi desimaaliin: round(1.3453,2)