Kako je cijeli broj predstavljen u js. Ukloniti - cjelobrojno dijeljenje s ostatkom u JavaScriptu? Rad s funkcijama snage

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

Rezati" decimalni broj, koriste se 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; maksimalna vrijednost argument 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 višestruka popunjavanja.

Skraćivanje decimalnih brojeva

Sve prethodno predstavljene metode izvode se JavaScript zaokruživanje na desetine. Da biste pozitivni broj skratili na dvije decimale, pomnožite ga sa 100, ponovno skratite i zatim rezultat podijelite sa 100:

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 podrumskih etaža 2 i 3 ( š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 linije 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 decimale, 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.

Ovo vam omogućuje da popravite odgovor @MarkElliota tako da radi i za negativne brojeve:

Var div = Math.trunc(y/x); var rem = y % x;

imajte na umu da Matematičke metode imaju prednost pred bitovnim operatorima jer rade s brojevima većim od 2 31 .

JavaScript izračunava s desne strane spol negativnih brojeva i ostatak necijelih brojeva, slijedeći matematičke definicije za njih.

FLOOR se definira kao "najveći cijeli broj manji od parametra", dakle:

• pozitivni brojevi: FLOOR(X) = cijeli dio od X;
• negativni brojevi: FLOOR(X) = cijeli broj od X minus 1 (jer bi trebao biti MANJI od parametra, tj. negativniji!)

OSTATAK je definiran kao "preostala" podjela (euklidska aritmetika). Kada dividenda nije cijeli broj, faktor obično također nije cijeli broj, tj. nema ostatka, ali ako je faktor prisiljen biti cijeli broj (a to je ono što se događa kada netko pokuša dobiti ostatak ili modul broj s pomičnim zarezom), očito će "ostati" cijeli broj.

JavaScript izračunava sve kako se očekuje, tako da programer mora paziti da postavi prava pitanja (a ljudi moraju paziti da odgovore na ono što se postavi!) Yarinovo prvo pitanje NIJE bilo "što je cjelobrojno dijeljenje X sa Y", umjesto ovo: " Broj cijelih brojeva koliko puta dati cijeli broj IDE u drugi." Za pozitivni brojevi odgovor je isti za oba, ali ne i za negativne brojeve, jer će cjelobrojno dijeljenje (dividenda s djeliteljem) biti -1 manje od broja (djelitelja) koji se "prevrće" (dividenda). Drugim riječima, FLOOR će vratiti točan odgovor za cjelobrojno dijeljenje negativnog broja, ali Yarin to nije pitao!

gammax je odgovorio točno, ovaj kod radi prema Yarinovim uputama. S druge strane, Samuel nije u pravu, pretpostavljam da nije napravio matematiku, inače bi vidio da ovo stvarno radi (također nije rekao koji je djelitelj njegovog primjera, ali nadam se da je bio 3) :

Ostatak = X% Y = -100% 3 = -1

Ide u = (X - ostatak) / Y = (-100 - -1) / 3 = -99 / 3 = -33

Usput, testirao sam kôd na Firefoxu 27.0.1, radio je očekivano s pozitivnim i negativnim brojevima, kao i necijelim vrijednostima, i za dividende i za djelitelje. Primjer:

100,34 / 3,57: GoesInto = -28, ostatak = -0,3800000000000079

Da, primijetio sam da postoji problem s visokom preciznošću, ali nisam imao vremena to provjeriti (ne znam je li to problem s Firefoxom, Windowsom 7 ili FPU-om mog CPU-a). Međutim, za Yarinovo pitanje, koje uključuje samo cijele brojeve, kod gammax radi dobro.

Možete koristiti funkciju parseInt da dobijete skraćeni rezultat.

ParseInt(a/b)

Da biste dobili ostatak, upotrijebite mod operator:

parseInt ima neke zamke s nizovima kako bi se izbjeglo korištenje radix parametra s bazom 10

ParseInt("09", 10)

U nekim slučajevima, prikaz niza broja može biti znanstvena notacija, u kojem će slučaju parseInt dati netočan rezultat.

ParseInt(10000000000000000000000000000000000, 10) // 1e+32

Ovaj poziv će dati rezultat 1.

Izračun broja stranica može se izvršiti u jednom koraku: Math.ceil(x/y)

Ako samo dijelite ovlasti dvoje, možete upotrijebiti bitovne operatore:

Eksport funkcije divideBy2(num) ( return ; ) eksport funkcije divideBy4(num) ( return ; ) eksport funkcije divideBy8(num) ( return ; )

(Prvo je posebno, drugo je ostalo)

Ovo će se uvijek skratiti na nulu. Nisam siguran je li prekasno, ali ovdje piše:

Funkcija intdiv(dividenda, divizor) ( divisor = divisor - divisor % 1; if (divisor == 0) throw new Error("division by zero"); dividenda = dividenda - dividend % 1; var rem = dividenda % divisor; return (ostatak: rem, količnik: (dividend - rem) / djelitelj);

Nisam stručnjak za bitovne operatore, ali evo još jednog načina da dobijete cijeli broj:

Var num = ~~(a / b);

Ovo će dobro funkcionirati i za negativne brojeve, dok će se Math.floor() okretati u pogrešnom smjeru.

Ovo se također čini točnim:

Var num = (a / b) >> 0;

Math.floor(operation) vraća zaokruženu vrijednost operacije.

Primjer pitanja 1:

Var x = 5; var y = 10,4; var z = Math.floor(x + y); konzola.log(z);

Konzola:

Primjer pitanja 2:

Var x = 14; var y = 5; var z = Math.floor(x%y); konzola.log(x);

Konzola:

Za neki broj y i neki djelitelj x izračunajte kvocijent i ostatak (ostatak) kao:

Var kvocijent = Math.floor(y/x); var ostatak = y % x;

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(), zadana će biti nula, što znači 0 decimalnih mjesta, argument ima najveću vrijednost od 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; 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"

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

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 je funkcija stepena predstavljena kao Math.pow(), au novom ES7 standardu uveden 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, 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

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

isNaN funkcija

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.

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 pažnju na to da prazna linija ili se niz koji se sastoji od razmaka i \n pretvara u broj 0. Osim toga, također pretvara null tip podataka i Boolean vrijednosti u broj.

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

2. Funkcija ParseInt. Ova funkcija je 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

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"

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 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, on se dopunjuje 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

Možete dobiti razlomački dio broja 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 + " je djeljiv 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 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 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 => 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