Parsefloat javascript 2 decimalna mjesta. Metode zaokruživanja brojeva u JavaScriptu. Zaokružite na najbliži broj

JavaScript matematika, zaokruživanje na dvije decimale (9)

Imam sljedeću JavaScript sintaksu:

Var popust = Math.round(100 - (cijena / maloprodajna cijena) * 100);

Ovo se zaokružuje na najbliži cijeli broj. Kako mogu vratiti rezultat s dvije decimale?

Evo primjera rada

Promjenjiva vrijednost=200,2365455; rezultat=Math.round(value*100)/100 //rezultat će biti 200,24

Za rukovanje zaokruživanjem na bilo koji broj decimalnih mjesta, funkcija s 2 retka koda bit će dovoljna za većinu potreba. Ovdje je primjer koda za igru.

Var testNum = 134,9567654; var decPl = 2; var testRes = roundDec(testNum,decPl); upozorenje(testNum + " zaokruženo na " + decPl + " decimalna mjesta su " + testRes); funkcija roundDec(nbr,dec_places)( var mult = Math.pow(10,dec_places); return Math.round(nbr * mult) / mult; )

Najbolje i najjednostavnije rješenje koje sam pronašao je ovo

Funkcija round(vrijednost, decimale) ( return Broj(Math.round(value+"e"+decimale)+"e-"+decimale); ) round(1.005, 2); // 1.01

Mala varijacija prihvaćenog odgovora. toFixed(2) vraća niz i uvijek ćete dobiti dva decimalna mjesta. To mogu biti nule. Ako želite potisnuti nule na kraju, samo učinite ovo:

Promjenljivi popust = + ((cijena / maloprodajna cijena).toFixed(2));

Uređeno: upravo sam otkrio nešto što se čini kao greška u Firefoxu 35.0.1, što znači da gore navedeno može dati NaN neke vrijednosti.
Promijenio sam svoj kod u

Var popust = Math.round(cijena / maloprodajna cijena * 100) / 100;

To daje broj točan na dvije decimale. Ako vam treba tri, pomnožit ćete i podijeliti s 1000, i tako dalje.
OP uvijek želi dva decimalna mjesta, ali ako je toFixed() pokvaren u Firefoxu, to prvo treba popraviti.
Pogledajte https://bugzilla.mozilla.org/show_bug.cgi?id=1134388

Da biste dobili rezultat s dva decimalna mjesta, možete učiniti sljedeće:

Var popust = Math.round((100 - (cijena / maloprodajna cijena) * 100) * 100) / 100;

Vrijednost koju treba zaokružiti množi se sa 100 kako bi se zadržale prve dvije znamenke, zatim dijelimo sa 100 kako bismo dobili stvarni rezultat.

ja mislim da Najbolji način onaj koji sam vidio je množenje s 10 s brojem znamenki, zatim izvođenje Math.rounda i zatim konačno dijeljenje s 10 s brojem znamenki. Evo jednostavne funkcije koju koristim u tipkopisu:

Funkcija roundToXDigits(vrijednost: broj, znamenke: broj) ( vrijednost = vrijednost * Math.pow(10, znamenke); vrijednost = Math.round(vrijednost); vrijednost = vrijednost / Math.pow(10, znamenke); povratna vrijednost; )

Ili jednostavan javascript:

Funkcija roundToXDigits(value, digits) ( if(!digits)( digits = 2; ) value = value * Math.pow(10, digits); value = Math.round(value); value = value / Math.pow(10) , znamenke);

BILJEŠKA. - Pogledajte Uredi 4 ako je 3-znamenkasta preciznost važna.

Var popust = (cijena / maloprodajna cijena).toFixed(2);

toFixed zaokružuje prema gore ili dolje za vas ovisno o vrijednostima većim od 2 decimalna mjesta.

Promijeniti. Kao što su drugi spomenuli, ovo pretvara rezultat u niz. Da biste to izbjegli:

Var popust = +((cijena / maloprodajna cijena).toFixed(2));

Uređivanje 2- Kao što je spomenuto u komentarima, ova funkcija ne radi s nekom preciznošću, na primjer, u slučaju 1.005 vratit će 1.00 umjesto 1.01. Ako je točnost toliko važna, pronašao sam ovaj odgovor: https://.com/a/32605063/1726511 Čini se da dobro funkcionira sa svim testovima koje sam isprobao.

Potrebna je jedna manja izmjena, ali funkcija u gornjem odgovoru vraća cijele brojeve kada se zaokruži na jedan, pa bi na primjer 99,004 vratilo 99 umjesto 99,00, što nije idealno za prikaz cijena.

Uredi 3- Čini se da je toFixed na stvarnom STILL povratu zeznuo neke brojke, čini se da ovo konačno uređivanje funkcionira. Bože, tolika odšteta!

Var popust = roundTo((cijena / maloprodajna cijena), 2); funkcija roundTo(n, znamenke) ( if (znamenke === nedefinirano) ( znamenke = 0; ) var multiplicator = Math.pow(10, znamenke); n = parseFloat((n * multiplicator).toFixed(11)); var test =(Math.round(n) / multiplicator) return +(test.toFixed(digits));

Uredi 4- Vi me ubijate. Uređivanje 3 ne uspijeva na negativnim brojevima bez kopanja zašto je lakše negativni broj učiniti pozitivnim prije zaokruživanja, a zatim ga promijeniti natrag prije vraćanja rezultata.

Funkcija roundTo(n, digits) ( var negative = false; if (digits === undefined) ( digits = 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; }

Najbrži način- brže od toFixed():

DVIJE NALJEPNICE

TRI DECIMALNOSTI

Funkcija round(num,dec) ( num = Math.round(num+"e"+dec) return Number(num+"e-"+dec) ) //Zaokruži na decimalu po svom izboru: round(1.3453,2)

Zašto je potrebno zaokruživanje?

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
U praktične svrhe, ova netočnost nije bitna, u našem slučaju govorimo o pogrešci u kvintilijunskim dijelovima, međutim, to bi neke moglo razočarati. Također možemo dobiti pomalo čudne rezultate kada radimo s brojevima koji predstavljaju valute, postotke ili veličine datoteka. Da bismo ispravili ove netočnosti, samo trebamo moći zaokružiti rezultate, a dovoljno je postaviti decimalnu preciznost.

Zaokruživanje brojeva ima praktičnu upotrebu, možda manipuliramo brojem unutar nekog raspona, na primjer, želimo zaokružiti vrijednost na najbliži cijeli broj umjesto da radimo samo s decimalnim dijelom.

Zaokruživanje decimalnih brojeva

1. Ako argument nije definiran za toFixed(), tada će biti postavljen na nulu, što znači da argument ima 0 decimalnih mjesta maksimalna vrijednost, jednako 20.
2. Ako toPrecision nema argumenta, broj ostaje netaknut

Neka je randNum = 6,25; pusti zaokruženo = randNum.toFixed(); // "6" console.log(randNum + rounded); > "6.256"
Ako želite da rezultat bude numerički tip podataka, tada ćete morati koristiti parseFloat:

Neka je randNum = 6,25; pusti zaokruženo = parseFloat(randNum.toFixed(1)); console.log(zaokruženo); > 6.3
Imajte na umu da su vrijednosti 5 zaokružene osim u rijetkim slučajevima.

Metode toFixed() i toPrecision() korisne su jer ne samo da mogu odrezati razlomak, već i dodati decimalna mjesta, što je zgodno kada radite s valutom:

Neka cijeliNum = 1 neka dolaraCenti = cijeliNum.toFixed(2); console.log(dolarsCents); > "1,00"
Imajte na umu da će toPrecision dati rezultat u znanstvenom zapisu ako je broj cijelih brojeva veći od same preciznosti:

Neka je num = 123.435 num.toPrecision(2); > "1.2e+2"

Kako izbjeći pogreške zaokruživanja s decimalama

Neka je numTest = 1,005; numTest.toFixed(2); > "1,00"
Rezultat gornjeg izračuna trebao je biti 1,01, a ne 1. Ako želite izbjeći sličnu pogrešku, možemo upotrijebiti rješenje koje je predložio Jack L Moore, a koje za izračun koristi eksponencijalne brojeve:

Funkcija round(value, decimales) ( return Number(Math.round(value+"e"+decimales)+"e-"+decimales); )
Sada:

Okrugli (1.005,2); > 1.01
Ako želite robusnije rješenje od gore prikazanog, možete otići na MDN.

Strojno ipsilon zaokruživanje

0,1 + 0,2 === 0,3 > netočno
Koristimo Math.EPSILON u našoj funkciji da bismo dobili valjanu usporedbu:

Funkcija epsEqu(x, y) ( return Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Funkcija prima dva argumenta: prvi je trenutni izračun, drugi je očekivani rezultat. Vraća usporedbu to dvoje:

EpsEqu(0,1 + 0,2, 0,3) > točno
Svi moderni preglednici već podržavaju ES6 matematičke funkcije, ali ako želite podršku u preglednicima kao što je IE 11, koristite polyfills.

Obrezivanje frakcijskog dijela

Funkcija truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3.1416) > 3.14
Ako želite prilagoditi metodu bilo kojem broju decimalnih mjesta, možete upotrijebiti bitnu dvostruku negaciju:

Funkcija truncated(num, decimalPlaces) ( let numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Sada:

Neka je randInt = 35,874993; skraćeno(randInt,3); > 35.874

Zaokružite na najbliži broj

Math.round(4.3) > 4 Math.round(4.5) > 5
Imajte na umu da se "polovica vrijednosti", 0,5, zaokružuje prema matematičkim pravilima.

Zaokružite prema dolje na najbliži cijeli broj

Math.floor(42.23); > 42 Math.floor(36.93); > 36
Imajte na umu da zaokruživanje naniže funkcionira za sve brojeve, uključujući negativne brojeve. Zamislite neboder s beskonačnim brojem katova, uključujući katove na donjoj razini (koji predstavljaju negativne brojeve). Ako ste u dizalu na najnižoj razini između 2 i 3 (što predstavlja vrijednost od -2,5), Math.floor će vas odvesti do -3:

Math.floor(-2,5); > -3
Ali ako želite izbjeći ovu situaciju, koristite Math.trunc, podržan u svim modernim preglednicima (osim IE/Edge):

Math.trunc(-41,43); > -41
Na MDN-u ćete pronaći polifill koji će pružiti podršku za Math.trunc u preglednicima i IE/Edge.

Zaokružite na najbliži cijeli broj

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

Zaokruživanje gore/dole na traženi broj

Funkcija roundTo5(num) ( return Math.round(num/5)*5; )
Sada:

Zaokruži na 5(11); > 10
Ako želite zaokružiti na višekratnike svoje vrijednosti, koristimo općenitiju funkciju, prosljeđujući početnu vrijednost i višekratnik:

Funkcija roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )
Sada:

Neka je početniBroj = 11; neka je višestruko = 10; zaokružiNaViše(početniBroj, višestruko); > 10;

Popravljanje broja u rasponu

Neka je niska granica = 1; neka je visoka granica = 100; neka je numInput = 123; let clamped = Math.max(lowBound, Math.min(numInput, highBound)); konzola.log(stegnut); > 100;
Opet, možemo ponovno upotrijebiti operaciju i zamotati cijelu stvar u funkciju, koristeći rješenje koje je predložio Daniel X. Moore:

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

NumInput.clamp(lowBound, highBound); > 100;

Gaussovo zaokruživanje

Funkcija gaussRound(num, decimalPlaces) ( neka d = decimalPlaces || 0, m = Math.pow(10, d), n = +(d ? num * m: num).toFixed(8), i = Math.floor (n), f = n - i, e = 1e-8, r = (f > 0,5 - e && f< 0.5 + e) ? ((i % 2 == 0) ? i: i + 1) : Math.round(n); return d ? r / m: r; }
Sada:

GaussRound(2,5) > 2 GaussRound(3,5) > 4 GaussRound(2,57,1) > 2,6
Decimala u CSS-u:

Budući da se JavaScript često koristi za stvaranje pozicijskih mapiranja za HTML elemente, možda se pitate što bi se dogodilo da generiramo decimalne vrijednosti za naše elemente:

#box ( width: 63.667731993px; )
Dobra vijest je da će moderni preglednici poštovati decimalne vrijednosti u blok modelu, uključujući postotak ili pikselske jedinice.

Sortiranje

Sortiranje po abecedi

Let fruit = ["butternut squash", "apricot", "cantaloupe"]; voće.sort(); > "marelica", "butternut squash", "cantaloupe"]
Međutim, nailazimo na problem čim je jedan od elemenata napisan velikim slovima:

Let fruit = ["butternut squash", "apricot", "Cantalope"]; voće.sort(); > "dinja", "marelica", "butternut squash"]
To je zato što, prema zadanim postavkama, sorter uspoređuje prvi znak predstavljen u Unicodeu. Unicode je jedinstveni kod za bilo koji simbol, bez obzira na platformu, bez obzira na program, bez obzira na jezik. Na primjer, ako pogledate tablicu kodova, znak "a" ima vrijednost U+0061 (u heksadecimalnom obliku 0x61), dok znak "C" ima kod U+0043 (0x43), koji dolazi ranije u Unicodeu tablicu nego znak "a".

Da bismo razvrstali niz koji može sadržavati mješovita prva slova, moramo sve elemente privremeno pretvoriti u mala slova ili definirati naš redoslijed sortiranja pomoću metode localeCompare() s nekim argumentima. U pravilu je za takav slučaj bolje odmah stvoriti funkciju za ponovnu upotrebu:

Funkcija alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("sensitivity": "base")); )); ) let fruit = ["butternut squash" ", "marelica", "Dinja"]; alphaSort(voće) >
Ako želite da je niz poredan obrnutim abecednim redom, jednostavno zamijenite položaje a i b u funkciji:

Funkcija alphaSort(arr) ( arr.sort(function (a, b) ( return b.localeCompare(a, "en", ("sensitivity": "base")); )); ) let fruit = ["butternut squash" ", "marelica", "Dinja"]; alphaSort(voće) > ["Cantaloupe", "butternut squash", "apricot"]
Ovdje je vrijedno napomenuti da se localeCompare koristi s argumentima, također moramo zapamtiti da ga podržava IE11+, za starije verzije IE-a, možemo ga koristiti bez argumenata, i malim slovima:

Funkcija caseSort(arr) ( arr.sort(funkcija (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) let fruit = ["butternut squash", "apricot", "Dinja"]; caseSort(fruit) > ["apricot", "butternut squash", "Cantaloupe"]

Numeričko sortiranje

Neka HighScores = ; highScores.sort(); >
Stvar je u tome što metoda sort() izvodi leksikografsku usporedbu: što znači da će se brojevi pretvoriti u niz, a usporedbe će se opet napraviti podudaranjem prvog znaka tog niza u redoslijedu znakova u Unicode tablici . Stoga ponovno moramo definirati naš redoslijed sortiranja:

Neka HighScores = ; highScores.sort(function(a,b) ( return a - b; )); >
Opet, za sortiranje brojeva obrnutim redoslijedom, zamijenite položaje a i b u funkciji.

Razvrstavanje strukture slične JSON-u

Neka rezultati = [ ( "ime": "Daniel", "rezultat": 21768), ( "ime": "Michael", "rezultat": 33579), ( "ime": "Alison", "rezultat": 38395 )];
U ES6+ možete koristiti funkcije strelica:

Scores.sort((a, b) => b.score - a.score));
Za starije preglednike koji nemaju ovu podršku:

Scores.sort(function(a, b) ( return a.score - b.score ));
Kao što vidite, sortiranje u JavaScriptu je prilično nejasna stvar, nadam se da će vam ovi primjeri nekako olakšati život.

Rad s funkcijama snage

U JavaScriptu funkcija snage uveden kao Math.pow(), novi ES7 standard uveo je novi operator stepenovanja, " * * ".

Potenciranje

Math.pow(3,2) > 9
Ovaj oblik zapisa znači 3 na kvadrat, ili 3 × 3, što dovodi do rezultata 9. Može se dati još jedan primjer, naravno:

Math.pow(5,3); > 125
To jest, 5 kubnih, ili 5 × 5 × 5, jednako je 125.

ECMAScript 7 je sljedeća verzija JavaScripta, u načelu, možemo koristiti novi predloženi operator stepenovanja - * *, ovaj oblik notacije može biti opisniji:

3 ** 2 > 9
Na ovaj trenutak Podrška za ovog operatera je prilično ograničena, stoga se ne preporučuje njegovo korištenje.

Funkcija napajanja može biti korisna u raznim situacijama. Jednostavan primjer, izračunavanje broja sekundi u satu: Math.pow (60,2).

Kvadratni i kubni korijeni

Math.sqrt(9) > 3
U isto vrijeme, kubni korijen od a je broj koji daje a kada se podigne na kub.

Math.cbrt(125) > 5
Math.cbrt() tek je nedavno uveden u specifikaciju JavaScripta i stoga je podržan samo u modernim preglednicima: Chrome 38+, Firefox i Opera 25+ i Safari 7.1+. Primijetit ćete to Internet Explorer nije na ovom popisu, ali pronaći ćete polifil na MDN-u.

Primjeri

Math.pow(1.25, 2); > 1,5625 Math.cbrt(56,57) > 3,8387991760286138
Imajte na umu da ovo radi prilično dobro kada se koristi negativne vrijednosti argumenti:

Math.pow(-5,2) > 25 Math.pow(10,-2) > 0,01
Međutim, ovo neće raditi za kvadratni korijen:

Math.sqrt(-9) > NaN
Iz matematičke analize znamo da se imaginarni broj odnosi na kvadratni korijen negativnih brojeva. I ovo nas može dovesti do druge tehnike za rad sa kompleksnim brojevima, ali to je druga priča.

Možete koristiti razlomke u Math.pow() da pronađete kvadratne i kubne korijene brojeva. Kvadratni korijen koristi eksponent od 0,5:

Math.pow(5, 0,5); // = Math.sqrt(5) = 5 ** (1/2) > 2,23606797749979
Međutim, zbog hirova pomičnog zareza, ne možete točno pogoditi točan rezultat:

Math.pow(2,23606797749979,2) > 5,000000000000001
U takvim situacijama morat ćete pribjeći odsijecanju znakova iz broja ili zaokruživanju na neku vrijednost.

Neki ljudi, iz nepoznatih razloga, u JavaScriptu brkaju funkciju Math.pow() s Math.exp(), koja je eksponencijalna funkcija za brojeve općenito. Napomena: u Engleski jezik"exponent" se prevodi kao "eksponent", pa je vjerojatnije da se ovo odnosi na govornike engleskog jezika, iako postoje alternativni nazivi za eksponent, kao što su indeks, snaga.

Matematičke konstante

Math.abs, parseInt, parseFloat

Math.abs()

Neka je newVal = -57,64; Math.abs(newVal); > 57,64
Math.abs(0) uvijek vraća nulu, ali ako stavimo znak minus ispred funkcije -Math.abs(NUM) uvijek ćemo dobiti negativnu vrijednost.

Math.abs(0); > -0

parseInt()

Sintaksa: parseInt(string, radix);

Funkcija parseInt pretvara prvi argument koji joj je proslijeđen u vrstu niza, interpretira ga i vraća cijeli broj ili NaN vrijednost. Rezultat (ako nije NaN) je cijeli broj i prvi je argument (string), koji se tretira kao broj u navedenom radixu. Na primjer, baza 10 označava pretvorbu iz decimalnog, 8 iz oktalnog, 16 iz heksadecimalnog i tako dalje. Ako je baza veća od 10, tada se slova koriste za predstavljanje brojeva većih od 9. Na primjer, za heksadecimalne brojeve (baza 16) koriste se slova od A do F.

Pogledajmo primjer rada s CSS svojstvima, gdje, relativno govoreći, možemo dobiti sljedeću vrijednost:

Neka elem = document.body; neka centerPoint = window.getComputedStyle(elem).transformOrigin; > "454px 2087.19px"
Vrijednosti možemo podijeliti razmacima:

Neka središta = centerPoint.split(" "); > ["454px", "2087.19px"]
Međutim, svaki element je i dalje niz, možemo se toga riješiti pomoću naše funkcije:

Neka centerX = parseInt(centri, 10); > 454 neka centerY = parseInt(centri, 10); >2087
Kao što vidite, s drugim argumentom označavamo brojevni sustav u koji će se broj pretvoriti; ovaj parametar nije obavezan, ali preporuča se koristiti ga ako ne znate koji će niz biti primljen kao unos.

parseFloat()

Sintaksa: parseFloat(niz)

Neka je FP = "33,33333%"; console.log(parseFloat(FP)); > 33,33333
Imajte na umu da ne postoji drugi argument u sintaksi parseFloat.

Razumijemo da su parseInt() i parseFloat() izuzetno korisne značajke, važno je napomenuti da još uvijek postoje neke pogreške, stoga je potrebno provjeriti raspon očekivanih vrijednosti i na kraju analizirati rezultat kako bi se osiguralo da su dobivene vrijednosti točne.
Pošaljite anonimno

Izračuni često daju rezultate koji su izvan željenih raspona. Kao rezultat toga, potrebno je provesti JavaScript zaokruživanje do određene vrijednosti.

Zašto okrugli brojevi?

JavaScript ne pohranjuje cijele brojeve jer su njihove vrijednosti predstavljene kao brojevi s pomičnim zarezom. Mnogi razlomci ne mogu se predstaviti kao brojevi s određenim konačnim brojem decimalnih mjesta, tako da JavaScript može generirati rezultate kao što su sljedeći:

0.1 * 0.2; > 0.020000000000000004

U praksi to neće napraviti nikakvu razliku, jer govorimo o pogrešci od 2 kvintilijuntke. Ali to može utjecati na rezultate kada radite s brojevima koji predstavljaju vrijednosti valute, postotke ili veličinu datoteke. Dakle, trebate učiniti ili na određeno decimalno mjesto.

Zaokruživanje decimalnih brojeva

Da biste "izrezali" decimalni broj, koristite metode toFixed() ili toPrecision(). Oba uzimaju jedan argument, koji određuje broj značajnih i decimalnih mjesta koja će biti uključena u rezultat:

• ako toFixed() nema naveden argument, zadana vrijednost je 0, to jest, nema decimalnih mjesta; najveća vrijednost argumenta je 20;
• ako toPrecision() nema argumenta, broj se ne mijenja.

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"

Bilješka

I toFixed() i toPrecision vraćaju zaokruženi prikaz niza rezultata, umjesto broja. To znači da će dodavanje zaokruženog u randNum rezultirati ulančavanjem nizova umjesto jednog broja:

console.log(randNum + zaokruženo); > "6.256"

Ako želite da JavaScript zaokruži broj na najbližu stotinku, koristite parseFloat() :

var randNum = 6,25; var rounded = parseFloat(randNum.toFixed(1)); console.log(zaokruženo); > 6.3

toFixed() i toPrecision() također su korisne metode za skraćivanje velikog broja decimalnih mjesta. Ovo je korisno kada radite s brojevima koji predstavljaju novčane jedinice:

var wholeNum = 1 var dollarsCents = wholeNum.toFixed(2); console.log(dolarsCents); > "1,00"

Imajte na umu da ako broj ima više znamenki od navedene preciznosti, toPrecision će dati rezultat u znanstvenom formatu:

var num = 123.435 num.toPrecision(2); > "1.2e+2"

Kako izbjeći greške kod zaokruživanja decimala

U nekim slučajevima toFixed i toPrecision implementiraju JavaScript zaokružuje 5 prema dolje, a ne na više:

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

Rezultat gornjeg primjera trebao bi biti 1,01, a ne 1. Ako želite izbjeći ovu pogrešku, preporučujem korištenje eksponencijalnih brojeva:

funkcija round(vrijednost, decimale) ( return Broj(Math.round(value+"e"+decimale)+"e-"+decimale); )

Primjena:

okruglo (1.005,2); > 1.01

Ako trebate još robusnije rješenje od zaokruživanja, dostupno je na MDN.

Zaokruživanje s epsilon

Alternativna metoda JavaScript zaokruživanje na desetine uveden je u ES6 ( poznat i kao JavaScript 2015). « Strojni ipsilon" pruža razumnu marginu pogreške pri usporedbi dva broja s pomičnim zarezom. Bez zaokruživanja, usporedbe mogu dati rezultate slične sljedećim:

0,1 + 0,2 === 0,3 > netočno

Math.EPSILON se može koristiti u funkciji za dobivanje važeće usporedbe:

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

Funkcija uzima dva argumenta: jedan sadrži izračune, drugi očekivani (zaokruženi) rezultat. Vraća usporedbu ova dva parametra:

epsEqu(0,1 + 0,2, 0,3) > točno

Svi moderni preglednici podržavaju ES6 matematičke funkcije. Ali ako trebate pružiti podršku u starijim preglednicima, tada morate koristiti polifile.

Skraćivanje decimalnih brojeva

Sve prethodno predstavljene metode izvode se JavaScript zaokruživanje na desetine. Skratiti pozitivan broj na dvije decimale, pomnožite sa 100, ponovno skratite i zatim rezultat podijelite sa 100, potrebno vam je:

funkcija truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3.1416) > 3.14

Ako vam treba nešto fleksibilnije, možete upotrijebiti bitovni operator:

funkcija truncated(num, decimalPlaces) ( var numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )

Upotreba:

var randInt = 35,874993; skraćeno(randInt,3); > 35.874

Zaokružite na najbliži broj

Provoditi JavaScript zaokruživanje na najbliži cijeli broj, Math.round() se koristi:

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

Imajte na umu da " polovične vrijednosti", kao što je .5, zaokružuju se naviše.

Zaokružite prema dolje na najbliži cijeli broj

Ako želite zaokružiti, koristite metodu Math.floor():

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

Zaokruživanje prema dolje ima jedan smjer za sve brojeve, uključujući i negativne. Ovo se može zamisliti kao neboder s beskonačnim brojem katova, uključujući ispod razine temelja ( koji predstavljaju negativne brojeve). Ako ste u dizalu između 2. i 3. etaže podruma ( što odgovara vrijednosti od -2.5), Math.floor će vas odvesti na kat -3:

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

Ako ovo trebate izbjeći, koristite JavaScript Math zaokruživanje koristeći Math.trunc() , podržano u svim modernim preglednicima (osim IE/Edge):

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

MDN također nudi tri retka polyfill za pružanje podrške za Math.trunc u starijim preglednicima i IE/Edge.

Zaokružite na najbliži cijeli broj

Ako želite zaokružiti decimalne brojeve prema gore, koristite Math.ceil. Ova se metoda također može smatrati beskonačnim dizalom: Math.ceil vas uvijek vodi "gore", bez obzira na to je li broj negativan ili pozitivan:

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

Zaokružite na najbliži višekratnik

Ako trebate zaokružiti vrijednost na najbliži višekratnik broja 5, stvorite funkciju koja dijeli broj s 5, zaokružuje ga i zatim množi rezultat s istom vrijednošću:

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

Upotreba:

zaokruži na5(11); > 10

Ako vam je potreban JavaScript za zaokruživanje na dvije znamenke, možete proslijediti i početnu vrijednost i višekratnik funkciji:

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

Za korištenje funkcije uključite broj koji treba zaokružiti i višekratnik u njezin poziv:

var početni broj = 11; promjenljiv višestruk = 10; zaokružiNaViše(početniBroj, višestruko); > 10;

Za zaokruživanje vrijednosti samo prema gore ili dolje, zamijenite zaokruživanje sa strop ili pod u funkciji.

Vezanje raspona

Ponekad trebate dobiti vrijednost za x koja mora biti unutar određenog raspona. Na primjer, potrebna nam je vrijednost od 1 do 100, ali dobivamo vrijednost 123. Da biste to popravili, možete koristiti min() ( vraća najmanji broj) i max ( vraća najveći dopušteni broj).

Upotreba:

var lowBound = 1; var highBound = 100; var numInput = 123; var clamped = Math.max(lowBound, Math.min(numInput, highBound)); konzola.log(stegnut); > 100;

Možete stvoriti funkciju ili proširenje klase Broj.

U ovom ćemo članku detaljno razmotriti brojeve, matematičke operatore, načine pretvaranja broja u niz i obrnuto, kao i mnoge druge važne točke.

jeKonačna funkcija

Funkcija isFinite omogućuje vam da provjerite je li argument konačan broj.

Kao odgovor ovu funkciju vraća false ako je argument Infinity , -Infinity , NaN ili će se pretvoriti u jednu od ovih posebnih numeričkih vrijednosti. U suprotnom, ova funkcija će vratiti true.

JeKonačna(73); // true isFinite(-1/0); // false isFinite(Infinity); // false isFinite(NaN); // false isFinite("Tekst"); // lažno

Osim globalna funkcija isFinite JavaScript također ima metodu Number.isFinite. Za razliku od isFinite, ne prisiljava argument da se pretvori u broj.

IsKonačno("73"); // pravi broj.isFinite("73"); // lažno

isNaN funkcija

Funkcija isNaN dizajnirana je za utvrđivanje je li argument broj ili se može pretvoriti u jedan. Ako je tako, tada funkcija isNaN vraća false. Inače vraća true.

IsNaN(NaN); //istina isNaN("25px"); //istina, jer 20px nije broj isNaN(25.5); //false isNaN("25.5"); //false isNaN(" "); //lažno, jer razmak ili nekoliko razmaka se pretvaraju u 0 isNaN(null); //lažno, jer null se pretvara u 0 isNaN(true); //lažno, jer true se pretvara u 1 isNaN(false); //lažno, jer false se pretvara u 0

Ako ovu radnju treba izvesti bez pretvaranja tipa, upotrijebite metodu Number.isNaN. Ova metoda je uvedena u jezik počevši od ECMAScripta 6.

Kako eksplicitno pretvoriti niz u broj?

Možete eksplicitno pretvoriti niz u broj pomoću sljedećih metoda:

1. Koristite unarni operator +, koji se mora staviti ispred vrijednosti.

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

Ova metoda zanemaruje razmake na početku i kraju retka, kao i \n (pokretanje retka).

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

Korištenje ovu metodu potrebno je obratiti pozornost na to da prazna linija ili se niz koji se sastoji od razmaka i \n pretvara u broj 0. Osim toga, također pretvara nulti tip podataka i booleove vrijednosti u broj.

Null; //0 +istina; //1 +false; //0 +" "; //0

2. Funkcija ParseInt. Ova je funkcija dizajnirana za pretvaranje argument na cijeli broj. Za razliku od korištenja unarni operator +, ovu metodu omogućuje pretvaranje niza u broj, u kojem nisu svi znakovi numerički. Počinje pretvarati niz, počevši od prvog znaka. I čim naiđe na nenumerički znak, ova funkcija zaustavlja svoj rad i vraća rezultirajući broj.

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

Ova funkcija može raditi s različitim sustavima brojeva (binarni, oktalni, decimalni, heksadecimalni). Baza brojevnog sustava određena je pomoću 2 argumenta.

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

Uz funkciju parseInt, JavaScript ima metodu Number.parseInt. Ova se metoda ne razlikuje od funkcije parseInt i uvedena je u JavaScript sa specifikacijom ECMASCRIPT 2015 (6).

3. funkcija parseFloat. Funkcija parseFloat slična je parseInt, osim što vam omogućuje pretvaranje argumenta u razlomački broj.

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

Osim toga, funkcija parseFloat, za razliku od parseInt, nema 2 argumenta, pa stoga uvijek pokušava niz tretirati kao broj u sustavu decimalnog zapisa.

ParseFloat("3.14"); parseFloat("314e-2"); parseFloat("0,0314E+2");

Uz funkciju parseFloat, JavaScript ima metodu Number.parseFloat. Ova se metoda ne razlikuje od funkcije parseFloat i uvedena je u JavaScript sa specifikacijom ECMASCRIPT 2015 (6).

Pretvaranje broja u niz

Možete pretvoriti broj u niz pomoću metode toString.

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

Metoda toString također vam omogućuje da odredite bazu brojevnog sustava, uzimajući u obzir da je potrebno eksplicitno pretvoriti broj u niz:

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

Kako provjeriti je li varijabla broj

Možete odrediti je li vrijednost varijable broj pomoću jedne od sljedećih metoda:

1. Korištenje funkcija isNaN i isFinite:

// myVar je varijabla if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar je broj ili se može pretvoriti u njega);

Kao funkcija:

// funkcija funkcija isNumeric(value) ( ​​​​return !isNaN(parseFloat(value)) && isFinite(parseFloat(value)); ) // koristi var myVar = "12px"; console.log(isNumeric(myVar)); //pravi

Ova metoda vam omogućuje da odredite je li navedena vrijednost broj ili se može pretvoriti u jedan. Ova opcija ne broji prazan niz, niz razmaka, null, Infinity, -Infinity, true i false kao broj.

2. Korištenje operatora typeof i funkcija isFinite, isNaN:

// funkcija koja provjerava je li vrijednost broj function isNumber(value) ( ​​​​return typeof value === "number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Ova funkcija određuje je li navedena vrijednost tipa Number i je li jedna od posebnih vrijednosti Infinity, -Infinity i NaN. Ako je tako, tada ova funkcija vraća true.

3. Korištenje metode ECMAScript 6 Number.isInteger(value). Ova metoda vam omogućuje da odredite je li navedena vrijednost cijeli broj.

Number.isInteger("20"); //lažno, jer ova metoda ne pretvara niz u broj Number.isInteger(20); //istina, jer ova vrijednost je broj

Parni i neparni brojevi

Pomoću sljedećih funkcija možete provjeriti je li broj paran ili neparan:

// Funkcija za provjeru funkcije parnog pariteta u broju isEven(n) ( return n % 2 == 0; ) // Funkcija za provjeru funkcije parnog pariteta u broju isOdd(n) ( return Math.abs(n % 2) == 1; )

Ali prije provođenja takve provjere, preporučljivo je provjeriti je li navedena vrijednost broj:

Vrijednost = 20; if (Number.isInteger(value)) ( if (isEven(value)) ( console.log("Number " + value.toString() + " - even"); ) )

Prosti brojevi u Javascriptu

Pogledajmo primjer iz kojeg proizlazimo koristeći Javascript prosti brojevi od 2 do 100.

// Funkcija koja provjerava je li broj prost function isPrime(value) ( ​​​​if (isNaN(value) || !isFinite(value) || value%1 || value< 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);

Zaokruživanje broja u Javascriptu

Postoje različiti načini zaokruživanja razlomka na cijeli broj u JavaScriptu.

1. Korištenje metoda Math.floor, Math.ceil i Math.round posebno dizajniranih za to. Metoda Math.floor zaokružuje razlomak na najbliži cijeli broj, tj. jednostavno odbacuje razlomački dio. Math.ceil zaokružuje razlomak na najbliži cijeli broj. Math.round zaokružuje broj prema gore ili dolje ovisno o vrijednosti razlomka. Ako je razlomački dio veći ili jednak 0,5, tada prema gore, inače je uvijanje prema dolje.

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

2. Korištenje metode toFixed(precision). Ova metoda zaokružuje razlomački dio broja na određenu preciznost. Rezultat zaokruživanja vraća se kao niz.

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

Ako nema dovoljno decimalnih mjesta da bi se oblikovala navedena preciznost broja, tada se on popunjava nulama.

Console.log(7.987.toFixed(5)); //"7,98700"

3. Korištenje metode toPrecision(accuracy). Ova metoda predstavlja broj s određenom preciznošću. Istodobno, on može zaokružiti ne samo razlomak, već i cijeli dio broja. Ovisno o rezultatu, ova metoda može prikazati rezultirajući broj s fiksnom točkom ili u eksponencijalnom obliku.

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. Korištenje logičkih operatora NOT ili OR.

//putem konzole dvostruke logičke negacije.log(~~7.9); //7 // korištenjem logičkog ILI s nulom: console.log(7.9^0); //7

Cijeli i razlomački dio broja

Cjelobrojni dio broja možete dobiti pomoću metoda Math.floor() i parseInt():

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

Razlomak broja možete dobiti pomoću operatora postotka (%). Ovaj operator vraća ostatak koji će se dobiti dijeljenjem prvog broja s drugim. U ovom slučaju morate koristiti 1 kao 2. broj.

Console.log(7,21%1); // 0.209999999999999996 // točno na 2 decimalna mjesta console.log((7.21%1).toFixed(2)); // "0,21"

Osim toga, frakcijski dio se također može dobiti pomoću izračuna:

Var broj = 7,21; var fractionNumber = number - Math.floor(Math.abs(number)); console.log(fractionnumber); // 0,20999999999999996

Je li broj djeljiv cijelim brojem?

Možete odrediti je li broj djeljiv s cijelim brojem pomoću operatora postotka:

Var broj = 9; // ako je ostatak broja podijeljenog s 3 0, tada da, inače ne if (broj%3==0) ( console.log ("Broj " + broj + " djeljiv je s 3"); ) else ( console. log("Broj " + broj + " nije djeljiv sa 3");

Formatiranje brojeva

U JavaScriptu, metoda toLocaleString() omogućuje formatiranje izlaza broja u skladu s regionalnim standardima (jezične postavke operativnog sustava).

Na primjer, formatirajmo broj u skladu s regionalnim standardima koji su instalirani u sustavu prema zadanim postavkama:

Var broj = 345,46; console.log(number.toLocaleString()); //"345.46"

Na primjer, formatirajmo broj u skladu s regionalnim standardima Rusije (ru):

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

Ova se metoda također može koristiti za formatiranje broja kao valute:

Console.log((2540.125).toLocaleString("ru-RU",(style:"valuta", valuta:"RUB"))); //"2.540,13 ₽" console.log((89.3).toLocaleString("ru-RU",(style:"currency", currency:"USD"))); //"89,30 $" console.log((2301,99).toLocaleString("ru-RU",(style:"currency", currency:"EUR"))); //"2301,99 €"

Predstavljanje broja kao postotka:

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

Rastavite broj na znamenke (koristite svojstvo Grupiranja):

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

Ispišite broj s određenim brojem znamenki (2) iza decimalne točke:

Console.log((1240.4564).toLocaleString("ru-RU",(minimumFractionDigits:2, maximumFractionDigits:2))); //"1240,46"

Usporedba brojeva

Sljedeći operatori koriste se za usporedbu brojeva u JavaScriptu: == (jednako), != (nije jednako), > (veće od),< (меньше), >= (veće ili jednako),<= (меньше или равно).

Na primjer, usporedimo dva broja:

Console.log(2>3); //lažna konzola.log(5>=3); //pravi

Kada se brojevi uspoređuju s razlomkom, potrebno je uzeti u obzir pogreške koje se mogu pojaviti tijekom ovih izračuna.

Na primjer, u JavaScriptu zbroj brojeva (0,2 + 0,4) nije jednak 0,6:

Console.log((0,2+0,4)==0,6); //lažno

Pogreške se javljaju jer su svi izračuni napravljeni pomoću računala ili nekog drugog elektronički uređaj proizvodi u 2 brojevnom sustavu. Oni. Prije izvođenja bilo kakvih radnji, računalo prvo mora pretvoriti brojeve predstavljene u izrazu u drugi brojevni sustav. Ali ne može se svaki razlomački decimalni broj točno prikazati u drugom brojevnom sustavu.

Na primjer, broj 0,25 10 in binarni sustav točno pretvoreno.

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

Na primjer, broj 0,2 10 može se pretvoriti u sustav 2 samo s određenom točnošću:

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

Kao rezultat toga, ove će pogreške utjecati na izračun zbroja dvaju brojeva i rezultate usporedbe. Oni. Ispostavilo se da će JavaScript zapravo vidjeti ovaj unos na sljedeći način:

0.6000000000000001==0.6

Kada računate ili prikazujete brojeve s razlomcima, uvijek morate naznačiti preciznost s kojom to želite učiniti.

Na primjer, usporedite brojeve do 2 decimalna mjesta pomoću metoda toFixed() i toPrecision():

//metoda toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //točno //metoda toPrecision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //pravi

Osnovne matematičke operacije

U JavaScriptu postoje sljedeći matematički operatori: + (zbrajanje), - (oduzimanje), * (množenje), / (dijeljenje), % (modulo), ++ (povećanje vrijednosti za 1), -- (smanjenje vrijednosti za 1).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, tj. 6:3=2 => 6-3*2 => rest(0) 5%2 //1, tj. 5:2=2(.5) => 5-2*2 => ostalo(1) 7,3%2 //1,3, tj. 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //predznak rezultata operacije % jednak je predznaku prve vrijednosti -9%2.5 //-1.5 , tj. 9:2.5=3(.6) => 9-2.5*3 => ostatak(1.5) -9%-2.5 //-1.5, tj. 9:2.5=3(.6) => 9-2.5*3 => rest(1.5) -2%5 //-2, tj. 2:5=0(.4) => 2-5*0 => odmor(2) x = 3; konzola.log(x++); //izvodi 3, zatim postavlja 4 console.log(x); //4 x = 3; konzola.log(++x); //postavlja 4 i izlazi x = 5; konzola.log(x--); //izvodi 5, zatim postavlja 4 console.log(x); //4 x = 5; konzola.log(--x); //postavlja 4 i daje izlaz Osim toga, JavaScript ima operatore kombinacija: 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; konzola.log(x); //9 x = 3; y = 6; x-=y; konzola.log(x); //-3 x = 3; y = 6; x*=y; konzola.log(x); //18 x = 3; y = 6; x/=y; konzola.log(x); //0,5 x = 3; y = 6; x%=y; konzola.log(x); //3