Javascript zaokruživanje na najbliži cijeli broj. Matematički objekt u javascriptu - Metode okruglog, stropa i poda - Zaokruživanje razlomaka

25.11.2023

Često je rezultat izračunavanja broj sa velikim brojem decimalnih mjesta. Ako se ovaj broj koristi za dalje izračune, onda se može ostaviti u ovom obliku. Ali ponekad je potrebno zaokružiti broj, na primjer za prikaz na stranici. JavaScript zaokružuje brojeve koristeći nekoliko metoda.

Metoda Math.round() zaokružuje vrijednost na cijeli broj.

Math.round (broj)

Brojevi su zaokruženi prema matematičkim pravilima. Odnosno, ako se iza decimalnog zareza nalazi broj od 0 do 4, tada se razlomak jednostavno odbacuje. A ako iza decimalnog zareza postoji broj od 5 do 9, tada se razlomak odbacuje, a jedan se dodaje cijelom dijelu. primjer:

JavaScript:

Postoje još dvije metode koje zaokružuju broj na cijeli broj. Metoda Math.floor() se zaokružuje naniže. Odbacuje razlomak broja. I metoda Math.ceil() zaokružuje. Odbacuje razlomak i dodaje jedan cijelom dijelu. primjer:

Naravno, 5 - (-2) je 5+2. Ne zaboravite da nećete dobiti broj 5 u ovoj formuli. Maksimum će biti 4,999999999. Rezultirajuće vrijednosti mogu se zaokružiti na potrebnu tačnost.

Ako su potrebni samo cijeli brojevi, onda se rezultirajuće vrijednosti mogu zaokružiti na najbliži cijeli broj. Jedan se mora dodati maksimumu da bi i ovaj maksimum bio moguć. Formula izgleda ovako:

cijeli broj = Math.floor(min + Math.random() * (maks + 1 - min)

Štampajmo brojeve od 10 do 15:

20
21
22
23
24

za (i=1; i= (veće ili jednako), 3); //false console.log(5>=3); //tačno

Prilikom poređenja brojeva sa razlomkom, potrebno je uzeti u obzir greške koje mogu nastati prilikom ovih proračuna.

Na primjer, u JavaScript-u zbir brojeva (0,2 + 0,4) nije jednak 0,6:

Console.log((0.2+0.4)==0.6); //false

Greške nastaju jer se sve kalkulacije rade kompjuterski ili drugim elektronski uređaj proizvodi u 2 brojevnom sistemu. One. Prije izvođenja bilo kakve radnje, računar mora prvo pretvoriti brojeve prikazane u izrazu u drugi brojevni sistem. Ali ne može svaki razlomak decimalni broj biti tačno predstavljen u 2. brojevnom sistemu.

Na primjer, broj 0,25 10 in binarni sistem tačno konvertovano.

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 sistem 2 samo sa određenom tač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 greške će uticati na izračunavanje zbira dva broja i rezultate poređenja. One. Ispostavilo se da će JavaScript zapravo vidjeti ovaj unos na sljedeći način:

0.6000000000000001==0.6

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

Na primjer, uporedite brojeve do 2 decimale koristeći metode toFixed() i toPrecision():

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

Osnovne matematičke operacije

U JavaScript-u postoje sljedeći matematički operatori: + (sabiranje), - (oduzimanje), * (množenje), / (dijeljenje), % (modulo), ++ (povećati vrijednost za 1), -- (smanji vrijednost za 1 ).

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

Vrlo često kalkulacije u JavaScript-u ne daju upravo one rezultate koje želimo. Naravno, sa brojevima možemo raditi šta god hoćemo - zaokružiti nagore ili naniže, postaviti opsege, odrezati nepotrebne brojeve na određeni broj decimalnih mjesta, sve ovisi o tome šta želite da radite s ovim brojem u budućnosti.

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Zašto je potrebno zaokruživanje?

Jedan od zanimljivih aspekata JavaScript-a je da on zapravo ne pohranjuje cijele brojeve, već radimo odmah sa brojevima s pomičnim zarezom. Ovo, u kombinaciji sa činjenicom da se mnoge razlomke vrijednosti ne mogu izraziti na konačan broj decimalnih mjesta, u JavaScriptu možemo dobiti ovakve rezultate:

Za praktične svrhe, ova nepreciznost nije bitna, u našem slučaju govorimo o grešci u kvintilionima dijelova, međutim, to može neke razočarati. Takođe možemo dobiti pomalo čudne rezultate kada radimo sa brojevima koji predstavljaju valute, procente ili veličine fajlova. Da bismo ispravili ove nepreciznosti, samo trebamo moći zaokružiti rezultate, a dovoljno je podesiti decimalnu preciznost. Zaokruživanje brojeva ima praktičnu primjenu, možemo manipulirati brojem unutar određenog raspona, na primjer želimo zaokružiti vrijednost na najbliži cijeli broj umjesto da radimo samo s decimalnim dijelom. Zaokruživanje decimala Da biste skratili decimalu, koristite metodu toFixed ili toPrecision. I jedni i drugi uzimaju jedan argument, koji određuje, respektivno, koliko

značajne figure (tj. ukupan broj cifara upotrijebljenih u broju) ili decimalna mjesta (broj iza decimalnog zareza) moraju uključivati rezultat: Ako argument nije definiran za toFixed(), tada će on biti zadano

jednaka nuli

, što znači 0 decimalnih mjesta, argument ima maksimalnu vrijednost od 20.
Ako se toPrecision ne da argument, broj ostaje netaknut

neka randNum = 6,25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" randBroj = 87,335; randNum.toFixed(2); > "87,33" randBroj = 87,337; randNum.toPrecision(3); > "87.3"
Obje metode toFixed() i toPrecision() vraćaju string prikaz rezultata, a ne broj. To znači da će kada se zbroji zaokružena vrijednost sa randNum, proizvesti konkatenacija nizova, a ne zbir brojeva: Neka je randNum = 6,25; neka rounded = randNum.toFixed(); // "6" console.log(randNum + rounded); > "6.256" podataka, tada ćete morati primijeniti parseFloat:

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

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

Neka cijeliNum = 1 neka dollarsCents = wholeNum.toFixed(2); console.log(dollarsCents); > "1.00"
Vrijedi napomenuti da će toPrecision dati rezultat u eksponencijalnom zapisu ako je broj cijelih brojeva veći od same preciznosti:

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

Kako izbjeći greške zaokruživanja decimalama U nekim slučajevima, toFixed i toPrecision zaokružuju vrijednost 5 prema dolje i prema gore:

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 grešku, možemo koristiti rješenje koje je predložio Jack L Moore, koje koristi eksponencijalne brojeve za izračun:

Funkcija round(vrijednost, decimale) (vrati broj(Math.round(value+"e"+decimas)+"e-"+decimal); )
sada:

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

Mašinsko epsilon zaokruživanje Alternativni metod za zaokruživanje decimalnih brojeva uveden je u ES6. Mašinsko epsilon zaokruživanje daje razumnu marginu greške kada se upoređuje dva broja s pomičnim zarezom. Bez zaokruživanja, poređenja mogu dati rezultate slične sljedećim:

0,1 + 0,2 === 0,3 > netačno
Koristimo Math.EPSILON u našoj funkciji da dobijemo valjano poređenje:

Funkcija epsEqu(x, y) (vraćanje Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Funkcija uzima dva argumenta: prvi je trenutni proračun, drugi je očekivani rezultat. Vraća poređenje ova dva:

EpsEqu(0,1 + 0,2, 0,3) > istina
Svi moderni pretraživači već podržavaju ES6 matematičke funkcije, ali ako želite podršku u pretraživačima kao što je IE 11, koristite polifile.

Odsecanje razlomka Sve metode koje su gore predstavljene mogu zaokružiti na decimalne brojeve. Da biste jednostavno izrezali broj na dvije decimale, prvo ga morate pomnožiti sa 100, a zatim podijeliti rezultat sa 100:

Funkcija truncated(num) (vraćanje Math.trunc(num * 100) / 100; ) truncated(3.1416) > 3.14
Ako želite prilagoditi metodu bilo kojem broju decimalnih mjesta, možete koristiti dvostruku negaciju u bitovima:

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

Neka randInt = 35,874993; truncated(randInt,3); > 35.874

Zaokruživanje na najbliži broj Za zaokruživanje decimalnog broja na najbliži broj gore ili dolje, ovisno o tome čemu smo najbliži, koristite Math.round():

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

Zaokruživanje na najbliži cijeli broj Ako želite uvijek zaokružiti naniže, koristite Math.floor:

Math.floor(42.23); > 42 Matematički pod (36.93); > 36
Imajte na umu da zaokruživanje prema dolje radi za sve brojeve, uključujući negativne brojeve. Zamislite neboder sa beskonačnim brojem spratova, uključujući spratove na donjem nivou (koji predstavljaju negativne brojeve). Ako ste u liftu na najnižem nivou 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 da izbegnete ovu situaciju, koristite Math.trunc, podržan u svim modernim pretraživačima (osim IE/Edge):

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

Zaokruživanje na najbliži cijeli broj S druge strane, ako uvijek trebate zaokružiti, koristite Math.ceil. Opet, zapamtite beskonačni lift: Math.ceil će uvijek ići "gore", bez obzira da li je broj negativan ili ne:

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

Zaokruživanje gore/dolje na potreban broj Ako želimo zaokružiti na najbliži umnožak od 5, najlakši način je da kreiramo funkciju koja dijeli broj sa 5, zaokružuje ga, a zatim ga množi za isti iznos:

Funkcija roundTo5(num) (vraćanje Math.round(num/5)*5; )
sada:

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

Funkcija roundToMultiple(num, multiple) (vraćanje Math.round(num/multiple)*multiple; )
sada:

Neka je početni broj = 11; neka je višestruko = 10; roundToMultiple(početni broj, višestruki); > 10;

Fiksiranje broja u rasponu Postoji mnogo slučajeva u kojima želimo da dobijemo vrijednost x koja se nalazi unutar raspona. Na primjer, možda će nam trebati vrijednost između 1 i 100, ali smo na kraju dobili vrijednost od 123. Da to popravimo, možemo koristiti min (vraća najmanji od skupa brojeva) i max (vraća najveći od bilo kojeg skupa brojeva). U našem primjeru, raspon je od 1 do 100:

Neka lowBound = 1; neka visoka granica = 100; neka numInput = 123; neka stegnut = Math.max(lowBound, Math.min(numInput, highBound)); console.log(zategnuto); > 100;
Opet, možemo ponovo koristiti operaciju i umotati cijelu stvar u funkciju, koristeći rješenje koje je predložio Daniel X. Moore:

Number.prototype.clamp = function(min, max) (vrati Math.min(Math.max(ovo, min), max); );
sada:

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

Gausovo zaokruživanje Gausovo zaokruživanje, također poznato kao bankarsko zaokruživanje, je mjesto gdje se zaokruživanje za ovaj slučaj događa na najbliži paran broj. Ova metoda zaokruživanja radi bez statističke greške. Najbolje rješenje je predložio Tim Down:

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 kreiranje pozicijskih mapiranja za HTML elemente, možda se pitate šta bi se dogodilo kada bismo generirali decimalne vrijednosti za naše elemente:

#box ( širina: 63.667731993px; )
Dobra vijest je da će moderni pretraživači poštovati decimalne vrijednosti u blok modelu, uključujući postotke ili jedinice piksela.

Sortiranje Vrlo često moramo sortirati neke elemente, na primjer, imamo niz zapisa igre, i oni moraju biti organizirani u opadajućem redoslijedu prema rangu igrača. nažalost, standardna metoda sort() ima neka iznenađujuća ograničenja: dobro radi sa uobičajenim engleskim riječima, ali se odmah pokvari kada naiđe na brojeve, jedinstvene znakove ili velike riječi. Sortiranje po abecedi Čini se da bi sortiranje niza po abecedi trebao biti jednostavan zadatak:

Neka voće = ["butternut tikva", "kajsija", "dinja"]; fruit.sort(); > "kajsija", "butternut tikva", "dinja"]
Međutim, nailazimo na problem čim je jedan od elemenata napisan velikim slovima:

Neka voće = ["butternut tikva", "kajsija", "dinja"]; fruit.sort(); > "dinja", "kajsija", "butternut tikva"]
To je zato što, prema zadanim postavkama, sorter upoređuje prvi znak predstavljen u Unicode-u. Unicode je jedinstveni kod za bilo koji znak, 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 0x61), dok znak "C" ima kod U+0043 (0x43), koji dolazi ranije u Unicode-u tablicu nego znak "a".

Da sortiramo niz koji može sadržavati miješana prva slova, moramo ili 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 kreirati funkciju za ponovnu upotrebu:

Funkcija alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("osjetljivost": "base")); )); ) let fruit = ["butternut tikva ", "kajsija", "dinja"]; alphaSort(voće) >
Ako želite da se niz sortira obrnutim abecednim redom, jednostavno zamijenite pozicije a i b u funkciji:

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

Funkcija caseSort(arr) ( arr.sort(function (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) neka voće = ["butternut tikva", "kajsija", "Dinja"]; caseSort(voće) > ["kajsija", "butternut tikva", "dinja"]

Numeričko sortiranje Sve ovo se ne odnosi na primjer o kojem smo gore govorili o nizu zapisa igre. S nekim numeričkim nizovima, sortiranje funkcionira sasvim dobro, ali u nekom trenutku rezultat može biti nepredvidljiv:

Neka highScores = ; highScores.sort(); >
Stvar je u tome da metoda sort() izvodi leksikografsko poređenje: što znači da će brojevi biti konvertovani u niz i da će se poređenja ponovo vršiti uparivanje prvog znaka tog niza po redosledu znakova u Unicode tabeli . Stoga, opet moramo definirati naš redoslijed sortiranja:

Neka highScores = ; highScores.sort(funkcija(a,b) (vraćanje a - b; )); >
Opet, da biste sortirali brojeve obrnutim redoslijedom, zamijenite pozicije a i b u funkciji.

Sortiranje strukture nalik JSON-u Konačno, ako imamo strukturu podataka nalik JSON-u predstavljenu kao niz zapisa igre:

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

Scores.sort((a, b) => b.score - a.score));
Za starije pretraživače koji nemaju ovu podršku:

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

Rad sa funkcijama stepena Eksponencijacija je operacija koja je prvobitno definisana kao rezultat višekratnog množenja prirodnog broja sam po sebi, kvadratni koren od a je broj koji daje a kada je na kvadrat. Ove funkcije mogli bismo stalno koristiti u svakodnevnom životu na časovima matematike, uključujući izračunavanje površina, volumena ili čak u fizičkom modeliranju.

U JavaScriptu, funkcija snage je predstavljena kao Math.pow(), u novom ES7 standardu je uvedena novi operater eksponencijacija - " * * ".

Podizanje na stepen Da biste podigli broj na n-ti stepen, koristite funkciju Math.pow(), gdje je prvi argument broj koji će biti podignut na stepen, drugi argument je eksponent:

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 kubika, ili 5 × 5 × 5, jednako je 125.

ECMAScript 7 je sljedeća verzija JavaScript-a, u principu, možemo koristiti novi predloženi operator eksponencijacije - * *, ovaj oblik notacije može biti opisniji:

3 ** 2 > 9
On trenutno Podrška za ovog operatera je prilično ograničena, pa se njegova upotreba ne preporučuje.

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

Kvadratni i kubni korijen Math.sqrt() i Math.cbrt() su suprotni od Math.pow(). Kao što se sjećamo, kvadratni korijen od a je broj koji daje a kada je na kvadrat.

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

Math.cbrt(125) > 5
Math.cbrt() je tek nedavno uveden u JavaScript specifikaciju, te je stoga podržan samo u modernim pretraživačima: Chrome 38+, Firefox i Opera 25+ i Safari 7.1+. Primetićete to Internet Explorer nije na ovoj listi, ali ćete naći polifil na MDN-u.

Primjeri Naravno, možemo koristiti necjelobrojne vrijednosti u jednoj od ovih funkcija:

Math.pow(1.25, 2); > 1.5625 Math.cbrt(56.57) > 3.8387991760286138
Imajte na umu da ovo također radi prilično dobro kada koristite negativne vrijednosti argumenata:

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 kvadratne korijene negativnih brojeva. I ovo nas može dovesti do druge tehnike rada sa kompleksnim brojevima, ali to je druga priča.

Možete koristiti razlomke u Math.pow() da pronađete kvadratni i kubni korijen 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 s pomičnim zarezom, ne možete točno pogoditi tač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 JavaScript-u brkaju funkciju Math.pow() sa Math.exp() , što je eksponencijalna funkcija za brojeve općenito. Napomena: u engleski"eksponent" je preveden kao "eksponent", tako da je vjerovatnije da se ovo odnosi na govornike engleskog jezika, iako postoje alternativni nazivi za eksponent, kao što su indeks, snaga.

Matematičke konstante Rad sa matematikom u JavaScript-u je olakšan brojnim ugrađenim konstantama. Ove konstante su svojstva objekta Math. Vrijedi napomenuti da se konstante pišu velikim slovima, a ne CamelCase notaciji. Math.abs, parseInt, parseFloat Rad sa brojevima u JavaScript-u može biti mnogo komplikovaniji nego što se čini. Dobijene vrijednosti ne spadaju uvijek u očekivane raspone, ponekad rezultat možda uopće nije ono što smo očekivali. Math.abs() Metoda Math.abs() vraća apsolutnu vrijednost broja, što nas podsjeća na sličnu matematičku funkciju za modul broja.

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() Znamo da JavaScript razumije da je “15” string, a ne broj, i, na primjer, kada analiziramo CSS svojstva koristeći JavaScript, ili primamo bilo koju vrijednost iz nepripremljenog niza, naši rezultati mogu biti nepredvidljivi. Mogli bismo primiti string predstavljen kao "17px" kao ulaz, a to nije neuobičajeno za nas. Pitanje je kako pretvoriti ovaj niz u stvarnu vrijednost i koristiti ga u daljim proračunima.

Sintaksa: parseInt(string, radix);

ParseInt funkcija konvertuje prvi argument koji joj je proslijeđen u tip stringa, interpretira ga i vraća cijeli broj ili NaN vrijednost. Rezultat (ako nije NaN) je cijeli broj i prvi je argument (string), tretiran kao broj u navedenom radiksu. Na primjer, baza 10 označava konverziju iz decimalni broj, 8 - oktalno, 16 - heksadecimalno i tako dalje. Ako je osnova veća od 10, onda se slova koriste za predstavljanje brojeva veći od 9. Na primjer, za heksadecimalni brojevi(baza 16) koriste se slova od A do F.

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

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

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

Neka centerX = parseInt(centers, 10); > 454 neka centarY = parseInt(centri, 10); >2087
Kao što vidite, drugim argumentom označavamo brojčani sistem u koji će se broj pretvoriti, ali je preporučljivo koristiti ga ako ne znate koji niz će biti primljen kao ulaz.

parseFloat() Iz gornjeg primjera, vjerovatno ste primijetili da parseInt odbacuje razlomak. U našem slučaju, parseFloat može raditi sa brojevima s pomičnim zarezom. Opet, ovo može biti korisno kada analizirate CSS i druge zadatke, posebno kada radite s procentima u pokretnom zarezu.

Sintaksa: parseFloat(string)

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

Iako razumijemo da su parseInt() i parseFloat() izuzetno korisne funkcije, važno je imati na umu da nisu bez grešaka, pa je potrebno provjeriti raspon očekivanih vrijednosti i na kraju analizirati rezultat kako biste osigurali da su dobijene vrijednosti tačne.
Pošaljite anonimno

Povezani članci