Acest articol va analiza mai îndeaproape 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, 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ă 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ă false este convertit la 0
Dacă această acțiune trebuie efectuată fără turnarea de tip, 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 explicit un șir într-un număr folosind următoarele metode:
1. Folosiți unar + operatorsă 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 folosire 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 de îndată ce întâlnește un caracter care nu este 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). Radixul 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ție.
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 notație 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ă o valoare variabilă 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 \u003d "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 de operator și isFinite, funcțiile isNaN:
// funcție care verifică dacă valoarea este un număr funcția este Număr (valoare) (returnează tipul valorii \u003d\u003d\u003d "(! 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 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ă determină dacă valoarea specificată este un număr întreg.
Number.isInteger ("20"); // fals, pentru că această metodă nu efectuează un flux de linie către 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 \u003d\u003d 0;) // Funcția pentru verificarea numărului pentru funcția de impar este isOdd (n) (returnează Math.abs (n% 2) \u003d\u003d 1;)
Dar înainte de a face o astfel de verificare, este recomandabil să vă asigurați că valoarea specificată este un număr:
Valoare \u003d 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 metode 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 în 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)); // 8
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ă. Mai mult, el poate rotunji nu numai fracționarea, 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 intermediul consolei de negare logică dublă.log (~~ 7.9); // 7 // utilizând SAU 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 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 \u003d 7,21; var fractionNumber \u003d 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 \u003d 9; // dacă restul împărțirii numărului cu 3 este 0, atunci da, altfel nu dacă (numărul% 3 \u003d\u003d 0) (console.log ("Număr" + număr + "este divizibil cu 3");) altceva (consola. 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 în funcție de setările de limbă regionale (sistemul de operare).
De exemplu, să formatăm numărul în conformitate cu standardele regionale care sunt instalate în mod implicit pe sistem:
Număr Var \u003d 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 €”
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: \u003d\u003d (egal) ,! \u003d (Nu egal),\u003e (mai mare decât),< (меньше), >\u003d (mai mare sau egal),<= (меньше или равно).
De exemplu, să comparăm două numere:
Console.log (2\u003e 3); // false console.log (5\u003e \u003d 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) \u003d\u003d 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 \u003d 0,25 | 0 0,25 × 2 \u003d 0,5 | 0 0,5 × 2 \u003d 1 | 1 0,125 10 \u003d 0,001 2
De exemplu, numărul 0,2 10 poate fi convertit în sistem 2 numai cu o anumită precizie:
0,2 × 2 \u003d 0,4 | 0 0,4 × 2 \u003d 0,8 | 0 0,8 × 2 \u003d 1,6 | 1 0,6 × 2 \u003d 1,2 | 1 0,2 × 2 \u003d 0,4 | 0 0,4 × 2 \u003d 0,8 | 0 0,8 × 2 \u003d 1,6 | 1 0,6 × 2 \u003d 1,2 | 1 0,2 × 2 \u003d 0,4 | 0 0,4 × 2 \u003d 0,8 | 0 0,8 × 2 \u003d 1,6 | 1 0,6 × 2 \u003d 1,2 | 1 ... 0,2 10 \u003d 0,001100110011 ... 2
Ca urmare, aceste erori vor afecta calculul sumei a două numere și rezultatele comparației. Acestea. se pare că, de fapt, JavaScript va vedea această intrare 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) \u003d\u003d (0.6) .toFixed (2)); // true // metoda toPrecision () console.log ((0,2 + 0,4) .toPrecision (2) \u003d\u003d (0,6) .toPrecision (2)); // Adevărat
Operații matematice de bază
Următorii operatori matematici există în JavaScript: + (adunare), - (scădere), * (înmulțire), / (diviziune),% (modulo), ++ (crește valoarea cu 1), - (scade valoarea cu 1).
6 + 3 // 9 6-3 // 3 6 * 3 // 18 6/3 // 2 6% 3 // 0, adică 6: 3 \u003d 2 \u003d\u003e 6-3 * 2 \u003d\u003e rest (0) 5% 2 // 1, adică 5: 2 \u003d 2 (.5) \u003d\u003e 5-2 * 2 \u003d\u003e odihnă (1) 7,3% 2 //1,3, adică 7.3: 2 \u003d 3 (.65) \u003d\u003e 7.3-2 * 3 \u003d\u003e rest (1.3) // semnul rezultatului operației% este egal cu semnul primei valori -9% 2.5 //-1.5 , adică 9: 2,5 \u003d 3 (.6) \u003d\u003e 9-2,5 * 3 \u003d\u003e odihnă (1,5) -9% -2,5 //-1,5, adică 9: 2,5 \u003d 3 (.6) \u003d\u003e 9-2,5 * 3 \u003d\u003e odihnă (1,5) -2% 5 // - 2, adică 2: 5 \u003d 0 (.4) \u003d\u003e 2-5 * 0 \u003d\u003e rest (2) x \u003d 3; console.log (x ++); // tipărește 3, y setează 4 mai târziu console.log (x); // 4 x \u003d 3; console.log (++ x); // setează 4 și imprimă x \u003d 5; console.log (x--); // tipărește 5, y setează 4 mai târziu console.log (x); // 4 x \u003d 5; console.log (- x); // seturi 4 și ieșiri În plus, JavaScript are operatori combinați: x + \u003d y (x \u003d x + y), x- \u003d y (x \u003d xy), x * \u003d y (x \u003d x * y), x / \u003d y (x \u003d x / y), x% \u003d y (x \u003d x% y). x \u003d 3; y \u003d 6; x + \u003d y; console.log (x); // 9 x \u003d 3; y \u003d 6; x- \u003d y; console.log (x); // - 3 x \u003d 3; y \u003d 6; x * \u003d y; console.log (x); // 18 x \u003d 3; y \u003d 6; x / \u003d y; console.log (x); //0,5 x \u003d 3; y \u003d 6; x% \u003d y; console.log (x); // 3
De multe ori, calculele în JavaScript nu dau exact rezultatele dorite. Desigur, putem face orice cu numerele - rotunjirea în sus sau în jos, setarea intervalelor, tăierea numerelor inutile la un anumit număr de zecimale, totul depinde de ceea ce doriți să faceți cu acest număr în viitor.De ce este necesară rotunjirea?
Unul dintre aspectele curioase ale JavaScript este că nu stochează de fapt numere întregi, lucrăm imediat cu numere în virgulă mobilă. Acest lucru, combinat cu faptul că multe valori fracționare nu pot fi exprimate în numere finite de zecimale, în JavaScript putem obține rezultate de acest fel:0.1 * 0.2;
> 0.020000000000000004
0.3 - 0.1
> 0.19999999999999998
În scopuri practice, această inexactitate nu contează deloc, în cazul nostru vorbim despre o eroare în părți de cinci miliarde, cu toate acestea, acest lucru poate dezamăgi pe cineva. Putem obține un rezultat puțin ciudat atunci când lucrăm cu numere care reprezintă valori ale monedelor, procentelor sau dimensiunilor fișierului. Pentru a corecta aceste inexactități, trebuie doar să putem rotunji rezultatele, în timp ce este suficient să stabilim precizia zecimală.
Rotunjirea numerelor are o aplicație practică, putem manipula un număr într-un anumit interval, de exemplu, dorim să rotunjim valoarea la cel mai apropiat număr întreg și să nu funcționăm doar cu partea zecimală.
Rotunjirea numerelor zecimale
Pentru a elimina numărul zecimal, utilizați toFixed sau metoda toPrecision. Amândoi iau un singur argument, care determină, respectiv, câte cifre semnificative (adică numărul total de cifre utilizate în număr) sau zecimale (numărul după punctul zecimal) rezultatul ar trebui să includă:- Dacă argumentul nu este definit pentru toFixed (), atunci implicit va fi zero, ceea ce înseamnă 0 zecimale, argumentul are o valoare maximă de 20.
- Dacă nu se dă niciun argument pentru precizie, numărul este lăsat neatins
Atât toFixed (), cât și toPrecision () returnează o reprezentare șir a rezultatului, nu un număr. Aceasta înseamnă că atunci când valoarea rotunjită este însumată cu randNum, va fi o concatenare de șiruri, nu o sumă de numere:
Fie randNum \u003d 6,25; let rounded \u003d randNum.toFixed (); // "6" console.log (randNum + rotunjit); \u003e "6.256"
Dacă doriți ca rezultatul să aibă un tip numeric de date, atunci va trebui să utilizați parseFloat:
Fie randNum \u003d 6,25; let rounded \u003d parseFloat (randNum.toFixed (1)); console.log (rotunjit); \u003e 6.3
Rețineți că 5 valori sunt rotunjite, cu excepția cazurilor rare.
Metodele toFixed () și toPrecision () sunt utile, deoarece nu numai că pot elimina partea fracțională, ci pot completa și zecimale, ceea ce este convenabil atunci când se lucrează cu moneda:
Let wholeNum \u003d 1 let dollarsCents \u003d wholeNum.toFixed (2); console.log (dollarsCents); \u003e "1,00"
Vă rugăm să rețineți că toPrecision va da rezultatul în notație exponențială dacă numărul de numere întregi este mai mare decât precizia în sine:
Let num \u003d 123.435 num.toPrecision (2); \u003e „1.2e + 2”
Cum să evitați erorile de rotunjire cu cifre zecimale
În unele cazuri, toFixed și toPrecision rundă 5 în jos și în sus:Să numTest \u003d 1.005; numTest.toFixed (2); \u003e "1,00"
Rezultatul calculului de mai sus ar fi trebuit să fie 1.01, nu 1. Dacă doriți să evitați această eroare, putem folosi soluția sugerată de Jack L Moore, care folosește numere exponențiale pentru a calcula:
Funcția rotundă (valoare, zecimale) (returnează numărul (Matematică rotundă (valoare + "e" + zecimale) + "e -" + zecimale);)
Acum:
Rotund (1.005.2); \u003e 1,01
Dacă doriți o soluție mai robustă decât cea prezentată mai sus, puteți merge la MDN.
Masina de rotunjit epsilon
O metodă alternativă pentru rotunjirea numerelor zecimale a fost introdusă în ES6. Rotunjirea epsilon a mașinii 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 \u003d\u003d\u003d 0,3\u003e fals
Folosim Math.EPSILON în funcția noastră pentru a obține comparația 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: primul este calculul curent, al doilea este rezultatul așteptat. Returnează o comparație a celor două:
EpsEqu (0,1 + 0,2, 0,3)\u003e adevărat
Toate browserele moderne acceptă deja funcții matematice ES6, dar dacă doriți asistență în browsere precum IE 11, utilizați polifilluri.
Decupare fracționată
Toate metodele prezentate mai sus știu cum se rotunjesc la cifre zecimale. Pentru a tăia pur și simplu numărul la două zecimale, trebuie mai întâi să îl înmulțiți cu 100, apoi să împărțiți rezultatul la 100:Funcție trunchiată (num) (return Math.trunc (num * 100) / 100;) trunchiată (3.1416)\u003e 3.14
Dacă doriți să găzduiți orice număr de zecimale, puteți utiliza negarea dublă în sens bit:
Funcție trunchiată (num, decimalPlaces) (let numPowerConverter \u003d Math.pow (10, decimalPlaces); return ~~ (num * numPowerConverter) / numPowerConverter;)
Acum:
Să randInt \u003d 35.874993; trunchiat (randInt, 3); \u003e 35,874
Rotunjiți la cel mai apropiat număr
Pentru a rotunji o zecimală în sus sau în jos la cel mai apropiat număr, oricare este cel mai apropiat, utilizați Math.round ():Math.round (4.3)\u003e 4 Math.round (4.5)\u003e 5
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
Dacă doriți să rotunjiți întotdeauna în jos, utilizați Math.floor:Math.floor (42.23); \u003e 42 Math.floor (36,93); \u003e 36
Rețineți că rotunjirea în jos funcționează pentru toate numerele, inclusiv pentru cele negative. Imaginați-vă un zgârie-nori cu un număr infinit de etaje, inclusiv cele de la nivelul inferior (reprezentând numere negative). Dacă vă aflați în lift la nivelul inferior între 2 și 3 (ceea ce reprezintă o valoare de -2,5), Math.floor vă va duce la -3:
Math.floor (-2,5); \u003e -3
Dar dacă doriți să evitați această situație, utilizați Math.trunc, care este acceptat în toate browserele moderne (cu excepția IE / Edge):
Math.trunc (-41,43); \u003e -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
Pe de altă parte, dacă trebuie întotdeauna să rotunjiți, utilizați Math.ceil. Din nou, amintindu-ne de creșterea infinită: Math.ceil va crește întotdeauna, indiferent dacă numărul este negativ sau nu:Math.ceil (42,23); \u003e 43 Math.ceil (36,93); \u003e 37 Math.ceil (-36,93); \u003e -36
Rotunjire în sus / în jos, după cum este necesar
Dacă vrem să rotunjim la cel mai apropiat multiplu de 5, cel mai simplu mod este de a crea o funcție care împarte un număr la 5, îl rotunjește și apoi îl înmulțește cu aceeași cantitate:Funcția roundTo5 (num) (return Math.round (num / 5) * 5;)
Acum:
RoundTo5 (11); \u003e 10
Dacă doriți să rotunjiți la multipli ai valorii dvs., vom folosi o funcție mai generală, trecând o valoare inițială și un multiplu:
Funcție roundToMultiple (num, multiple) (returnează Math.round (num / multiple) * multiple;)
Acum:
Fie Număr inițial \u003d 11; lasa multiplu \u003d 10; roundToMultiple (initialNumber, multiple); \u003e 10;
Fixarea unui număr într-un interval
Există multe cazuri în care dorim să obținem o valoare x care se află într-un interval. De exemplu, s-ar putea să dorim o valoare între 1 și 100, dar am obținut o valoare de 123. Pentru a remedia acest lucru, putem folosi min (returnează cel mai mic dintr-un set de numere) și max (returnează cel mai mare dintre orice set de numere ). În exemplul nostru, intervalul este de la 1 la 100:Fie lowBound \u003d 1; lasa highBound \u003d 100; let numInput \u003d 123; let clamped \u003d Math.max (lowBound, Math.min (numInput, highBound)); console.log (prins); \u003e 100;
Din nou, putem refolosi operațiunea și o putem înfășura într-o funcție, să folosim soluția sugerată de Daniel X. Moore:
Number.prototype.clamp \u003d function (min, max) (return Math.min (Math.max (this, min), max););
Acum:
NumInput.clamp (lowBound, highBound); \u003e 100;
Rotunjire gaussiană
Rotunjirea Gaussiană, cunoscută și sub numele de rotunjire a malului, este locul unde rotunjirea are loc la cel mai apropiat nivel. Această metodă de rotunjire funcționează fără erori statistice. Cea mai bună soluție a fost sugerată de Tim Down:Funcția gaussRound (num, decimalPlaces) (let d \u003d decimalPlaces || 0, m \u003d Math.pow (10, d), n \u003d + (d? Num * m: num) .toFixed (8), i \u003d Math.floor (n), f \u003d n - i, e \u003d 1e-8, r \u003d (f\u003e 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)\u003e 2 gaussRound (3,5)\u003e 4 gaussRound (2,57,1)\u003e 2,6
Punct zecimal în CSS:
Deoarece JavaScript este adesea folosit pentru a genera transformări poziționale pe elemente HTML, s-ar putea să vă întrebați ce se întâmplă dacă generăm valori zecimale pentru elementele noastre:
#box (lățime: 63.667731993px;)
Vestea bună este că browserele moderne vor lua în considerare valorile zecimale în modelul casetei, inclusiv în unități procentuale sau de pixeli.
Triere
De foarte multe ori trebuie să sortăm unele elemente, de exemplu, avem o serie de înregistrări de joc și acestea trebuie să fie organizate în ordinea descrescătoare a rangului jucătorilor. Din păcate, metoda standard sort () are unele limitări surprinzătoare: funcționează bine cu cuvintele în engleză utilizate în mod obișnuit, dar se rupe imediat când se confruntă cu numere, caractere unice sau cuvinte cu majuscule.Sortează alfabetic
S-ar părea că sortarea alfabetică a unui tablou ar trebui să fie cea mai simplă sarcină:Let fruit \u003d ["squash butternut", "cais", "melon"]; fruit.sort (); \u003e "caise", "dovlecei", "melon"]
Cu toate acestea, întâmpinăm o problemă imediat ce unul dintre elemente este cu majuscule:
Let fruit \u003d ["squash butternut", "cais", "Cantalope"]; fruit.sort (); \u003e "Cantalup", "caise", "dovlecei de butternut"]
Acest lucru se datorează faptului că, în mod implicit, sortatorul compară primul caracter reprezentat în Unicode. Unicode este un cod unic pentru orice caracter, 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 sistemul hexazecimal 0x61), în timp ce caracterul „C” are codul U + 0043 (0x43), care apare mai devreme în Tabel Unicode decât caracterul „A”.
Pentru a sorta o matrice, care poate conține majuscule din primele litere, trebuie fie să convertim temporar toate elementele în minuscule, fie să definim propria noastră ordine de sortare folosind metoda localeCompare () cu câteva argumente. De regulă, pentru un astfel de caz, este mai bine să creați imediat o funcție pentru utilizare repetată:
Function alphaSort (arr) (arr.sort (function (a, b) (return a.localeCompare (b, "en", ("sensitive": "base"));));) let fruit \u003d ["squash butternut "," caise "," Cantalup "]; alphaSort (fruct)\u003e
Dacă doriți să obțineți o matrice sortată în ordine alfabetică inversă, schimbați doar pozițiile lui a și b în funcția:
Function alphaSort (arr) (arr.sort (function (a, b) (return b.localeCompare (a, "en", ("sensitive": "base"));));) let fruit \u003d ["squash butternut "," caise "," Cantalup "]; alphaSort (fructe)\u003e ["Cantalup", "dovlecei", "caise"]
Aici este demn de remarcat faptul că localeCompare este utilizat cu argumente, de asemenea, trebuie să vă amintiți că este acceptat de IE11 +, pentru versiunile mai vechi de IE, îl putem folosi fără argumente și cu litere mici:
Function caseSort (arr) (arr.sort (function (a, b) (return a.toLowerCase (). LocaleCompare (b.toLowerCase ());));) let fruit \u003d ["squash butternut", "cais", "Pepene galben"]; caseSort (fructe)\u003e ["caise", "squash butternut", "Cantaloupe"]
Sortare numerică
Toate acestea nu se aplică exemplului despre care am vorbit mai sus despre gama de înregistrări de joc. Cu unele matrice numerice, sortarea funcționează foarte bine, dar la un moment dat rezultatul poate fi imprevizibil:Let highScores \u003d; highScores.sort (); \u003e
Faptul este că metoda sort () efectuează o comparație lexicografică: ceea ce înseamnă că numerele vor fi convertite într-un șir și comparațiile vor fi efectuate din nou prin potrivirea primului caracter al acestui șir în ordinea caracterelor tabelului Unicode. Prin urmare, trebuie din nou să ne definim ordinea de sortare:
Let highScores \u003d; highScores.sort (funcția (a, b) (returnează a - b;)); \u003e
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
În cele din urmă, dacă avem o structură de date asemănătoare JSON reprezentată ca o serie de înregistrări de joc:Let scores \u003d [("nume": "Daniel", "scor": 21768), ("nume": "Michael", "scor": 33579), ("nume": "Alison", "scor": 38395 )];
În ES6 +, puteți utiliza funcțiile săgeată:
Scores.sort ((a, b) \u003d\u003e 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 nu este un lucru evident, sper că aceste exemple ușurează cumva viața.
Lucrul cu funcții de alimentare
Exponențierea este o operație definită inițial ca rezultat al înmulțirii multiple a unui număr natural de la sine, rădăcina pătrată a lui este numărul care dă a la pătrat. Am putea folosi aceste funcții tot timpul în viața de zi cu zi în lecțiile de matematică, inclusiv atunci când calculăm suprafețe, volume sau chiar în modelarea fizică.În JavaScript, funcția exponențială este reprezentată ca Math.pow (), în noul standard ES7, este introdus un nou operator de exponențiere - „* *”.
Exponențierea
Pentru a ridica un număr la a n-a putere, utilizați funcția Math.pow (), unde primul argument este numărul care trebuie ridicat la putere, al doilea argument este exponentul:Math.pow (3,2)\u003e 9
Această formă de notație înseamnă 3 pătrat sau 3 × 3, ceea ce duce la rezultatul 9. Puteți da un alt exemplu, desigur:
Math.pow (5.3); \u003e 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ă notație poate fi mai descriptivă:
3 ** 2
> 9
În acest moment, suportul pentru acest operator este destul de limitat, deci nu este recomandat să-l utilizați.
Funcția de alimentare poate fi utilă într-o varietate de situații. Un exemplu simplu, calculând numărul de secunde într-o oră: Math.pow (60,2).
Pătrat și rădăcină cub
Math.sqrt () și Math.cbrt () sunt opusul funcției Math.pow (). Amintiți-vă că rădăcina pătrată a lui este numărul care dă a când este pătrat.Math.sqrt (9)\u003e 3
În același timp, rădăcina cubică a numărului a este numărul care dă a când este ridicat la un cub.
Math.cbrt (125)\u003e 5
Math.cbrt () a fost introdus în specificația JavaScript foarte recent și, prin urmare, este acceptat numai în browserele moderne: Chrome 38+, Firefox și Opera 25+ și Safari 7.1+. Veți observa că Internet Explorer nu se află pe această listă, totuși veți găsi un polyfill pe MDN.
Exemple de
Desigur, putem folosi și valori care nu sunt întregi într-una dintre aceste funcții:Math.pow (1,25, 2); \u003e 1.5625 Math.cbrt (56.57)\u003e 3.8387991760286138
Rețineți că acest lucru funcționează bine și pentru valorile argumentelor negative:
Math.pow (-5,2)\u003e 25 Math.pow (10, -2)\u003e 0,01
Cu toate acestea, pentru o rădăcină pătrată, acest lucru nu va funcționa:
Math.sqrt (-9)\u003e NaN
Știm din analiza matematică că un număr imaginar este înțeles ca rădăcinile pătrate ale numerelor negative. Și acest lucru ne poate conduce la o altă tehnică de lucru cu numere complexe, dar asta este o altă poveste.
Puteți utiliza valori fracționare î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); // \u003d Math.sqrt (5) \u003d 5 ** (1/2)\u003e 2.23606797749979
Cu toate acestea, din cauza capriciilor punctului plutitor, nu puteți ghici cu exactitate rezultatul corect:
Math.pow (2.23606797749979.2)\u003e 5.000000000000001
În astfel de situații, va trebui să recurgeți la tăierea semnelor de la număr sau rotunjirea la o anumită valoare.
Unii, dintr-un motiv necunoscut din JavaScript, confundă funcția Math.pow () cu Math.exp (), care este o funcție exponențială pentru numere în general. Notă: în engleză, „exponent” se traduce prin „exponent”, deci este mai probabil să se refere la vorbitorii de engleză, deși există nume alternative pentru exponent, cum ar fi index, putere.
Constantele matematice
Lucrul cu matematica în JavaScript este ușurat de o serie de constante încorporate. Aceste constante sunt proprietăți ale obiectului Math. Rețineți că constantele sunt scrise cu majuscule, nu cu notația CamelCase.Math.abs, parseInt, parseFloat
Lucrul cu cifre în JavaScript poate fi mult mai complicat decât pare. Valorile obținute nu se încadrează întotdeauna în intervalele așteptate, uneori rezultatul poate să nu fie ceea ce ne așteptam.Math.abs ()
Metoda Math.abs () returnează valoarea absolută a unui număr, ceea ce ne amintește de funcția matematică analogă pentru modulul unui număr.Să fie newVal \u003d -57,64; Math.abs (newVal); \u003e 57,64
Math.abs (0) returnează întotdeauna zero, dar dacă punem un semn minus în fața funcției -Math.abs (NUM), vom fi întotdeauna negativi.
Math.abs (0); \u003e -0
parseInt ()
Știm că JavaScript înțelege că „15” este un șir, nu un număr și, de exemplu, atunci când se analizează proprietățile CSS folosind JavaScript sau se obține o valoare dintr-o matrice nepregătită, rezultatele noastre pot fi imprevizibile. Am putea obține un șir reprezentat ca "17px" ca intrare, iar acest lucru nu este neobișnuit pentru noi. Întrebarea este cum să convertiți acest șir într-o valoare reală și să îl utilizați în alte calcule.Sintaxă: parseInt (șir, radix);
Funcția parseInt convertește primul argument trecut într-un ș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 sistemul numeric specificat (radix). De exemplu, baza 10 indică o conversie din zecimal, 8 în octal, 16 în hex și așa mai departe. Dacă baza este mai mare de 10, atunci literele sunt folosite pentru a indica numere mai mari de 9. De exemplu, numerele hexazecimale (baza 16) folosesc literele de la A la F.
Să luăm în considerare un exemplu de lucru cu proprietăți CSS, unde, relativ vorbind, putem obține o astfel de valoare:
Să elem \u003d document.body; let centerPoint \u003d window.getComputedStyle (elem) .transformOrigin; \u003e "454px 2087.19px"
Putem împărți valorile pe spații:
Let centres \u003d centerPoint.split (""); \u003e ["454px", "2087.19px"]
Cu toate acestea, fiecare element este încă un șir, putem scăpa de acest lucru aplicând funcția noastră:
Fie centerX \u003d parseInt (centre, 10); \u003e 454 let centerY \u003d parseInt (centres, 10); \u003e 2087
După cum puteți vedea, ca al doilea argument, indicăm sistemul numeric la care va fi convertit numărul, acest parametru este opțional, dar este recomandat să îl utilizați în cazul în care nu știți ce șir va ajunge la intrare.
parseFloat ()
Din exemplul de mai sus, este posibil să fi observat că parseInt aruncă partea fracționată. În cazul nostru, parseFloat este capabil să funcționeze cu numere în virgulă mobilă. Din nou, acest lucru poate fi util atunci când analizați CSS și alte sarcini, mai ales atunci când aveți de-a face cu procente în virgulă mobilă.Sintaxă: parseFloat (șir)
Să FP \u003d "33,33333%"; console.log (parseFloat (FP)); \u003e 33,33333
Rețineți că nu există un al doilea argument în sintaxa parseFloat.
Înțelegem că parseInt () și parseFloat () sunt funcții extrem de utile, este important să rețineți că acest lucru nu este lipsit de erori, de aceea este necesar să verificați gama valorilor așteptate și, în cele din urmă, să analizați rezultatul pentru a vă asigura că valorile obținute sunt corecte.
Trimite anonim
Calculele produc adesea rezultate care se încadrează în limitele dorite. Ca urmare, trebuie să implementaț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 \u003d 6,25; randNum.toFixed (); \u003e "6" Math.PI.toPrecision (1); \u003e "3" var randNum \u003d 87.335; randNum.toFixed (2); \u003e "87,33" var randNum \u003d 87,337; randNum.toPrecision (3); \u003e "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 o concatenare a șirului, mai degrabă decât un singur număr:
console.log (randNum + rotunjit); \u003e "6.256"
Dacă doriți ca JavaScript să se rotunjească la cea mai apropiată sutime, utilizați parseFloat ():
var randNum \u003d 6,25; var rounded \u003d parseFloat (randNum.toFixed (1)); console.log (rotunjit); \u003e 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 lucrați cu numere reprezentând unități monetare:
var wholeNum \u003d 1 var dollarsCents \u003d wholeNum.toFixed (2); console.log (dollarsCents); \u003e "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 \u003d 123.435 num.toPrecision (2); \u003e „1.2e + 2”
Cum să evitați erorile la rotunjirea zecimalelor
În unele cazuri toFixed și toPrecision implementează JavaScript rotunjind 5 în jos, și nu la mai multe:
var numTest \u003d 1.005; numTest.toFixed (2); \u003e 1;
Exemplul de mai sus ar trebui să aibă ca rezultat 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ărul (Matematică rotundă (valoare + "e" + zecimale) + "e -" + zecimale);)
Cerere:
rotund (1.005.2); \u003e 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 \u003d\u003d\u003d 0,3\u003e fals
Math.EPSILON poate fi folosit î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)\u003e adevărat
Toate browserele moderne acceptă funcții matematice ES6. Dar dacă trebuie să oferiți asistență în browsere 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)\u003e 3.14
Dacă aveți nevoie de ceva mai flexibil, puteți utiliza operatorul bitwise:
funcție trunchiată (num, decimalPlaces) (var numPowerConverter \u003d Math.pow (10, decimalPlaces); return ~~ (num * numPowerConverter) / numPowerConverter;)
Folosind:
var randInt \u003d 35.874993; trunchiat (randInt, 3); \u003e 35,874
Rotunjiți la cel mai apropiat număr
A efectua Rotunjirea JavaScript la număr întreg, folosit de Math.round ():
Math.round (4.3)\u003e 4 Math.round (4.5)\u003e 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); \u003e 42 Math.floor (36,93); \u003e 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); \u003e -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); \u003e -41
MDN oferă, de asemenea 3-line 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 ridicare nesfârșită: Math.ceil te conduce întotdeauna, indiferent dacă numărul este negativ sau pozitiv:
Math.ceil (42,23); \u003e 43 Math.ceil (36,93); \u003e 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;)
Folosind:
roundTo5 (11); \u003e 10
Dacă aveți nevoie de JavaScript pentru a rotunji la două cifre, puteți transmite atât semința, 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 \u003d 11; var multiplu \u003d 10; roundToMultiple (Număr inițial, multiplu); \u003e 10;
Pentru a rotunji valorile doar în sus sau în jos, înlocuiți rotundul cu tavan sau podea în funcție.
Range Snap
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).
Folosind:
var lowBound \u003d 1; var highBound \u003d 100; var numInput \u003d 123; var clamped \u003d Math.max (lowBound, Math.min (numInput, highBound)); console.log (prins); \u003e 100;
Puteți crea o funcție sau o extensie a clasei Number.
Math.round () funcția returnează valoarea unui număr rotunjit la cel mai apropiat număr întreg.
Sursa pentru acest exemplu interactiv este stocată într-un depozit GitHub. Dacă doriți să contribuiți la proiectul de exemple interactive, vă rugăm să clonați https://github.com/mdn/interactive-examples și să ne trimiteți o cerere de extragere.
Sintaxă
Math.round (x)Parametrii
x Un număr.Valoare returnată
Valoarea numărului dat rotunjit la cel mai apropiat număr întreg.
Descriere
Dacă porțiunea fracțională a argumentului este mai mare de 0,5, argumentul este rotunjit la numărul întreg cu următoarea valoare absolută mai mare. Dacă este mai mic de 0,5, argumentul este rotunjit la întregul cu valoarea absolută mai mică. Dacă porțiunea fracționată este exact 0,5, argumentul este rotunjit la următorul număr întreg în direcția + ∞. Rețineți că acest lucru diferă de funcțiile round () ale multor limbi, care adesea rotunjesc acest caz la următorul număr întreg departe de zero , în schimb, oferind un rezultat diferit în cazul numerelor negative cu o parte fracționată de exact 0,5.
Deoarece round () este o metodă statică a matematicii, o folosiți întotdeauna ca Math.round (), mai degrabă decât ca metodă a unui obiect Math pe care l-ați creat (Math nu are niciun constructor).
Exemple
Math.round (20.49); // 20 Math.round (20.5); // 21 Math.round (42); // 42 Math.round (-20,5); // -20 Math.round (-20.51); // -21Implementare demonstrativă
Mai jos este un fragment de cod care este echivalent funcțional cu math.round, cu excepția faptului că fragmentul de cod de mai jos este mai lent decât Math.round. Scopul fragmentului de cod de mai jos este de a demonstra modul în care funcționează Math.round.
Funcția vanilla_round (x) (var y \u003d Math.abs (x) + 0,5; // astfel încât mai puțin de 1/2 runde în jos; runde mai mari întoarcă Math.floor (x + 0,5))
Operatorul de modul de mai sus obține partea zecimală a lui x. Mai mult, fragmentul de cod de mai sus ar putea fi modificat pentru a rotunji la o anumită precizie pe un număr:
Funcție round_to_precision (x, precision) (var y \u003d + x + (precision \u003d\u003d\u003d nedefinit? 0,5: precision / 2); returnează y - (y% (precision \u003d\u003d\u003d nedefinit? 1: + precision));)
Round_to_precision (11, 2); // scoate 12 round_to_precision (11, 3); // produce 12 round_to_precision (11, 4); // scoate 12 round_to_precision (11, 5); // scoate 10 round_to_precision (11, 6); // scoate 12 round_to_precision (11, 7); // scoate 14 round_to_precision (11, 8); // produce 8 round_to_precision (3.7, 0.5); // scoate 3.5 round_to_precision (3,75, 0,5); // scoate 4 round_to_precision (3,8, 0,5); // ieșiri 4
Specificații
| Specificație | stare | cometariu |
|---|---|---|
| ECMAScript prima ediție (ECMA-262) | Standard | Definiția inițială. Implementat în JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) |
Standard | |
| ECMAScript 2015 (ediția a 6-a, ECMA-262) Definiția „Math.round” din specificația respectivă. |
Standard | |
| ECMAScript Ultimul proiect (ECMA-262) Definiția „Math.round” din specificația respectivă. |
Proiect |
Compatibilitate browser
Tabelul de compatibilitate din această pagină este generat din date structurate. Dacă doriți să contribuiți la date, consultați https://github.com/mdn/browser-compat-data și trimiteți-ne o cerere de extragere.
Actualizați datele de compatibilitate pe GitHub
| Desktop | Mobil | Server | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Crom | Margine | Firefox | Internet Explorer | Operă | Safari | Vizualizare web Android | Chrome pentru Android | Firefox pentru Android | Opera pentru Android | Safari pe iOS | Samsung Internet | Node.js | |
| rundă | Chrome Suport complet 1 | Suport Edge complet 12 | Suport complet Firefox 1 | IE Suport complet 3 | Opera Suport complet Da | Safari Suport complet Da | WebView Android Suport complet 1 | Chrome Android Suport complet 18 | Suport complet Firefox pentru Android 4 | Opera Android Suport complet Da | Safari iOS Suport complet Da | Samsung Internet Android Suport complet 1.0 | nodejs Suport complet Da |
Acum să ne uităm la metoda pardoselii (tradus ca gen)care funcționează opus metodei plafonului, adică este 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 descendent. Deși 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 Matematică.
Matrice sursă:
var numberArray \u003d;
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 în. Dar condiția nu este îndeplinităîntrucât funcția ia un singur parametru.
Soluția # 3 - Funcție cu doi parametri
Aici problema este rezolvată corect. Pentru a face acest lucru, a trebuit să vă amintiți subiectul condițiilor din javascript și să aplicați mai multe condiții în același timp.
34.82 - elementul original al tabloului
35 - rotunjeste
12.9 - elementul original al matricei
13 - rotunjiți în sus
17.01 - elementul original al tabloului
18 - rotunjeste
78.51 - elementul original al tabloului
79 - rotunjeste
aceasta decizia corectă Teme pentru acasă. Aici, doi parametri sunt specificați pentru funcție î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 fracționare.
