Metode zaokruživanja brojeva u JavaScriptu. Matematički objekt u javascriptu - Round, ceil i floor metode - Zaokruživanje frakcijskih brojeva Js 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.

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; let rounded = 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 proizvesti 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"

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, decimals) ( return Broj(Math.round(value+"e"+decimals)+"e-"+decimals); )
Sada:

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

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.

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

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.

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.

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

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;

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;

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.

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"]

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.

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.

U Snaga JavaScripta funkcija je predstavljena kao Math.pow(), u novom ES7 standardu uveden je novi operator stepenovanja - " * * ".

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).

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.

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.

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

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.

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, pa 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

Funkcija Math.round() vraća vrijednost broja zaokruženog na najbliži cijeli broj.

Izvor za ovaj interaktivni primjer pohranjen je u GitHub repozitorij. Ako želite doprinijeti projektu interaktivnih primjera, klonirajte https://github.com/mdn/interactive-examples i pošaljite nam zahtjev za povlačenje.

Vrijednost zadanog broja zaokružena na najbliži cijeli broj.

Ako je razlomački dio argumenta veći od 0,5, argument se zaokružuje na cijeli broj sa sljedećom višom apsolutnom vrijednošću. Ako je manji od 0,5, argument se zaokružuje na cijeli broj s nižom apsolutnom vrijednošću. Ako je razlomak točno 0,5, argument se zaokružuje na sljedeći cijeli broj u smjeru +∞. Imajte na umu da se ovo razlikuje od funkcija round() mnogih jezika, koje često zaokružuju ovaj slučaj na sljedeći cijeli broj daleko od nule, umjesto da daje drugačiji rezultat u slučaju negativnih brojeva s razlomačkim dijelom od točno 0,5.

Budući da je round() statična metoda Matha, uvijek ga koristite kao Math.round(), a ne kao metodu Math objekta koji ste stvorili (Math nema konstruktor).

Ispod je isječak koda koji je funkcionalno ekvivalentan math.round osim što je isječak koda u nastavku sporiji od Math.round. Svrha isječka koda u nastavku je pokazati kako Math.round funkcionira.

Funkcija vanilla_round(x) ( var y = Math.abs(x) + 0.5; // tako da manje od 1/2 zaokružuje prema dolje; veće zaokružuje naviše vraća Math.floor(x+0.5) )

Gornji operator modula dobiva decimalni dio od x. Nadalje, gornji isječak koda mogao bi se modificirati da zaokruži broj na određenu preciznost:

Funkcija round_to_precision(x, preciznost) ( var y = +x + (preciznost === nedefinirano ? 0,5: preciznost/2); return y - (y % (preciznost === nedefinirano ? 1: +preciznost)); )

Zaokruži_na_preciznost(11, 2); // izlazi 12 round_to_precision(11, 3); // izlazi 12 round_to_precision(11, 4); // izlazi 12 round_to_precision(11, 5); // izlazi 10 round_to_precision(11, 6); // izlaz 12 round_to_precision(11, 7); // izlazi 14 round_to_precision(11, 8); // izlazi 8 round_to_precision(3.7, 0.5); // izlazi 3.5 round_to_precision(3.75, 0.5); // izlazi 4 round_to_precision(3.8, 0.5); // izlazi 4

Tablica kompatibilnosti na ovoj stranici generirana je iz strukturiranih podataka. Ako želite doprinijeti podacima, pogledajte https://github.com/mdn/browser-compat-data i pošaljite nam zahtjev za povlačenje.

Ažurirajte podatke o kompatibilnosti na GitHubu

Sada pogledajmo metodu poda (prevedeno kao rod), koja djeluje suprotno od ceil metode, tj. zaokružuje razlomak prema dolje.

var dob = 35,97;

dob = Math.floor(age); /* Zaokruži vrijednost varijable starosti prema dolje */

dokument.pisati(dob);

Kao što vidite, katna metoda zaokružila je broj 35,97 na 35, odnosno prema dolje. Unatoč činjenici da je 0,97 veće od 0,5 (cm.).

U ovoj lekciji razmatrane su metode objekta Math za zaokruživanje frakcijskih decimalnih brojeva.

Sada morate napraviti domaću zadaću.

Vaš zadatak je napisati funkciju koja uzima dva parametra.
1. Niz koji se sastoji od brojeva s razlomcima.
2. Metoda zaokruživanja "okruglo", "strop" ili "pod".

Na izlazu funkcija treba ispisati isti niz, ali u isto vrijeme sve elementi niza, mora se zaokružiti pomoću metode matematičkog objekta navedenog u drugom parametru.

Izvorni niz:

var numberArray = ;

Isprva se rješavanje ovog zadatka može učiniti gotovo identičnim rješavanju domaćih zadataka iz prva tri lekcije ova tema. Ali nije sve tako jednostavno...

Rješenje #1 - Pažnja

Prema uvjetima zadatka, funkcija mora uzeti dva parametra - izvorni niz i jednu od metoda: "round", "ceil" ili "floor" . Na temelju ovoga, pokušao sam učiniti ovo...

funkcija decimal (anyArray ,method) /* Kreirajte funkciju s dva parametra */
{

za (i = 0; i< anyArray .length ; i ++ )

{
document.write(bilo koji niz
" )

bilo koji niz = Math.method(bilo koji niz); /* Koristeći jednu od metoda objekta Math, zaokružujemo trenutni element niza */

document.write(anyArray + "

" )
}

decimal (numberArray, round ) /* Pozovite funkciju i navedite dva parametra za nju. Ali NE MOŽETE navesti metodu NAME kao parametar funkcije */

U ovom rješenju stvaramo funkciju s dva parametra, a kada je pozivamo, pokušavamo navesti izvorni niz i NAZIV jedne metode kao parametre funkcije:
decimal(numberArray, round) - u ovom slučaju okruglo.

Ali nećemo dobiti nikakav rezultat jer NE MOŽETE navesti metodu NAME kao parametar funkcije.

Napomena: nije slučajnost da su u opisu problema nazivi metoda "round", "ceil" i "floor" stavljeni u navodnike.

decimal (numberArray, "round") - ali takav zapis također neće biti točan!!!

Rješenje broj 2 - Ispravljanje prethodnog rješenja

Problem možete riješiti navođenjem jednog parametra za funkciju.

var numberArray = ;

funkcija decimal (anyArray ) /* Kreirajte funkciju s jednim parametrom */
{

za (i = 0; i< anyArray .length ; i ++ ) /* Перебираем элементы массива */

{
document.write(anyArray + " - izvorni element niza
" ) /* Ispis trenutnog elementa niza */

/* Koristeći okruglu metodu objekta Math, zaokružujemo trenutni element niza */

document.write(anyArray + " - Zaobljeni element

" ) /* Ispis ROUNDED elementa niza */
}

decimal (numberArray ) /* Pozovite funkciju i navedite jedan parametar - originalni niz */

35 - Zaobljeni element

13 - Zaobljeni element

17 - Zaobljeni element

79 - Zaobljeni element

Ovdje smo uspjeli postići željeni rezultat: metoda zaokruživanja zaokružila je sve brojeve za . Ali uvjet nije ispunjen jer funkcija uzima samo jedan parametar.

Rješenje #3 - Funkcija s dva parametra

Ovdje je problem ispravno riješen. Da bih to učinio, morao sam se sjetiti javascript uvjeti tema i primijeniti nekoliko uvjeta istovremeno.

var numberArray = ;

funkcija decimal(anyArray,method)
{
za (i = 0; i< anyArray .length ; i ++ )
{
document.write(anyArray + " - izvorni element niza
" );

ako (metoda
{
bilo koji niz = Math.round (bilo koji niz);
document.write(anyArray + " - standardno zaokruživanje

" )
}

Inače ako (metoda
{

document.write (anyArray + " - zaokruži

" )
}

inače ako (metoda
{

document.write (anyArray + " - zaokruži prema dolje

" )
}

}
}
decimal (numberArray, "ceil") /* Drugi parametar funkcije - pod navodnicima označava naziv jedne od metoda */

34.82 - početni element niza
35 - zaokružiti

12.9 - početni element niza
13 - zaokružiti

17.01 - početni element niza
18 - zaokružiti

78.51 - početni element niza
79 - zaokružiti

Ovaj ispravno rješenje Domaća zadaća. Ovdje su navedena dva parametra za funkciju prema uvjetu.

Isprobajte ga zadnji redak ovo rješenje:
decimal(numberArray, "ceil") Kao drugi parametar funkcije odredite nazive ostalih metoda "round" i "floor" objekta Math.

Rješenje #4 - Funkcija s dva parametra + brza metoda

Odlučio sam malo optimizirati prethodno rješenje i dodao promptna metoda koji uzrokuje modalni prozor, koji sadrži polje za unos podataka.

Sada, zahvaljujući tome, možete unijeti naziv jedne od metoda round , floor ili ceil u polje za unos i dobiti odgovarajući rezultat.

var numberArray = ;

funkcija decimal(anyArray,method)
{
za (i = 0; i< anyArray .length ; i ++ )
{
document.write(anyArray + " - izvorni element niza
" );

if (method == "round" ) /* 1. uvjet */
{
bilo koji niz = Math.round (bilo koji niz);
document.write(anyArray + "

" )
}

Else if(method == "ceil" ) /* 2. uvjet */
{
bilo koji niz = Math.ceil (bilo koji niz);
document.write(anyArray + "

" )
}

else if(method == "floor" ) /* 3. uvjet */
{
bilo koji niz = Math.kat (bilo koji niz);
document.write(anyArray + "

" )
}

/* Dodaj metodu upita */

var method = prompt ("Unesite jednu od metoda: round, ceil ili floor" );

if (metoda == "pod" ) /* 1. uvjet */
{
document.write("Unijeli ste metodu " + metoda + " koja zaokružuje brojeve DOLJE

" )
}

else if (method == "round" ) /* 2. uvjet */
{
document.write("Unijeli ste metodu " + metoda + " koja zaokružuje brojeve prema standardnim pravilima

" )
}

else if (metoda == "ceil" ) /* 3. uvjet */
{
document.write("Unijeli ste metodu " + metoda + " koja zaokružuje brojeve

" )
}

else /* Inače... */
{
document.write("Niste unijeli ili ste unijeli metodu netočno

" )
}

decimal (numberArray, method ) /* Poziv funkcije */

Ovako funkcioniraju metode round, floor ili ceil matematičkog objekta, koje zaokružuju frakcijske brojeve.

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.

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 koja se zove Number.isFinite. Za razliku od isFinite, ne prisiljava argument da se pretvori u broj.

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

Funkcija isNaN dizajnirana je za određ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); //true 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 se ova radnja mora izvesti bez pretvaranja tipa, upotrijebite metodu Number.isNaN. Ova metoda je uvedena u jezik počevši od ECMAScripta 6.

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

1. Upotrijebite 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 Imajte na umu da se prazan niz ili niz koji se sastoji od razmaka i \n pretvara u broj 0. Osim toga, također pretvara nultu vrstu podataka i Booleove vrijednosti u broj.

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

2. Funkcija ParseInt. Ova je funkcija dizajnirana za pretvaranje argumenta u cijeli broj. Za razliku od korištenja unarnog + operatora, 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).

Broj možete pretvoriti 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 koju morate eksplicitno pretvoriti broj u niz:

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

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

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"); ) )

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 (больше), < (меньше), >= (veće ili jednako), 3); //lažna konzola.log(5>=3); //pravi

Kada se brojevi uspoređuju s frakcijskim dijelom, potrebno je uzeti u obzir pogreške koje mogu nastati 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 2. 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

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 => ostatak(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