Reguli simple de rotunjire javascript. Studiem metode și aplicăm în practică

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ă adevărat este convertit în 1 este NaN (fals); // fals, pentru că fals convertește la 0

Dacă această acțiune trebuie efectuată fără tipografiere, 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 explicit un șir într-un număr folosind următoarele metode:

1. Folosiți unar + operator pentru a fi 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 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. 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 // 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,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 de 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 combinați: 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 polifilaje.

Trunchierea numerelor zecimale

Toate metodele prezentate anterior sunt performante Rotunjirea JavaScript 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, 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.

Acum să ne uităm la metoda podelei (tradus ca gen) care funcționează opus metodei plafonului, adică el rotunjește un număr fracționat.

După cum puteți vedea, metoda podelei a rotunjit 35,97 în jos la 35, care este în jos. Chiar dacă 0,97 este mai mare de 0,5 (cm. ).

Această lecție a acoperit metodele obiectului Matematică, permițând rotunjirea numerelor zecimale fracționate.

Acum trebuie să-ți faci temele.

Sarcina dvs. este să scrieți o funcție care ia doi parametri.
1. O matrice formată din numere cu fracții.
2. Metoda de rotunjire "rotund", "tavan" sau "podea".

La ieșire, funcția ar trebui să producă aceeași matrice, dar în același timp toate elementele matricei ar trebui rotunjite folosind metoda specificată în al doilea parametru al obiectului Math.

Matrice sursă:

var numberArray =;

La început, soluția la această problemă poate părea aproape identică cu soluțiile la problemele gospodăriei din primele trei lecții ale acestui subiect. Dar nu totul este atât de simplu ...

Soluția # 1 - Atenție

Prin starea problemei funcția trebuie să ia doi parametri- matricea originală și una dintre metode: „rotund”, „tavan” sau „podea”. Pe baza acestui fapt, eu a încercat să facă acest lucru...

În această soluție, creăm o funcție cu doi parametri și, atunci când o numim, încercăm să specificăm matricea originală și NUMELE unei metode ca parametri ai funcției:
zecimal (numberArray, round) - în acest caz rotund.

Dar nu vom obține rezultatul, deoarece NU specificați o metodă NUME ca parametru funcțional.

Vă rugăm să rețineți: nu este o coincidență faptul că numele metodelor „rotund”, „tavan” și „podea” din enunțul problemei citat.

zecimal (numberArray, "rotund") - dar nici acest lucru nu va fi corect !!!

Soluția # 2 - Corectați soluția anterioară

Puteți rezolva problema specificând un parametru pentru funcție.

35 - Element rotunjit

13 - Element rotunjit

17 - Element rotunjit

79 - Element rotunjit

Aici am reușit să obținem rezultatul dorit: metoda rotundă a rotunjit toate numerele cu. Dar condiția nu este îndeplinită deoarece funcția ia doar un parametru.

Soluția # 3 - Funcție cu doi parametri

Aici problema este rezolvată corect. Pentru a face acest lucru, a fost necesar să ne amintim subiectul condițiilor din javascript și să aplicăm mai multe condiții în același timp.

34.82 - elementul original al matricei
35 - rotunjiți în sus

12.9 - elementul original al matricei
13 - rotunjiți în sus

17.01 - elementul original al matricei
18 - rotunjeste

78.51 - elementul original al matricei
79 - rotunjeste

Aceasta este decizia corectă Teme pentru acasă. Aici sunt specificați doi parametri pentru funcția în funcție de condiție.

Încercați ultima linie a acestei soluții:
zecimal (numberArray, "ceil") ca al doilea parametru al funcției, specificați numele altor metode "round" și "floor" ale obiectului Math.

Soluția # 4 - Funcție cu doi parametri + metodă prompt

Am decis să modificăm puțin soluția anterioară și am adăugat o metodă promptă care invocă o fereastră modală care conține un câmp pentru introducerea informațiilor.

Acum, datorită acestui fapt, va fi posibil să introduceți numele uneia dintre metodele rotunde, podele sau tavan în câmpul de intrare și să obțineți rezultatul corespunzător.

Așa funcționează metodele de rotunjire, podea sau tavan ale obiectului Math, care rotunjesc numerele zecimale.