În această parte a lecțiilor noastre ne vom familiariza cu obiectul Număr ca și în cazul unui container de tip de date numerice. Esența sa obiectivă reală va fi atinsă foarte superficial astăzi.

La fel ca obiectul Şir conține rânduri de text, obiect Număr conţine numere. La fel ca șirurile, numerele pe care le creăm devin automat instanțele unui obiect.

Tip de date număr

Numerele în JavaScript sunt de două tipuri: întreg și virgulă mobilă (nu există diviziuni în mai multe tipuri, ca în alte limbi întreg, lung, scurt, dublu). Numerele în virgulă mobilă au părți întregi și fracționale separate printr-un punct (indiferent de setările locale).

Aceste două tipuri de numere nu sunt tipuri independente și nu necesită o conversie specială între ele. Dacă, de exemplu, 32.5 ne vom inmulti cu 0.4 , apoi obținem imediat un număr întreg 13 , nu o fracțiune 13.0 , care trebuie convertit într-o valoare întreagă (cum este adesea cazul în alte limbi).

Crearea unui obiect Number

Ca și un șir, un număr este de obicei instanțiat ca obiect Număr, o atribuire simplă (spre deosebire de un șir, nu sunt necesare ghilimele).

var myNum = 21 ;

Dar puteți crea și un nou obiect folosind constructorul:

var myNum = Număr nou; myNum = 21;

În marea majoritate a cazurilor, acest lucru este inutil și chiar dăunător. Ne vom uita la exemple corecte de astfel de lucru cu obiecte în partea 4.

Reprezentarea numerelor

Formă exponențială

Numerele pot fi reprezentate fie în formă obișnuită, fie în formă exponențială, de exemplu:

2e6 // fără spații!

Înseamnă: 2 × 10 6

Dacă scoatem un astfel de număr prin metoda documentului scrie(), apoi obținem un număr extins în reprezentarea obișnuită.

Document. scrie(14e12);

Rezultat:

Sisteme numerice de bază

Numerele pot fi reprezentate și în sisteme zecimal, hexazecimal și octal.

Întreg numere în formă zecimală nu ar trebui să înceapă de la zero, deoarece zero este un prefix pentru sistemele non-zecimale. Doar 0 prefix pentru valori octale și 0x pentru hexazecimal.

De exemplu, 075 este reprezentarea octală a unui număr zecimal 61 , A 0x75 reprezentare hexazecimală a numărului zecimal 117 .

Pentru valori octale, numerele de la 0 la 7 , pentru seriile alfanumerice hexazecimale 0123456789ABCDEF. Se pot folosi litere în orice registru.

Expresiile aritmetice pot folosi orice formă de numere, dar rezultatul va fi întotdeauna reprezentat ca un număr zecimal.

Reprezentarea numerelor în alte sisteme

Vorbind despre obiect Şir, am atins metoda toString(), care convertește orice obiect într-un șir. Când convertiți numerele în șiruri, este recomandabil să specificați sistemul de numere ca argument.

Vă rugăm să rețineți

Numărul original trebuie inclus între paranteze

(număr). toString(sistem)

sistem poate lua orice valoare de la 2 la 36.

(157 ).toString(2 ); // reprezentare binară 157, egal (53 ).toString(27 ); // reprezentare exotică din 27 de cifre 53, egal

Dar aceste expresii rezultate sunt șiruri. Pentru a le face numere reale în sistemele numerice specificate, aveți nevoie de rezultatul metodei toString(sistem) converti înapoi în număr. Acest lucru nu se mai face prin metoda, ci funcția kernel Număr (obiect). Vom vorbi despre funcțiile nucleului într-una dintre lecțiile următoare, dar deocamdată acordați atenție sintaxei, este similar cu un apel de funcție:

var a = 1546; var b = a. toString(2); var c = Număr(b);

Sau imediat, „două într-unul”:

var a = 1546; var b = Număr(o. toString(2 ));

Nota

Dacă numărul inițial este atribuit unei variabile, atunci nu trebuie să fie plasat în paranteze atunci când apelați metoda toString() .

Proprietățile obiectului Number

Vom atinge proprietățile generale ale obiectului constructorului și prototipului în lecția despre obiect Obiect, iar acum să ne întoarcem la proprietățile specifice ale obiectului Număr.

Aceste proprietăți numai pentru citire, adică nu le putem schimba.

MAX_VALUE

Numărul maxim care poate fi procesat în JavaScript.

Să vedem ce fel de număr este acesta:

var e = Număr . MAX_VALUE document. scrie(e)

Rezultat:

1.7976931348623157e+308

Plus că în acest caz nu este un semn de adiție, ci un grad pozitiv, adică 1,7976931348623157 × 10.308

Nota

De obicei, demonstrez rezultate folosind scripturi scrise efectiv. Dar prea multe calcule fracționale pot încetini încărcarea paginii, iar majoritatea rezultatelor din acest tutorial sunt scrise de mână, ca să spunem așa.

MIN_VALUE

Și aceasta este în consecință valoarea minimă. Să-l explorăm.

var f = Număr . MIN_VALUE document. scrie(f)

Rezultat:

Adică 5 × 10 -324

O valoare non-numerică pe care am întâlnit-o deja.

Această proprietate este returnată de JavaScript atunci când o operație numerică produce într-un fel un rezultat non-numeric.

NEGATIVE_INFINITY, POSITIVE_INFINITY

Cândva s-au gândit la ceva de genul acesta: „un căprior, doi căprioare, multe căprioare”.

JavaScript contează puțin mai mult „avansat”: „un căprior, doi căprioare, trei căprioare, ... , 1,7976931348623157 × 10.308 căprioare, multe căprioare”.

Acest „mulți” transcendental este exprimat de proprietate POSITIVE_INFINITY.

Când procesul este invers, împărțind o unitate („un cerb”) în bucăți mici, mici, cea mai mică bucată numărată va fi de 5 × 10 -324 părți. Orice mai puțin este deja NEGATIVE_INFINITY.

Metodele obiectului Number

Notă: La fel ca metoda toString(), toate celelalte metode necesită ca numărul original să fie inclus în paranteze dacă este reprezentat explicit (mai degrabă decât ca o variabilă).

toExponential()

Returnează un șir care reprezintă un număr în notație științifică, cu o cifră înainte de virgulă zecimală.

Sintaxă:

număr. la Exponenţial(număr de caractere)

Argument număr de caractere specifică precizia de rotunjire după virgulă zecimală. Dacă argumentul este omis, numărul de cifre după virgulă zecimală este egal cu numărul de cifre necesare pentru a reprezenta valoarea.

Exemplu:

var myFullNumber = 4659872156831598853654127; document. scrie(myFullNumber.toExponential(4))

Rezultat:

toFixed()

Returnează un șir reprezentând un număr cu virgulă fixă, rotunjit la numărul de zecimale specificat în argument.

Sintaxă:

număr. la Fixat(număr de caractere)

Exemple:

var myDecimal1 = 46,59872156831598853654127; var myDecimal2 = 46 ; document. scrie(myDecimal1.toFixed(1)) document. scrie("
") document. scrie(myDecimal2.toFixed(3))

Rezultate:

Această metodă este uneori foarte utilă. De exemplu, funcția greoaie din ultima lecție poate fi acum reprezentată astfel:

funcția anyRootPlus(x, y) ( var srcnum = Math . exp(Matematica. jurnal(x)/y); var rezultat = (srcnum). la Fixat(3); returnează rezultatul; )

Acum să-l inserăm în formular și să-l testăm:

Adevărat, acum numerele întregi vor avea și trei zerouri după punct. Dar, cunoscând comportamentul numerelor și șirurilor de caractere, știind cum să lucrați cu operatorii condiționali și conversia tipului, nu este atât de dificil să faceți „proiectul” numeric necesar.

toLocaleString()

Convertește un obiect numeric într-o valoare șir, ținând cont de setările locale pentru separatoarele zecimale și separatorii de mii. Moneda națională este luată ca bază, prin urmare, în versiunea rusă toate numerele, chiar și numerele întregi, sunt prezentate cu două zecimale (kopecii):

var myDrob = 25,327; var myMnogo = 25635120; var myRoubl = 35 ; /* măriți-l pentru a vedea mai bine virgulele */ document. scrie("

" + myDrob. toLocaleString() + "

" ); document. scrie("

" + myMnogo. toLocaleString() + "

" ); document. scrie("

" + myRoubl. toLocaleString() + "

" );

Rezultate:

la Precizie()

Returnează un șir reprezentând un număr cu numărul total specificat de cifre semnificative.

Sintaxă:

număr. la Precizie(cantitateCifre)

Argument:

cantitateCifre numărul de cifre din rândul afișat. Dacă cantitatea specificată este mai mare decât cantitatea din numărul original, sunt afișate zerouri zecimale.

Document. scrie((354 ).la Precizie(8 ))

Rezultat:

Metode la Precizie()Şi toLocaleString()împreună nu functioneaza, pentru „designul rusesc” al numerelor de orice precizie, va trebui să vă scrieți propria funcție. Funcția scrisă poate fi o metodă suplimentară a obiectului Număr, am făcut deja ceva similar cu obiectul Data(). Mai multe detalii în lecția despre obiect Obiect.

toString()

Ei bine, am discutat deja despre această metodă în detaliu la începutul lecției.

Creează-ți propria metodă

Acum vom crea aceeași metodă care va afișa un număr cu orice număr de zecimale cu spații între al miilea și cu o virgulă ca separator zecimal.

Pentru a face acest lucru, avem nevoie de o funcție destul de complicată care va converti șirurile și matricele obținute dintr-o instanță a unui obiect Număr.

Să declarăm metoda:

Number.prototype.toRussianString = laRussianString

Înainte de a începe construirea funcției, să formulăm sarcinile.

Mai întâi trebuie să reprezentăm numărul ca șir și să extragem din el partea întreagă, partea fracțională și punctul separator.

Apoi plasați spațiile necesare în partea întreagă, rotunjiți partea fracțională la numărul de caractere care pot fi specificate ca argument pentru funcție (și metodă) și schimbați punctul cu virgulă.

Să începem funcția prin declararea variabilelor necesare.

funcția toRussianString(prec) ( /* variabile pentru conversia șirurilor */ var a = "" , b = "" , c, d, e;

Privind în viitor, voi spune că partea zecimală, ca urmare a perturbărilor noastre de șir, își pierde esența „fracțională” și trebuie să lucrăm cu ea ca cu un alt număr întreg. Pentru a lucra cu el vom folosi metoda la Precizie(), iar argumentul funcției noastre (și în același timp al metodei noastre) stabilește valoarea specific pentru metodă la Precizie(). Parametrul minim al acestei metode este unul. Și funcția noastră poate avea nevoie de zero (atunci când se rotunjește la un număr întreg). Și, în același timp, rotunjirea corectă ar trebui să funcționeze chiar înainte de a începe să „dezmembram” obiectul. Prin urmare, imediat când declarăm variabile, vom ocoli această capcană:

/* variabilă care convertește instanța obiectului dat într-un șir */ if (prec == 0 ) var str = this . la Fixat(0 ).toStringtoString(10 );

Continuăm să declarăm variabile.

/* variabilă pentru valoarea returnată */ var nr1; /* variabile pentru părți ale „exploziei” */ var intpart, fractpaft, precpart, divider, dot = str. ultimulIndexOf("." ); /* counter */ var i;

Variabilă punct găsește poziția unui punct într-un șir cu numărul specificat. În această poziție tăiem întreaga parte ( intpart). Dacă numărul este un întreg și nu există niciun punct, poziția sa va fi mai mică decât zero. În acest caz, separatorul ( separator), și partea fracționară ( fractpart) trebuie să fie șiruri goale. În caz contrar, o virgulă este atribuită separatorului, iar partea fracțională este tăiată pentru lucrări ulterioare:

dacă (punct< 0 ) { intpart = str; fractpart = "" ; divizor = "" ;) else (intpart = str. subșir(0, punct); subșir fracpart = str. (punct + 1, str. lungime "," ;}

);

divizor = (punct + 1, str. > 3 ) {

Lucrăm cu toată partea. Spațiile sunt necesare numai dacă există mai mult de 3 caractere:

dacă (intpart.

Acum să jucăm următorul joc „solitaire” (toate acestea se întâmplă în interiorul unei declarații condiționate): Să parcurgem tripletele în ordine inversă. Mai întâi, să le colectăm într-o variabilă o fără adăugiri, doar pentru a calcula lungimea subșirului rezultat. La urma urmei, dacă numărul total de cifre nu era divizibil cu 3, atunci o coadă de 1 sau 2 cifre a rămas în stânga, iar acum îl putem exprima ca subșir scăzând lungimea subșirului cu „trei” din lungimea întregului șir (variabilă c).

). Și puneți în față un spațiu care nu se rupe (pe care îl vom elimina mai târziu). Pentru ce? Deoarece grupurile de trei cifre au fost citite în ordine inversă, această coadă inițială ar trebui să fie plasată la sfârșitul rândului. Adică, dacă avem un număr, să zicem, 36748521, trebuie să aliniem 521.748 36, punând un spațiu nedespărțitor în fața fiecărui grup, astfel încât să existe un separator pentru matrice (la urma urmei, trebuie să le răsturnăm înapoi, iar acest lucru se poate face folosind metoda matricei verso().

În ultima instrucțiune a buclei, vom aranja în triplete și vom scrie rezultatul într-o variabilă (punct + 1, str. b pentru (i=intpart.-3; i>=0; i-=3) /* colectează tripleți */( a = a + intpart. substr(i, 3); " " /* găsiți „coada” din stânga */ /* colectează tripleți */ c = (punct + 1, str.+ intpart. (punct + 1, str.); (0 , intpart.-o. " " /* găsiți „coada” din stânga */ /* colectează tripleți *//* plasează separatorii în tripleți */

b = b + (i, 3);) Când adăugați șiruri b+c).

obținem un șir care trebuie convertit într-o matrice, iar apoi această matrice este inversată și convertită înapoi într-un șir (totul este scris într-o variabilă d(" " ).D = (b+c).().toString().Despică verso " " );

înlocui (/,/g, Matricea este convertită într-un șir împreună cu delimitatorii de virgulă, nu avem nevoie de ele. Prin urmare, în aceleași instrucțiuni le eliminăm folosind /,/ expresie regulată /,/g , Unde crearea unei expresii regulate pentru virgulă și

g

„steagul”, care indică faptul că trebuie să înlocuiți toate modelele de expresie (pur și simplu puneți toate virgulele) care apar în linie. Le înlocuim cu aceleași spații care nu se rupe. dacă (lungimea.parte > 3)).

Cert este că fie la începutul, fie la sfârșitul rândului nostru va exista un spațiu suplimentar care nu se poate întrerupe format din 6 caractere: „&”, „n”, „b”, „s”, „p” și „ ;”. Prin urmare, să curățăm gunoiul și să scriem rezultatul într-o variabilă e:

dacă (d. subșir(0 , 1 ) == "&" ) e = d. subșir(6, d. (punct + 1, str.-6); altfel e = d. subșir(0, d. (punct + 1, str.-6 );

Acum putem, cu conștiința curată, să închidem întregul operator condiționat și să scriem o opțiune alternativă pentru un număr scurt care nu trebuie împărțit în „trei”.

) else e = intpart;

Deci variabila e stochează partea întreagă a numărului și ne vom ocupa de zecimală.

Atenţie! Când lucrăm cu partea fracțională (care acum trebuie tratată ca un întreg), trebuie să ne amintim că atunci când prec == 0 funcția va avea probleme, așa că să o conectăm imediat:

dacă (prec != 0 ) (

Acum poți lucra în pace. Dar mai sunt câteva „pietre” pe care acum le vom ocoli.

În primul rând, dacă avem o parte fracțională, să presupunem 41 , și setăm rotunjirea la 3 cifre, apoi metoda la Precizie, luând partea noastră fracțională ca un întreg, va rezulta 41.0 , adică trebuie să eliminați punctul.

În al doilea rând, dacă partea fracțională a numărului original este mai mare de 3 cifre, atunci metoda la Precizie va începe să producă rezultatul în formă exponenţială. Va trebui să lupți și tu cu asta.

Prin urmare, vom „curăța” rezultatul prin trei variabile: precpart, precpart1Şi precpart2.

Precpart = (Număr (fractpart). la Precizie(prec)). toString(10 )

Acum „curățăm”:

/* dacă există o parte fracțională */ dacă (fractpart != "") ( /* caută și elimină punctul */ precpart1 = precpart. Despică(".", "") /* verificați dacă există un exponent acolo, */ var plus = precpart1.lastIndexOf("e"); /* și dacă există, */ dacă (plus > 0) /* scoate-l de la rădăcini, */ precpart2 = precpart1. subșir(0 , plus); /* altfel */ altfel /* nu schimba nimic */ precpart2 = precpart1) /* dacă nu există o parte fracțională, */ altfel /* apoi scoatem zerouri și scăpăm din nou de punctul */ precpart2 = "," +precpart. Despică("." , "" )

Deoarece am indicat la început că, dacă nu există o parte fracțională în numărul original, nu există nicio virgulă, atunci în acest caz trebuie să o punem din nou.

) altfel ( /* adică dacă prec este încă zero, imprimați linii goale */ precpart2 = "" ; divizor = "" ; }

Și acordul final:

Nr1 = e + divizor + precpart2; întoarcere nr1; )

Întreaga funcție:

funcția toRussianString(prec) ( var a = "" , b = "" , c, d, e; if (prec == 0 ) var str = this . la Fixat(0 ).toString(10); else var str = this . toString(10); var nr1; var intpart, fractpaft, precpart, divider, dot = str. ultimulIndexOf("." ); var i; dacă (punct< 0 ) { intpart = str; fractpart = "" ; divizor = "" ;) else (intpart = str. subșir(0, punct); subșir fracpart = str. (punct + 1, str. lungime "," ;) dacă (intpart. (punct + 1, str.> 3 ) ( pentru (i=intpart. (punct + 1, str.-3; i>=0; i-=3 ) ( a = a + intpart. /* colectează tripleți */(i, 3); c = " " /* găsiți „coada” din stânga */ /* colectează tripleți */ c = (punct + 1, str.+ intpart. (punct + 1, str.); b = b + " " /* găsiți „coada” din stânga */ /* colectează tripleți */(i, 3);) d = (b+c). d(" " ).D = (b+c).().toString().Despică verso " " ); subșir(0 , 1 ) == "&" ) e = d. subșir(6, d. (punct + 1, str.-6); subșir(0, d. (punct + 1, str. altfel e = d. la Precizie(prec)). toString-6); ) else e = intpart; if (prec != 0 ) ( precpart = (Număr (fractpart). Despică(10) dacă (fractpart != "") ( precpart1 = precpart. subșir("".", "") var plus = precpart1.lastIndexOf("e"); "," +precpart. Despică("." , "" dacă (plus > 0 ) precpart2 = precpart1. "" ; divizor = "" (0 , plus);

else precpart2 = precpart1 ) else precpart2 =

) ) else ( precpart2 = scrie; ) nr1 = e + divizor + precpart2; întoarcere nr1; ) Această funcție poate fi apelată acum ca metodă.(3 ))

Rezultat:

Var MyNumber = 2569843359.6583521 document.

(Numărul meu.

to RussianString

Puteți plasa constructorul metodei și funcția într-o bibliotecă - adică într-un fișier .js care poate fi apelat din codul paginii web. Pe măsură ce scrieți metode pentru diferite obiecte, puteți sorta metodele în fișiere de bibliotecă pentru aceste obiecte și puteți utiliza metode suplimentare.

Acest lucru vă permite să remediați răspunsul lui @MarkElliot, astfel încât să funcționeze și pentru numere negative:

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

• Rețineți că metodele Math au avantajul față de operatorii pe biți că funcționează cu numere mai mari de 2 31 .
• JavaScript calculează în dreapta genul numerelor negative și restul numerelor neîntregi, urmând definițiile matematice ale acestora.

FLOOR este definit ca „cel mai mare întreg mai mic decât parametrul”, astfel:

numere pozitive: FLOOR(X) = parte întreagă a lui X;

gammax a răspuns corect, acest cod funcționează conform instrucțiunilor lui Yarin. Pe de altă parte, Samuel greșește, nu a făcut calculul, cred, sau ar fi văzut că asta chiar funcționează (de asemenea, nu a spus care este divizorul exemplului său, dar sper să fie 3) :

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

GoesInto = (X - Rest) / Y = (-100 - -1) / 3 = -99 / 3 = -33

Apropo, am testat codul pe Firefox 27.0.1, a funcționat așa cum era de așteptat cu numere pozitive și negative, precum și cu valori non-întregi, atât pentru dividende, cât și pentru divizori. Exemplu:

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

Da, am observat că există o problemă de mare precizie, dar nu am avut timp să o verific (nu știu dacă este o problemă cu Firefox, Windows 7 sau cu FPU-ul procesorului meu). Cu toate acestea, pentru întrebarea lui Yarin, care implică doar numere întregi, codul gammax funcționează bine.

Puteți utiliza funcția parseInt pentru a obține rezultatul trunchiat.

ParseInt(a/b)

Pentru a obține restul, utilizați operatorul mod:

parseInt are unele capcane cu șiruri pentru a evita utilizarea parametrului radix cu baza 10

ParseInt("09", 10)

În unele cazuri, reprezentarea în șir a unui număr poate fi o notație științifică, caz în care parseInt va produce un rezultat incorect.

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

Acest apel va produce rezultatul 1.

Calcularea numărului de pagini se poate face într-un singur pas: Math.ceil(x/y)

Dacă doar împărțiți puterile a doi, puteți utiliza operatori pe biți:

Funcția de export divideBy2(num) ( return ; ) funcția de export divideBy4(num) ( return ; ) funcția de export divideBy8(num) ( return ; )

(Primul este particularul, al doilea este restul)

Aceasta se va trunchia întotdeauna la zero. Nu sunt sigur dacă este prea târziu, dar aici scrie:

Funcția intdiv(dividend, divisor) ( divizor = divizor - divizor % 1; if (divizor == 0) throw new Error("diviziune cu zero"); dividend = dividend - dividend % 1; var rem = dividend % divizor; returnare ( rest: rem, cot: (dividend - rem) / divizor )

Nu sunt un expert în operatorii pe biți, dar iată o altă modalitate de a obține un număr întreg:

Var num = ~~(a / b);

Acest lucru va funcționa bine și pentru numerele negative, în timp ce Math.floor() se va roti în direcția greșită.

Si asta pare corect:

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

Math.floor(operation) returnează valoarea rotunjită a operației.

Exemplu de întrebare 1:

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

Prefix:

Exemplu de întrebare 2:

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

Prefix:

Pentru un număr y și un divizor x, calculați factorul (coeficientul) și restul (restul) ca:

Var quotient = Math.floor(y/x); var rest = y % x;

Adesea, calculele produc rezultate care sunt în afara intervalelor dorite. Ca urmare, este necesar să se implementeze Rotunjire JavaScript până la o anumită valoare.

De ce numere rotunde?

JavaScript nu stochează numere întregi deoarece valorile lor sunt reprezentate ca numere în virgulă mobilă. Multe fracții nu pot fi reprezentate ca un număr cu un anumit număr finit de zecimale, astfel încât JavaScript poate genera rezultate precum următoarele:

0.1 * 0.2; > 0.020000000000000004

În practică, acest lucru nu va face nicio diferență, deoarece vorbim despre o eroare de 2 chintilioane. Dar acest lucru poate afecta rezultatele atunci când lucrați cu numere care reprezintă valori monetare, procente sau dimensiunea fișierului. Prin urmare, trebuie să faceți sau la o anumită zecimală.

Rotunjirea numerelor zecimale

Pentru a „taia” un număr zecimal, utilizați metodele toFixed() sau toPrecision(). Ambele au un singur argument, care specifică numărul de locuri semnificative și zecimale care trebuie incluse în rezultat:

• dacă toFixed() nu are niciun argument specificat, valoarea implicită este 0, adică fără zecimale; valoarea maximă a argumentului este 20;
• dacă nu i se dă niciun argument lui toPrecision(), numărul nu este schimbat.

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"

Nota

Atât toFixed() cât și toPrecision returnează o reprezentare șir rotunjită a rezultatului, mai degrabă decât un număr. Aceasta înseamnă că adăugarea rotunjită la randNum va avea ca rezultat o concatenare de șiruri, mai degrabă decât un singur număr:

console.log(RandNum + rotunjit); > „6.256”

Dacă doriți ca JavaScript să rotunjească un număr la cele mai apropiate sutimi, utilizați parseFloat() :

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

toFixed() și toPrecision() sunt, de asemenea, metode utile pentru trunchierea unui număr mare de zecimale. Acest lucru este util atunci când lucrați cu numere care reprezintă unități monetare:

var wholeNum = 1 var dollarsCents = wholeNum.toFixed(2); console.log(dollarsCents); > „1.00”

Rețineți că, dacă un număr are mai multe cifre decât precizia specificată, toPrecision va scoate rezultatul în format științific:

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

Cum să evitați greșelile atunci când rotunjiți zecimale

În unele cazuri, se implementează Fixed și Precision JavaScript rotunjind 5 în jos, și nu la mai mult:

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

Rezultatul exemplului de mai sus ar trebui să fie 1.01, nu 1. Dacă doriți să evitați această eroare, vă recomand să utilizați numere exponențiale:

funcția rotund(valoare, zecimale) ( returnează Număr(Math.round(valoare+"e"+zecimale)+"e-"+zecimale); )

Aplicație:

rotund(1.005,2); > 1.01

Dacă aveți nevoie de o soluție și mai robustă decât rotunjirea, aceasta este disponibilă la MDN.

Rotunjire cu epsilon

Metodă alternativă JavaScript rotunjit la zecimi a fost introdus în ES6 ( cunoscut și sub numele de JavaScript 2015). « Epsilon de mașină" oferă o marjă rezonabilă de eroare atunci când se compară două numere în virgulă mobilă. Fără rotunjire, comparațiile pot produce rezultate similare cu următoarele:

0,1 + 0,2 === 0,3 > fals

Math.EPSILON poate fi folosit într-o funcție pentru a obține o comparație validă:

funcția epsEqu(x, y) ( returnează Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

Funcția ia două argumente: unul conține calculele, al doilea rezultatul așteptat (rotunjit). Returnează o comparație a acestor doi parametri:

epsEqu(0,1 + 0,2, 0,3) > adevărat

Toate browserele moderne acceptă funcțiile matematice ES6. Dar dacă trebuie să oferiți asistență în browsere mai vechi, atunci trebuie să utilizați polyfills.

Trunchierea numerelor zecimale

Toate metodele prezentate anterior funcționează JavaScript rotunjit la zecimi. Pentru a trunchia un număr pozitiv la două zecimale, înmulțiți-l cu 100, trunchiați-l din nou și apoi împărțiți rezultatul la 100:

funcția trunchiat(num) ( returnează Math.trunc(num * 100) / 100; ) trunchiat(3.1416) > 3.14

Dacă aveți nevoie de ceva mai flexibil, puteți utiliza operatorul pe biți:

funcția trunchiată(num, decimalPlaces) ( var numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )

Utilizare:

var randInt = 35,874993; trunchiat(randInt,3); > 35.874

Rotunjiți la cel mai apropiat număr

A implementa Rotunjirea JavaScript la cel mai apropiat număr întreg, Math.round() este folosit:

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

Rețineți că " jumatate de valori", cum ar fi .5, sunt rotunjite în sus.

Rotunjiți în jos la cel mai apropiat număr întreg

Dacă doriți să rotunjiți în jos, utilizați metoda Math.floor():

Math.floor(42,23); > 42 Math.floor(36,93); > 36

Rotunjirea în jos are o singură direcție pentru toate numerele, inclusiv pentru cele negative. Acesta poate fi imaginat ca un zgârie-nori cu un număr infinit de etaje, inclusiv sub nivelul fundației ( reprezentând numere negative). Dacă vă aflați în liftul dintre etajele 2 și 3 de la subsol ( care corespunde unei valori de -2,5), Math.floor vă va duce la etajul -3:

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

Dacă trebuie să evitați acest lucru, utilizați JavaScript Math rotunjire folosind Math.trunc() , acceptat în toate browserele moderne (cu excepția IE/Edge):

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

MDN oferă, de asemenea polyfill cu trei linii pentru a oferi suport pentru Math.trunc în browsere mai vechi și IE/Edge.

Rotunjiți până la cel mai apropiat număr întreg

Dacă doriți să rotunjiți numerele zecimale în sus, utilizați Math.ceil . Această metodă poate fi considerată și ca un lift infinit: Math.ceil te duce întotdeauna „în sus”, indiferent dacă numărul este negativ sau pozitiv:

Math.ceil(42,23); > 43 Math.ceil(36,93); > 37 Math.ceil(-36,93); -36

Rotunjiți la cel mai apropiat multiplu

Dacă trebuie să rotunjiți o valoare la cel mai apropiat multiplu de 5, creați o funcție care împarte numărul la 5, îl rotunjește și apoi înmulțește rezultatul cu aceeași valoare:

funcția roundTo5(num) ( returnează Math.round(num/5)*5; )

Utilizare:

roundTo5(11); > 10

Dacă aveți nevoie de JavaScript pentru a rotunji la două cifre, puteți trece atât sămânța, cât și multiplul funcției:

funcția roundToMultiple(num, multiple) ( returnează Math.round(num/multiplu)*multiplu; )

Pentru a utiliza funcția, includeți numărul de rotunjit și multiplu în apelul său:

var initialNumber = 11; var multiplu = 10; roundToMultiple(initialNumber, multiple); > 10;

Pentru a rotunji doar valorile în sus sau în jos, înlocuiți rotunjirea cu tavan sau podea în funcție.

Legătura de gamă

Uneori trebuie să obțineți o valoare pentru x care trebuie să fie într-un anumit interval. De exemplu, avem nevoie de o valoare de la 1 la 100, dar obținem valoarea 123. Pentru a remedia acest lucru, puteți folosi min() ( returnează cel mai mic număr) și max ( returnează numărul maxim permis).

Utilizare:

var lowBound = 1; var highBound = 100; var numInput = 123; var blocat = Math.max(lowBound, Math.min(numInput, highBound)); console.log(blocat); > 100;

Puteți crea o funcție sau o extensie a clasei Number.

În acest articol vom analiza în detaliu numere, operatori matematici, modalități de a converti un număr într-un șir și invers, precum și multe alte puncte importante.

funcția isFinite

Funcția isFinite vă permite să verificați dacă un argument este un număr finit.

Ca răspuns, această funcție returnează false dacă argumentul este Infinity, -Infinity, NaN sau va fi turnat la una dintre aceste valori numerice speciale. În caz contrar, această funcție va returna true.

IsFinite(73); // adevărat este finit(-1/0); // false este Finit(Infinit); // false este finit(NaN); // false este finit("Text"); // fals

Pe lângă funcția globală isFinite, JavaScript are și metoda Number.isFinite. Spre deosebire de isFinite, nu forțează ca argumentul să fie convertit într-un număr.

IsFinite("73"); // true Number.isFinite("73"); // fals

funcția isNaN

Funcția isNaN este concepută pentru a determina dacă un argument este un număr sau poate fi convertit în unul. Dacă da, atunci funcția isNaN returnează false. În caz contrar, se întoarce adevărat.

IsNaN(NaN); //true isNaN ("25px"); //adevărat, pentru că 20px nu este un număr isNaN(25,5); //false isNaN ("25.5"); //false isNaN(" "); //fals, pentru că un spațiu sau mai multe spații sunt convertite în 0 isNaN(null); //fals, pentru că null este convertit la 0 isNaN(true); //fals, pentru că adevărat este convertit la 1 isNaN(fals); //fals, pentru că false este convertit la 0

Dacă această acțiune trebuie efectuată fără un tip cast, atunci utilizați metoda Number.isNaN. Această metodă a fost introdusă în limbaj începând cu ECMAScript 6.

Cum se transformă în mod explicit un șir într-un număr?

Puteți converti explicit un șir într-un număr folosind următoarele metode:

1. Utilizare operator unar +, care trebuie plasat înaintea valorii.

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

Această metodă ignoră spațiile de la începutul și sfârșitul liniei, precum și \n (line feed).

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

Folosind această metodă, trebuie să acordați atenție faptului că un șir gol sau un șir format din spații și \n este convertit la numărul 0. În plus, convertește și tipul de date nul și valorile booleene într-un număr. .

Nul; //0 +adevărat; //1 +fals; //0 +" "; //0

2. Funcția ParseInt. Această funcție este concepută pentru a converti argument la număr întreg. Spre deosebire de utilizare operator unar +, această metodă vă permite să convertiți un șir într-un număr în care nu toate caracterele sunt numerice. Începe să convertească șirul, începând de la primul caracter. Și de îndată ce întâlnește un caracter nenumeric, această funcție își oprește activitatea și returnează numărul rezultat.

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

Această funcție poate funcționa cu diferite sisteme de numere (binar, octal, zecimal, hexazecimal). Baza sistemului numeric este specificată folosind 2 argumente.

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

Pe lângă funcția parseInt, JavaScript are metoda Number.parseInt. Această metodă nu este diferită de funcția parseInt și a fost introdusă în JavaScript cu specificația ECMASCRIPT 2015 (6).

3. funcția parseFloat. Funcția parseFloat este similară cu parseInt , cu excepția faptului că vă permite să convertiți argumentul într-un număr fracționar.

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

În plus, funcția parseFloat, spre deosebire de parseInt, nu are 2 argumente și, prin urmare, încearcă întotdeauna să trateze șirul ca un număr în sistemul de notație zecimală.

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

Pe lângă funcția parseFloat, JavaScript are metoda Number.parseFloat. Această metodă nu este diferită de funcția parseFloat și a fost introdusă în JavaScript cu specificația ECMASCRIPT 2015 (6).

Conversia unui număr într-un șir

Puteți transforma un număr într-un șir folosind metoda toString.

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

Metoda toString vă permite, de asemenea, să specificați baza sistemului de numere, ținând cont de care trebuie să convertiți în mod explicit numărul într-un șir:

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

Cum se verifică dacă o variabilă este un număr

Puteți determina dacă valoarea unei variabile este un număr utilizând una dintre următoarele metode:

1. Folosind funcțiile isNaN și isFinite:

// myVar este o variabilă dacă (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar este un număr sau poate fi turnat la acesta);

Ca functie:

// funcția funcției isNumeric(valoare) ( ​​return !isNaN(parseFloat(valoare)) && isFinite(parseFloat(valoare)); ) // folosește var myVar = "12px"; console.log(isNumeric(myVar)); //adevărat

Această metodă vă permite să determinați dacă valoarea specificată este un număr sau poate fi convertită în unul. Această opțiune nu numără șirul gol, șirul de spații, null, Infinity, -Infinity, true și false ca număr.

2. Folosind operatorul typeof și isFinite, funcțiile isNaN:

// funcție care verifică dacă valoarea este un număr." && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Această funcție determină dacă valoarea specificată este de tip Number și dacă este una dintre valorile speciale Infinity, -Infinity și NaN. Dacă da, atunci această funcție returnează true.

3. Folosind metoda ECMAScript 6 Number.isInteger(value). Această metodă vă permite să determinați dacă valoarea specificată este un număr întreg.

Number.isInteger("20"); //fals, pentru că această metodă nu convertește un șir într-un număr Number.isInteger(20); //adevărat, pentru că această valoare este un număr

Numere pare și impare

Puteți verifica dacă un număr este par sau impar folosind următoarele funcții:

// Funcție pentru verificarea unui număr pentru funcția de paritate pară isEven(n) ( return n % 2 == 0; ) // Funcție pentru verificarea unui număr pentru funcția de paritate impară isOdd(n) ( return Math.abs(n % 2) == 1;

Dar înainte de a efectua o astfel de verificare, este recomandabil să vă asigurați că valoarea specificată este un număr:

Valoare = 20; dacă (Număr.isInteger(valoare)) ( dacă (este Even(valoare)) ( console.log(„Număr „ + valoare.toString() + „ - par”); ) )

Numerele prime în Javascript

Să ne uităm la un exemplu în care vom afișa numere prime de la 2 la 100 folosind Javascript.

// Funcția care verifică dacă un număr este primă funcție isPrime(valoare) ( ​​dacă (isNaN(valoare) || !isFinite(valoare) || valoare%1 || valoare< 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);

Rotunjirea unui număr în Javascript

Există diferite moduri de a rotunji o fracție la un număr întreg în JavaScript.

1. Folosind metodele Math.floor, Math.ceil și Math.round special concepute pentru aceasta. Metoda Math.floor rotunjește o fracție la cel mai apropiat număr întreg, adică. pur și simplu aruncă partea fracționată. Math.ceil rotunjește o fracție până la cel mai apropiat număr întreg. Math.round rotunjește un număr în sus sau în jos, în funcție de valoarea părții fracționale. Dacă partea fracțională este mai mare sau egală cu 0,5, atunci în sus, în caz contrar, răsucirea este în jos.

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

2. Folosind metoda toFixed(precision). Această metodă rotunjește partea fracțională a unui număr la o precizie specificată. Rezultatul rotunjirii este returnat ca șir.

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

Dacă nu există suficiente zecimale pentru a forma precizia specificată a numărului, atunci acesta este umplut cu zerouri.

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

3. Folosind metoda toPrecision(accuracy). Această metodă reprezintă un număr cu o precizie specificată. În același timp, el poate rotunji nu numai fracționarea, ci și întreaga parte a numărului. În funcție de rezultat, această metodă poate prezenta numărul rezultat cu punct fix sau sub formă exponențială.

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. Folosind operatorii logici NOT sau OR.

//prin negație logică dublă console.log(~~7.9); //7 // folosind SAU logic cu zero: console.log(7.9^0); //7

Parte întreagă și fracționară a unui număr

Puteți obține partea întreagă a unui număr folosind metodele Math.floor() și parseInt():

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

Puteți obține partea fracționară a unui număr folosind operatorul procent (%). Acest operator returnează restul care va fi obținut din împărțirea primului număr la al doilea. În acest caz, trebuie să utilizați 1 ca al doilea număr.

Console.log(7,21%1); // 0,2099999999999996 // precis cu 2 zecimale console.log((7,21%1).toFixed(2)); // "0,21"

În plus, partea fracțională poate fi obținută și folosind calcule:

Număr var = 7,21; var fractionNumber = număr - Math.floor(Math.abs(număr)); console.log(fractionNumber); // 0,2099999999999996

Numărul este divizibil cu un număr întreg?

Puteți determina dacă un număr este divizibil cu un număr întreg folosind operatorul procentual:

Număr var = 9; // dacă restul numărului împărțit la 3 este 0, atunci da, altfel nu dacă (număr%3==0) ( console.log ("Numărul " + numărul + " este divizibil cu 3"); ) else ( consolă ("Numărul " + numărul + " nu este divizibil cu 3");

Formatarea numerelor

În JavaScript, metoda toLocaleString() vă permite să formatați rezultatul unui număr în conformitate cu standardele regionale (setările de limbă ale sistemului de operare).

De exemplu, să formatăm un număr în conformitate cu standardele regionale care sunt instalate implicit în sistem:

Număr var = 345,46; console.log(number.toLocaleString()); //"345,46"

De exemplu, să formatăm numărul în conformitate cu standardele regionale ale Rusiei (ru):

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

Această metodă poate fi folosită și pentru a formata un număr ca monedă:

Console.log((2540.125).toLocaleString("ru-RU",(style:"currency", currency:"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"))); //"2.301,99 EUR"

Reprezentarea unui număr ca procent:

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

Împărțiți un număr în cifre (proprietatea useGrouping):

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

Tipăriți un număr cu un anumit număr de cifre (2) după virgulă:

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

Comparația numerelor

Următorii operatori sunt utilizați pentru a compara numerele în JavaScript: == (egal), != (nu este egal), > (mai mare decât),< (меньше), >= (mai mare sau egal cu),<= (меньше или равно).

De exemplu, să comparăm două numere:

Console.log(2>3); //false console.log(5>=3); //adevărat

La compararea numerelor cu o parte fracțională, este necesar să se țină cont de erorile care pot apărea în timpul acestor calcule.

De exemplu, în JavaScript, suma numerelor (0,2 + 0,4) nu este egală cu 0,6:

Console.log((0,2+0,4)==0,6); //fals

Erorile apar deoarece un computer sau un alt dispozitiv electronic efectuează toate calculele în sistemul numeric al 2-lea. Aceste. Înainte de a efectua orice acțiune, computerul trebuie mai întâi să convertească numerele prezentate în expresie în al 2-lea sistem numeric. Dar nu orice număr zecimal fracționar poate fi reprezentat exact în al 2-lea sistem numeric.

De exemplu, numărul 0,25 10 este convertit exact în binar.

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

De exemplu, numărul 0,2 10 poate fi convertit în sistemul 2 numai cu o anumită precizie:

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

Ca urmare, aceste erori vor afecta calculul sumei a două numere și rezultatele comparației. Aceste. Se pare că JavaScript va vedea de fapt această intrare după cum urmează:

0.6000000000000001==0.6

Când calculați sau afișați numere cu părți fracționale, trebuie să indicați întotdeauna precizia cu care doriți să faceți acest lucru.

De exemplu, comparați numere cu până la 2 zecimale folosind metodele toFixed() și toPrecision():

//metoda toFixed() console.log(((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //metoda toPrecision() console.log(((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //adevărat

Operații matematice de bază

Următorii operatori matematici există în JavaScript: + (adunare), - (scădere), * (înmulțire), / (împărțire), % (modulo), ++ (creștere o valoare cu 1), -- (scădere o valoare cu 1).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, i.e. 6:3=2 => 6-3*2 => rest(0) 5%2 //1, i.e. 5:2=2(.5) => 5-2*2 => rest(1) 7.3%2 //1.3, i.e. 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //semnul rezultatului operației % este egal cu semnul primei valori -9%2.5 //-1.5 , adică 9:2.5=3(.6) => 9-2.5*3 => rest(1.5) -9%-2.5 //-1.5, i.e. 9:2.5=3(.6) => 9-2.5*3 => rest(1.5) -2%5 //-2, i.e. 2:5=0(.4) => 2-5*0 => rest(2) x = 3; console.log(x++); // scoate 3, apoi setează 4 console.log(x); //4 x = 3; console.log(++x); //setează 4 și iese x = 5; console.log(x--); // scoate 5, apoi setează 4 console.log(x); //4 x = 5; console.log(--x); //seturile 4 și iese În plus, JavaScript are operatori de combinație: 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).