Rotunjirea numerelor în JavaScript. Javascript - lateral - dactiloscop rotunjire rotunjire până la cel mai apropiat număr întreg

Acest articol va analiza mai atent numerele, operatorii matematici, modalitățile 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 finit.

Ca răspuns, această funcție returnează fals dacă argumentul este Infinity, -Infinity, NaN sau va fi aruncat la una dintre aceste valori numerice speciale. În caz contrar, această funcție va reveni adevărată.

IsFinite (73); // true isFinite (-1/0); // false isFinite (Infinity); // false isFinite (NaN); // false isFinite („Text”); // fals

În plus față de funcția globală isFinite, JavaScript are și o metodă Number.isFinite. Spre deosebire de isFinite, nu forțează argumentul la un număr.

IsFinite („73”); // Număr adevărat.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 acesta. Dacă da, 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ă spațiul sau mai multe spații sunt convertite la 0 isNaN (nul); // fals, pentru că nul este convertit la 0 isNaN (adevărat); // fals, pentru că true este convertit la 1 isNaN (false); // fals, pentru că fals convertește la 0

Dacă această acțiune trebuie efectuată fără tipografiere, atunci utilizați metoda Number.isNaN. Această metodă a fost introdusă în limbă de la ECMAScript 6.

Cum pot converti explicit un șir într-un număr?

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

1. Folosiți unar + operator să fie plasat înaintea valorii.

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

Această metodă ignoră spațiul alb principal și final și \ n (flux de linie).

+ "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 tradus 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 un număr întreg... Spre deosebire de utilizarea operator unar +, această metodă vă permite să convertiți un șir într-un număr în care nu toate caracterele sunt numerice... Începe conversia șirului, începând cu primul caracter. Și imediat ce întâlnește un caracter non-digital, 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 numerice (binar, octal, zecimal, hexazecimal). Radioul este specificat folosind 2 argumente.

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

În plus față de funcția parseInt, JavaScript are o metodă Number.parseInt. Această metodă nu diferă de funcția parseInt și a fost introdusă în JavaScript cu specificația ECMASCRIPT 2015 (6).

3. Funcția parseFloat. ParseFloat este similar cu parseInt, cu excepția faptului că convertește argumentul într-o fracțiune.

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

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

În plus față de funcția parseFloat, JavaScript are o metodă Number.parseFloat. Această metodă nu diferă de funcția parseFloat și a fost introdusă în JavaScript cu specificația ECMASCRIPT 2015 (6).

Convertiți numărul în șir

Puteți converti 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 numeric, ținând cont de care este necesar să aruncaț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. Utilizarea funcțiilor isNaN și isFinite:

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

Ca o funcție:

// funcția funcție isNumeric (valoare) (return! isNaN (parseFloat (valoare)) && isFinite (parseFloat (valoare));) // utilizați 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ă la acesta. Această opțiune nu tratează un șir gol, un șir de spații, nul, Infinit, -Infinit, adevărat sau fals ca număr.

2. Folosind tipul operatorului și funcțiile isFinite, isNaN:

// funcție care verifică dacă valoarea este un număr funcția este Număr (valoare) (returnează tipul valorii === "(! LANG: 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 tipul Number și dacă este una dintre valorile speciale Infinity, -Infinity și NaN. Dacă da, atunci această funcție revine adevărată.

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

Number.isInteger ("20"); // fals, pentru că această metodă nu traduce șirul la numărul Number.isInteger (20); // adevărat, pentru că valoarea dată 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ția pentru verificarea numărului pentru funcția de uniformitate isEven (n) (returnează n% 2 == 0;) // Funcția pentru verificarea numărului pentru funcția de impar este isOdd (n) (returnează 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; if (Number.isInteger (value)) (if (isEven (value)) (console.log ("Number" + value.toString () + "- even");))

Primele Javascript

Să luăm în considerare un exemplu în care afișăm primele de la 2 la 100 folosind Javascript.

// O funcție care verifică dacă numărul este funcția primă este Primă (valoare) (dacă (esteNaN (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 un număr fracțional la o valoare întreagă în JavaScript.

1. Folosind metodele special concepute Math.floor, Math.ceil și Math.round. Metoda Math.floor rotunjește numărul fracțional până la cel mai apropiat număr întreg, adică aruncă pur și simplu partea fracționată. Math.ceil rotunjește un număr fracțional 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ționate. Dacă partea fracționată este mai mare sau egală cu 0,5, atunci sus, altfel bucla este în jos.

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

2. Folosind metoda toFixed (precizie). Această metodă rotunjește partea fracționată a unui număr la precizia specificată. Rezultatul rotunjirii este returnat ca un ș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 completat cu zerouri.

Console.log (7.987.toFixed (5)); //"7.98700 "

3. Prin metoda toPrecision. Această metodă reprezintă un număr cu precizia specificată. În același timp, el poate rotunji nu numai fracțiunea, ci și întreaga parte a numărului. Această metodă poate reprezenta numărul rezultat, în funcție de rezultat, cu un punct fix sau în 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. Folosirea operatorilor logici NOT sau OR.

// prin consola de negare logică dublă.log (~~ 7.9); // 7 // utilizând un OR logic cu zero: console.log (7.9 ^ 0); // 7

Partea întreagă și fracționată a unui număr

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

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

Puteți obține partea fracționată a unui număr folosind operatorul procentual (%). Acest operator returnează restul care va fi obținut împărțind primul număr la al doilea. În acest caz, 1 trebuie utilizat ca numărul 2.

Console.log (7,21% 1); // 0,20999999999999996 // exact la 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,20999999999999996

Numărul este chiar divizibil

Puteți determina dacă un număr este divizibil în mod egal folosind operatorul procentual:

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

Formatarea numerelor

În JavaScript, metoda toLocaleString () vă permite să formatați ieșirea unui număr pentru a se potrivi cu setările de limbă regionale (sistemul de operare).

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

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

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

Console.log ((108.1) .toLocaleString ("ru-RU")); // „108,1”

Această metodă poate fi utilizată și pentru formatarea unui număr ca monedă:

Console.log ((2540.125) .toLocaleString ("ru-RU", (stil: "monedă", monedă: "RUB"))); // "2 540.13 ₽" console.log ((89.3) .toLocaleString ("ru-RU", (stil: "monedă", monedă: "USD"))); // "89.30 $" console.log ((2301.99) .toLocaleString ("ru-RU", (stil: "monedă", monedă: "EUR"))); // „2.301,99 EUR”

Reprezentarea unui număr ca procent:

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

Împarte numărul în cifre (useGrouping property):

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

Imprimați un număr cu un anumit număr de cifre (2) după punctul zecimal:

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

Compararea numerelor

JavaScript folosește următorii operatori pentru a compara numerele: == (egal) ,! = (Nu egal),> (mai mare decât),< (меньше), >= (mai mare sau egal),<= (меньше или равно).

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

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

Atunci când se compară numerele cu părțile fracționate, este necesar să se ia în considerare erorile care pot apărea în timpul acestor calcule.

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

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

Erorile apar deoarece toate calculele sunt efectuate de un computer sau alt dispozitiv electronic din al doilea sistem numeric. Acestea. înainte de a efectua orice acțiune, computerul trebuie mai întâi să convertească numerele reprezentate în expresie în 2 sisteme numerice. Dar nu orice număr zecimal fracționat poate fi reprezentat exact în sistemul cu 2 numere.

De exemplu, numărul 0,25 10 este convertit exact în sistemul 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 într-un sistem 2 doar 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 celor două numere și rezultatele comparației. Acestea. se pare că, de fapt, JavaScript va vedea această înregistrare după cum urmează:

0.6000000000000001==0.6

Când calculați sau afișați numere cu o parte fracționată, trebuie să indicați întotdeauna precizia cu care trebuie realizată.

De exemplu, comparați numerele de 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), * (multiplicare), / (diviziune),% (modulo), ++ (creștere cu 1), - (scădere cu 1).

6 + 3 // 9 6-3 // 3 6 * 3 // 18 6/3 // 2 6% 3 // 0, adică 6: 3 = 2 => 6-3 * 2 => rest (0) 5% 2 // 1, adică 5: 2 = 2 (.5) => 5-2 * 2 => rest (1) 7,3% 2 //1.3, adică 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 => odihnă (1,5) -9% -2,5 //-1,5, adică 9: 2,5 = 3 (.6) => 9-2,5 * 3 => odihnă (1,5) -2% 5 // - 2, adică 2: 5 = 0 (.4) => 2-5 * 0 => rest (2) x = 3; console.log (x ++); // tipărește 3, y setează 4 mai târziu console.log (x); // 4 x = 3; console.log (++ x); // setează 4 și imprimă x = 5; console.log (x--); // tipărește 5, y setează 4 mai târziu console.log (x); // 4 x = 5; console.log (- x); // seturi 4 și ieșiri În plus, JavaScript are operatori combinati: x + = y (x = x + y), x- = y (x = xy), 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

Calculele produc adesea rezultate care se încadrează în limitele dorite. Ca urmare, trebuie să efectuați Rotunjire JavaScript la o anumită valoare.

De ce rotunjim numerele?

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

0.1 * 0.2; > 0.020000000000000004

În practică, acest lucru nu va avea nicio diferență, întrucât vorbim despre o eroare de 2 quintilioane. Cu toate acestea, acest lucru poate afecta rezultatul atunci când lucrați cu numere care reprezintă valori valutare, procente sau dimensiunea fișierului. Prin urmare, trebuie să faceți sau la o anumită zecimală.

Rotunjirea numerelor zecimale

Pentru a „tăia” un număr zecimal, utilizați metodele toFixed () sau toPrecision (). Amândoi acceptă un argument, care specifică numărul de zecimale semnificative și zecimale care trebuie incluse în rezultat:

• dacă nu este specificat niciun argument pentru toFixed (), valoarea implicită este 0, adică fără zecimale; valoarea maximă a argumentului este 20;
• dacă nu este specificat niciun argument pentru toPrecision (), numărul nu este modificat.

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"

Notă

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

console.log (randNum + rotunjit); > "6.256"

Dacă doriți ca JavaScript să se rotunjească la cea mai apropiată sutime, 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 tăierea unui număr mare de zecimale. Acest lucru este util atunci când se lucrează 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ă există mai multe cifre decât numărul specificat de parametrul de precizie, toPrecision va returna rezultatul în format științific:

var num = 123.435 num.toPrecision (2); > „1.2e + 2”

Cum se evită erorile la rotunjirea fracțiilor zecimale

În unele cazuri, toFixed și toPrecision implementează JavaScript rotunjind în jos 5și nu la mai multe:

var numTest = 1.005; numTest.toFixed (2); > 1;

Exemplul de mai sus ar trebui să aibă ca rezultat 1.01, nu 1. Dacă trebuie să evitați această eroare, vă recomand să utilizați numere exponențiale:

funcție rotundă (valoare, zecimale) (returnează numărul (Matematică rotundă (valoare + "e" + zecimale) + "e -" + zecimale);)

Cerere:

rotund (1.005.2); > 1,01

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

Rotunjire Epsilon

Metoda alternativă Rotunjirea JavaScript la zecimi a fost introdus în ES6 ( cunoscut și sub numele de JavaScript 2015). « Mașină epsilon»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 utilizat într-o funcție pentru a obține o comparație corectă:

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 calcule, al doilea este 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ții matematice ES6. Dar dacă trebuie să oferiți asistență în browserele mai vechi, atunci trebuie să utilizați polifilări.

Trunchierea numerelor zecimale

Toate metodele prezentate anterior sunt performante Rotunjirea JavaScript la zecimi... Pentru a tăia un număr pozitiv la două zecimale, înmulțiți-l cu 100, tăiați-l din nou și apoi împărțiți rezultatul la 100, aveți nevoie:

function truncated (num) (return Math.trunc (num * 100) / 100;) truncated (3.1416)> 3.14

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

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

Utilizare:

var randInt = 35.874993; trunchiat (randInt, 3); > 35,874

Rotunjirea la cel mai apropiat număr

A efectua Rotunjirea JavaScript la număr întreg, folosit de Math.round ():

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

Rețineți că " valori pe jumătate„De exemplu .5 sunt rotunjite.

Rotunjiți 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 direcție pentru toate numerele, inclusiv pentru cele negative. Acest lucru 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 lift între etajele 2 și 3 ale subsolului ( care corespunde unei valori de -2,5), Math.floor te va duce la etajul -3:

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

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

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

MDN oferă, de asemenea 3 linii polyfill pentru a oferi suport 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, utilizați Math.ceil. Această metodă poate fi, de asemenea, considerată ca o creștere nesfârșită: Math.ceil te duce întotdeauna, 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ție roundTo5 (num) (return 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 numărul inițial cât și multiplicitatea funcției:

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

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

var Număr inițial = 11; var multiplu = 10; roundToMultiple (initialNumber, multiple); > 10;

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

Acordarea distanței

Uneori trebuie să obțineți valoarea lui x, care trebuie să se afle într-un anumit interval. De exemplu, avem nevoie de o valoare între 1 și 100, dar obținem o valoare de 123. Pentru a remedia acest lucru, se poate 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 clamped = Math.max (lowBound, Math.min (numInput, highBound)); console.log (prins); > 100;

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

Salut. Astăzi, în coloana de pe Javascript, vom analiza modul de setare a numărului de zecimale în numerele cu virgulă mobilă în javascript. De exemplu, trebuie să lăsați 3 zecimale în ieșire sau doar două.

Problemă: zecimale javascript

Deci, ne confruntăm cu o sarcină: există un rezultat de calcul în care există numere înainte de punctul zecimal și după punctul zecimal. Zecimal. Să presupunem că rezultatul este așa 1538.9891200153. Dar atunci când vă retrageți, ar trebui să obțineți un număr care să reflecte suma, unde înainte de punctul zecimal este numărul de bancnote și după - copeici.

Există mai multe moduri de a rezolva această problemă.

Soluția 1: zecimale javascript folosind metoda toFixed

toFixed este o metodă încorporată în javascript care se aplică oricărui număr, ia precizia de rotunjire (adică numărul de zecimale) ca parametru.

Var num = 1538.9891200153; num_str = num.toFixed (); // num_str = 1538; num_str = num.toFixed (2); //num_str=1538.98; num_str = num.toFixed (5); //num_str=1538.98912;

Parametrul de precizie din această funcție trebuie să fie nu mai puțin de 0 (nu acceptă valori negative) și nu mai mult de 20.

De asemenea, puteți face fără o variabilă, de exemplu așa:

Num_str = (1538.9891200153) .toFixed (2); //num_str=1538.98;

Soluția 2: zecimale javascript folosind metoda toPrecision

Această soluție se bazează pe aceeași metodă încorporată în javascript. O caracteristică distinctivă a acestei metode este că parametrul luat ca intrare nu înseamnă precizia (numărul de cifre după punctul zecimal), ci numărul total de cifre (atât înainte, cât și după punctul zecimal).

Var num = 1538.9891200153; num_str = num.toPrecision (5); //num_str=1538.9; num_str = num.toPrecision (7); //num_str=1538.989;

Soluție punct zecimal: numărul javascript de zecimale

Dacă zecimalele trebuie să fie complet eliminate, adică trebuie să rotunjiți numărul fracțional la un număr întreg, atunci puteți utiliza funcțiile clasei Matematică: rotund, tavan și podea.
Rotund - rotunjește în sus sau în jos (în funcție de număr). Dacă valoarea după punctul zecimal este mai mare de jumătate, atunci se va rotunji în sus, dacă este mai mică - în jos. Adică, dacă 0,51 - va deveni 1, dacă 0,49 - 0.

Ceil - din engleză. tavanul se rotunjește întotdeauna în sus.

Etaj - din engleză. podeaua se rotunjește întotdeauna în jos.

Var num = 1538.9891200153; num_str = Math.round (num); // num_str = 1539; num_str = Math.floor (num); // num_str = 1538; num_str = Math.ceil (num); // num_str = 1539;

Asta e tot. Sper că această postare te-a ajutat să rezolvi problema. Dacă ceva nu a funcționat - puneți întrebări folosind butonul verde „Puneți o întrebare unui specialist”, sau în comentarii.

Bună ziua iubitorilor de JavaScript. Ați observat deja că acest limbaj este foarte neobișnuit și în fiecare secțiune se remarcă prin particularitățile sale și soluțiile tehnice neobișnuite. Prin urmare, postarea de astăzi este dedicată subiectului: „rotunjirea JavaScript”.

După ce citiți articolul curent, veți afla de ce este necesar să rotunjiți numerele, ce metode și proprietăți în js îndeplinesc această funcție și, de asemenea, modul în care se evidențiază împărțirea la 0. Fără a schimba principiile mele, voi atașa exemple la punctele cheie ale materialul și descrie fiecare acțiune în detaliu. Acum să începem să învățăm!

Note importante despre numere

Mai întâi, amintiți-vă că în js toate tipurile de numere (fracții și numere întregi) sunt de acest tip Număr... În plus, toate sunt pe 64 de biți, deoarece sunt stocate în formatul „dublă precizie”, cunoscut și ca standardul IEEE-754.

Variabilele numerice sunt create în mod obișnuit:

var amorțit = 35; // numar natural

var drob = 0,93; // reprezentare zecimală

var numb16 = 0xFF; // sistem de număr hexazecimal

Suportă și alte reprezentări numerice. Deci, puteți crea în continuare numere în virgulă mobilă (acestea sunt numite uneori „numere în format științific”).

Există suport pentru o metodă foarte interesantă toLocaleString (), care formatează toți parametrii numerici în conformitate cu specificațiile specificate în ECMA 402. Datorită acestui fapt, numerele mari, numerele de telefon, monedele și chiar procentele sunt afișate frumos în caseta de dialog.

var num = 714000.80;

alert (num.toLocaleString ());

Pentru a lucra cu elemente de tip Number, un întreg obiect global a fost prevăzut cu o grămadă de tot felul de funcții matematice, al căror nume este Matematica.

În plus, există și alte metode care rotunjesc valorile numerice la numere întregi, zecimi, sutimi etc. Să le luăm în considerare pe toate în detaliu.

Mare și puternică matematică

Obiectul matematic global include o mare varietate de funcții matematice și trigonometrice. Acesta este un obiect foarte util și adesea îi ajută pe dezvoltatori atunci când lucrează cu date digitale.

Pe alte platforme, există analogii pentru Math. De exemplu, în limbaje populare precum Java și C #, Math este o clasă care acceptă toate aceleași funcționalități standard. Așa cum puteți vedea, acest instrument este cu adevărat minunat și puternic.

Acum vreau să trec prin metodele de rotunjire specifice și să vorbesc despre ele în detaliu.

Math.floor ()

Voi începe cu Matematica.podea... Fii atent la numele metodei. În mod logic, devine clar că, din moment ce vorbim despre rotunjire, iar traducerea literală a cuvântului „etaj” înseamnă „etaj”, atunci acest instrument va rotunji valorile procesate în jos.

De asemenea, este posibil ca numărul procesat care utilizează această funcție să rămână același. Acest lucru se datorează faptului că rotunjirea se realizează conform unei inegalități nestricte (<=). Таким образом, при отработке этой строчки кода:

alert (Math.floor (4.5));

răspunsul va fi numărul 4.

Math.ceil ()

Din nou, uitați-vă la nume (în acest fel, materialul este absorbit mai repede). Dacă cineva nu știe, tavan înseamnă tavan. Aceasta înseamnă că datele numerice vor fi rotunjite în sus, utilizând o inegalitate slabă (> =).

alertă (Math.ceil (4.5));

După cum probabil ați ghicit, răspunsul va fi numărul 5.

Math.round ()

Această metodă rotunjește numărul fracțional la cel mai apropiat număr întreg. Deci, dacă partea fracțională este cuprinsă între 0 și 0,5, neincluzând, are loc rotunjirea în jos. Și dacă partea fracționară se află în intervalul de la 0,5 inclusiv la următorul număr întreg, atunci este rotunjită la numărul întreg mai mare.

alert (Math.round (4.5));

Sper că toată lumea a gândit sau a spus răspunsul corect - 5.

Încă câteva metode

JavaScript are, de asemenea, alte 2 metode care se ocupă de rotunjirea reprezentărilor numerice. Cu toate acestea, ele sunt oarecum diferite.

Va fi vorba despre instrumente precum toFixed ()și toPrecision ()... Ele sunt responsabile nu numai pentru rotunjire, ci și pentru acuratețea acesteia la anumite semne. Să sapăm mai adânc.

toFixed ()

Folosind acest mecanism, puteți specifica la câte zecimale ar trebui rotunjită valoarea. Metoda returnează rezultatul ca un șir. Mai jos am atașat o variantă cu trei variante diferite. Analizează răspunsurile pe care le-ai primit.

var num = 5656.9393;

document.writeln (num.toFixed ()); // 5657

document.writeln (num.toFixed (2)); // 5656,94

document.writeln (num.toFixed (7)); // 5656.9393000

După cum puteți vedea, dacă nu specificați un argument, atunci toFixed ()) va rotunji valoarea fracțională la întreg numere. A treia linie este rotunjită până la 2 caractere, iar în al patrulea - din cauza parametrului „7”, s-au adăugat încă trei 0.

toPrecision ()

Această metodă funcționează într-un mod ușor diferit. În locul argumentului, puteți lăsa fie un spațiu gol, fie setați un parametru. Cu toate acestea, acesta din urmă va rotunji numerele la numărul specificat de cifre, ignorând virgula. Iată rezultatele programului rescris din exemplul anterior:

var num = 5656.9393;

document.writeln (num.toPrecision ()); // 5656.9393

document.writeln (num.toPrecision (2)); // 5.7e + 3

document.writeln (num.toPrecision (7)); // 5656.939

Împărțirea cu 0 caracteristică în js

După cum știți din lecțiile de matematică, nu puteți împărți la zero. Această regulă a fost luată ca bază de majoritatea creatorilor de limbaje de programare. Prin urmare, atunci când sunt împărțite la zero, toate programele generează o eroare.

Cu toate acestea, JavaScript s-a distins și aici. Deci, în timpul executării unei astfel de operații, nu apar mesaje de eroare ... deoarece o astfel de operație revine "Infinit"!

De ce este așa? După cum știți din aceleași științe matematice, cu cât divizorul este mai mic, cu atât este mai mare numărul. De aceea, creatorii acestui limbaj orientat spre prototip au decis să abandoneze șabloanele și să-și urmeze propriul drum.

Pentru cei care întâmpină prima dată valoarea Infinitului, mai jos am explicat caracteristicile sale.

Infinit - înseamnă infinit și corespunde pe deplin semnului matematic ∞.

Ar putea fi negativ. Toate regulile standard pentru lucrul cu operatori aritmetici sunt, de asemenea, păstrate.

alertă (12/0); // Infinit

alertă (12.34 / 0); // Infinit

alertă (-3 / 0); // -Infinitate

Despre asta, poate, și termină. Dacă ți-a plăcut publicația, atunci asigură-te că te abonezi la blogul meu. Nu fi lacom cu linkuri către articole interesante și împărtășește-le prietenilor tăi. Pa! Pa!