Js parte întreagă atunci când este împărțit. Metode pentru rotunjirea numerelor în JavaScript

Î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 unul dintre aceste speciali valori numerice. ÎN altfel 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

Cu excepţia functie globala isFinite JavaScript are și o metodă numită 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ă valoare falsă 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ă Rețineți 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 folosire 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 sisteme diferite Numere (binare, octale, zecimale, hexazecimale). 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).

Transformarea 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, de asemenea, dacă aparține unuia dintre sensuri 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 funcție primă 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",(style:"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).

x = 3; y = 6; x+=y; console.log(x); //9 x = 3; y = 6; x-=y; console.log(x); //-3 x = 3; y = 6; x*=y; console.log(x); //18 x = 3; y = 6; x/=y; console.log(x); //0,5 x = 3; y = 6; x%=y; console.log(x); //3 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?

0.1 * 0.2; > 0.020000000000000004

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:

Î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ă.

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 cea mai apropiată sutime, utilizați parseFloat() :

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

toFixed() și toPrecision() sunt, de asemenea, metode utile pentru tăiere cantitate mare 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 JavaScript rotunjit 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 browsere 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 browserele 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 prins = Math.max(lowBound, Math.min(numInput, highBound)); console.log(blocat); > 100;

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

De ce este necesară rotunjirea?

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Din punct de vedere practic, această inexactitate nu contează deloc, în cazul nostru vorbim despre o eroare în chintilioane, totuși, acest lucru îi poate dezamăgi pe unii. De asemenea, putem obține rezultate oarecum ciudate atunci când lucrăm cu numere care reprezintă monede, procente sau dimensiuni de fișiere. Pentru a corecta aceste inexactități, trebuie doar să putem rotunji rezultatele și este suficient să setăm precizia zecimală.

Rotunjirea numerelor are aplicații practice, putem manipula un număr într-un anumit interval, de exemplu, dorim să rotunjim o valoare la cel mai apropiat număr întreg, în loc să lucrăm doar cu partea zecimală.

Rotunjirea numerelor zecimale

1. Dacă un argument nu este definit pentru toFixed(), acesta va fi implicit zero, ceea ce înseamnă 0 zecimale, argumentul are o valoare maximă de 20.
2. Dacă toPrecision nu i se oferă niciun argument, numărul este lăsat neatins

Fie randNum = 6,25; let rounded = randNum.toFixed(); // "6" console.log(randNum + rotunjit); > „6.256”
Dacă doriți ca rezultatul să fie un tip de date numerice, atunci va trebui să utilizați parseFloat:

Fie randNum = 6,25; let rounded = parseFloat(randNum.toFixed(1)); console.log(rotunjit); > 6.3
Vă rugăm să rețineți că valorile de 5 sunt rotunjite, cu excepția cazurilor rare.

Metodele toFixed() și toPrecision() sunt utile, deoarece nu numai că pot tăia partea fracțională, ci și pot adăuga zecimale, ceea ce este convenabil când lucrați cu moneda:

Let wholeNum = 1 let dollarsCents = wholeNum.toFixed(2); console.log(dollarsCents); > „1.00”
Este de remarcat faptul că toPrecision va produce rezultatul în notație exponențială dacă numărul de numere întregi este mai mare decât precizia în sine:

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

Cum să evitați erorile de rotunjire cu zecimale

Fie numTest = 1,005; numTest.toFixed(2); > „1.00”
Rezultatul calculului de mai sus ar fi trebuit să fie 1,01, nu 1. Dacă doriți să evitați o eroare similară, putem folosi soluția propusă de Jack L Moore, care folosește numere exponențiale pentru calcul:

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

Rotunzi (1,005,2); > 1.01
Dacă doriți o soluție mai robustă decât cea prezentată mai sus, puteți merge la MDN.

Mașină epsilon rotunjire

0,1 + 0,2 === 0,3 > fals
Folosim Math.EPSILON în funcția noastră 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 are două argumente: primul este calculul curent, al doilea este rezultatul așteptat. Acesta returnează o comparație a celor două:

EpsEqu(0,1 + 0,2, 0,3) > adevărat
Toate browserele moderne acceptă deja funcții matematice ES6, dar dacă doriți suport în browsere precum IE 11, utilizați polyfills.

Tăierea părții fracționale

Funcția trunchiat(num) ( return Math.trunc(num * 100) / 100; ) trunchiat(3.1416) > 3.14
Dacă doriți să adaptați metoda la orice număr de zecimale, puteți utiliza negația dublă pe biți:

Funcția trunchiată(num, decimalPlaces) (let numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Acum:

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

Rotunjiți la cel mai apropiat număr

Math.round(4.3) > 4 Math.round(4.5) > 5
Vă rugăm să rețineți că „jumătate din valoare”, 0,5 este rotunjit în sus conform regulilor matematicii.

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

Math.floor(42,23); > 42 Math.floor(36,93); > 36
Vă rugăm să rețineți că rotunjirea în jos funcționează pentru toate numerele, inclusiv pentru numerele negative. Imaginați-vă un zgârie-nori cu un număr infinit de etaje, inclusiv etaje la nivelul de jos (reprezentând numere negative). Dacă vă aflați într-un lift la cel mai jos nivel între 2 și 3 (care reprezintă o valoare de -2,5), Math.floor vă va duce la -3:

Math.floor(-2,5); > -3
Dar dacă doriți să evitați această situație, utilizați Math.trunc, acceptat în toate browserele moderne (cu excepția IE/Edge):

Math.trunc(-41,43); > -41
Pe MDN veți găsi un polyfill care va oferi suport pentru Math.trunc în browsere și IE/Edge.

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

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

Rotunjire în sus/în jos la numărul necesar

Funcția roundTo5(num) ( return Math.round(num/5)*5; )
Acum:

RoundTo5(11); > 10
Dacă doriți să rotunjiți la multipli ai valorii dvs., folosim o funcție mai generală, trecându-i valoarea inițială și multiplu:

Funcția roundToMultiple(num, multiple) ( returnează Math.round(num/multiple)*multiple; )
Acum:

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

Fixarea unui număr într-un interval

Fie lowBound = 1; lasă highBound = 100; fie numInput = 123; let clamped = Math.max(lowBound, Math.min(numInput, highBound)); console.log(blocat); > 100;
Din nou, putem reutiliza operația și înfășura totul într-o funcție, folosind soluția propusă de Daniel X. Moore:

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

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

rotunjire gaussiană

Funcția gaussRound(num, decimalPlaces) ( fie 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; }
Acum:

GaussRound(2,5) > 2 gaussRound(3,5) > 4 gaussRound(2,57,1) > 2,6
Decimală în CSS:

Deoarece JavaScript este adesea folosit pentru a crea mapări poziționale pentru elementele HTML, s-ar putea să vă întrebați ce s-ar întâmpla dacă am genera valori zecimale pentru elementele noastre:

#box ( lățime: 63,667731993px; )
Vestea bună este că browserele moderne vor respecta valorile zecimale în modelul bloc, inclusiv unitățile procentuale sau pixelii.

Triere

Sortarea alfabetică

Lăsați fructe = [„dovleac”, „caise”, „cântapă”]; fruct.sort(); > „caisă”, „dovleac”, „gustalup”]
Cu toate acestea, ne confruntăm cu o problemă de îndată ce unul dintre elemente este cu litere mari:

Lasa fructe = ["dovleac", "caise", "Cantalope"]; fruct.sort(); > „Cantalup”, „caise”, „dovleac”]
Acest lucru se datorează faptului că, în mod implicit, sortatorul compară primul caracter reprezentat în Unicode. Unicode este cod unic pentru orice simbol, indiferent de platformă, indiferent de program, indiferent de limbă. De exemplu, dacă te uiți la tabelul de coduri, caracterul „a” are valoarea U+0061 (în hexazecimal 0x61), în timp ce caracterul „C” are codul U+0043 (0x43), care vine mai devreme în Unicode tabel decât caracterul „a”.

Pentru a sorta o matrice care poate conține primele litere mixte, trebuie fie să convertim temporar toate elementele în litere mici, sau definiți-vă propria ordine de sortare folosind metoda localeCompare() cu unele argumente. De regulă, pentru un astfel de caz, este mai bine să creați imediat o funcție pentru utilizare repetată:

Funcția alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("sensibilitate": "bază")); )); ) let fruit = ["dovleac butternut „, „caisă”, „Cantalup”]; alphaSort(fructe) >
Dacă doriți ca matricea să fie sortată în ordine alfabetică inversă, schimbați pur și simplu pozițiile lui a și b în funcție:

Funcția alphaSort(arr) ( arr.sort(function (a, b) ( return b.localeCompare(a, "en", ("sensibilitate": "bază")); )); ) let fruit = ["dovleac butternut „, „caisă”, „Cantalup”]; alphaSort(fructe) > ["Cantalupe", "dovleac", "caise"]
Aici este de remarcat faptul că localeCompare este folosit cu argumente, trebuie să ne amintim, de asemenea, că este suportat de IE11+, pentru versiunile mai vechi de IE, îl putem folosi fără argumente și cu litere mici:

Funcția caseSort(arr) ( arr.sort(funcție (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) let fruit = ["dovleac", "caise", "Pepene galben"]; caseSort(fructe) > ["caise", "dovleac", "Cantalupe"]

Sortare numerică

Fie highScores = ; highScores.sort(); >
Chestia este că metoda sort() realizează o comparație lexicografică: ceea ce înseamnă că numerele vor fi convertite într-un șir și comparațiile se vor face din nou prin potrivirea primului caracter al acelui șir în ordinea caracterelor din tabelul Unicode. . Prin urmare, trebuie să definim din nou ordinea noastră de sortare:

Fie highScores = ; highScores.sort(funcție(a,b) ( returnează a - b; )); >
Din nou, pentru a sorta numerele în ordine inversă, schimbați pozițiile lui a și b în funcție.

Sortarea unei structuri asemănătoare JSON

Fiți scoruri = [ ( „nume”: „Daniel”, „scor”: 21768 ), ( „nume”: „Michael”, „scor”: 33579 ), ( „nume”: „Alison”, „scor”: 38395 ) ];
În ES6+, puteți utiliza funcții de săgeți:

Scores.sort((a, b) => b.score - a.score));
Pentru browserele mai vechi care nu au acest suport:

Scores.sort(funcție(a, b) ( returnează a.score - b.score ));
După cum puteți vedea, sortarea în JavaScript este un lucru destul de obscur, sper că aceste exemple vor face viața mai ușoară cumva.

Lucrul cu funcții de putere

În JavaScript, funcția de putere este reprezentată ca Math.pow(), iar în noul standard ES7, a fost introdus un nou operator de exponențiere - " * * ".

Exponentiație

Math.pow(3,2) > 9
Această formă de notație înseamnă 3 pătrat, sau 3 × 3, ceea ce duce la rezultatul 9. Un alt exemplu poate fi dat, desigur:

Math.pow(5,3); > 125
Adică, 5 cuburi, sau 5 × 5 × 5, este egal cu 125.

ECMAScript 7 este următoarea versiune de JavaScript, în principiu, putem folosi noul operator de exponențiere propus - * *, această formă de notație poate fi mai descriptivă:

3 ** 2 > 9
Pe în acest moment Suportul pentru acest operator este destul de limitat, deci utilizarea lui nu este recomandată.

Funcția de putere poate fi utilă în cele mai multe situatii diferite. Un exemplu simplu, calcularea numărului de secunde într-o oră: Math.pow (60,2).

Rădăcini pătrate și cubice

Math.sqrt(9) > 3
În același timp, rădăcina cubă a lui a este un număr care dă a atunci când este ridicat la un cub.

Math.cbrt(125) > 5
Math.cbrt() a fost introdus doar recent în specificația JavaScript și, prin urmare, este acceptat doar în browserele moderne: Chrome 38+, Firefox și Opera 25+ și Safari 7.1+. Vei observa asta Internet Explorer nu se află pe această listă, dar veți găsi un polyfill pe MDN.

Exemple

Math.pow(1,25, 2); > 1,5625 Math.cbrt(56,57) > 3,8387991760286138
Vă rugăm să rețineți că acest lucru funcționează destul de bine și atunci când utilizați valori negative ale argumentelor:

Math.pow(-5,2) > 25 Math.pow(10,-2) > 0,01
Cu toate acestea, acest lucru nu va funcționa pentru rădăcina pătrată:

Math.sqrt(-9) > NaN
Din analiza matematică știm că un număr imaginar se referă la rădăcinile pătrate ale numerelor negative. Și asta ne poate conduce la o altă tehnică de lucru cu numere complexe, dar asta este o altă poveste.

Puteți folosi fracții în Math.pow() pentru a găsi rădăcinile pătrate și cubice ale numerelor. Rădăcina pătrată folosește un exponent de 0,5:

Math.pow(5, 0,5); // = Math.sqrt(5) = 5 ** (1/2) > 2,23606797749979
Cu toate acestea, din cauza capricilor virgulă mobilă, nu puteți ghici exact rezultatul corect:

Math.pow(2,23606797749979,2) > 5,000000000000001
În astfel de situații, va trebui să recurgeți la tăierea semnelor din număr sau rotunjirea la o anumită valoare.

Unii oameni, din motive necunoscute, în JavaScript confundă funcția Math.pow() cu Math.exp() , care este funcția exponențială pentru numere în general. Notă: în engleză„exponent” este tradus ca „exponent”, deci este mai probabil să se aplice vorbitorilor de engleză, deși există denumiri alternative pentru exponent, cum ar fi index, putere.

Constante matematice

Math.abs, parseInt, parseFloat

Math.abs()

Fie newVal = -57,64; Math.abs(newVal); > 57,64
Math.abs(0) returnează întotdeauna zero, dar dacă punem un semn minus în fața funcției -Math.abs(NUM) vom obține întotdeauna o valoare negativă.

Math.abs(0); > -0

parseInt()

Sintaxă: parseInt(șir, radix);

Funcția parseInt convertește primul argument transmis într-un tip șir, îl interpretează și returnează un număr întreg sau o valoare NaN. Rezultatul (dacă nu NaN) este un număr întreg și este primul argument (șir), tratat ca un număr în radixul specificat. De exemplu, baza 10 indică conversia din zecimal, 8 din octal, 16 din hexazecimal și așa mai departe. Dacă baza este mai mare de 10, atunci literele sunt folosite pentru a reprezenta numere mai mari de 9. De exemplu, pentru numerele hexazecimale (baza 16), sunt folosite literele de la A la F.

Să ne uităm la un exemplu de lucru cu proprietăți CSS, unde, relativ vorbind, putem obține următoarea valoare:

Fie elem = document.body; let centerPoint = window.getComputedStyle(elem).transformOrigin; > „454px 2087.19px”
Putem împărți valorile pe spații:

Let centre = centerPoint.split(" "); > ["454px", "2087.19px"]
Cu toate acestea, fiecare element este încă un șir, putem scăpa de asta folosind funcția noastră:

Fie centerX = parseInt(centre, 10); > 454 let centerY = parseInt(centre, 10); >2087
După cum puteți vedea, cu al doilea argument indicăm sistemul de numere în care va fi convertit acest parametru este opțional, dar este recomandat să îl utilizați dacă nu știți ce șir va fi primit ca intrare.

parseFloat()

Sintaxă: parseFloat(șir)

Fie FP = "33,33333%"; console.log(parseFloat(FP)); > 33,33333
Rețineți că nu există un al doilea argument în sintaxa parseFloat.

Înțelegem că parseInt() și parseFloat() sunt extrem de caracteristici utile, este important de reținut că există încă unele erori implicate, așa că este necesar să verificați intervalul de valori așteptate și, în cele din urmă, să analizați rezultatul pentru a vă asigura că valorile obținute sunt corecte.
Trimite anonim

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

Transformarea 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 funcție primă 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",(style:"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).