Rotunjire Javascript la cea mai apropiată zecime. Reguli simple de rotunjire în javascript. Studiem metodele și le aplicăm în practică. Rotunjiți până la cel mai apropiat număr întreg
Bună, iubitori de JavaScript. Ați observat deja că acest limbaj este foarte extraordinar și în fiecare secțiune se remarcă prin particularitățile sale și neobișnuit solutii tehnice. Prin urmare, publicația de astăzi este dedicată subiectului: „Rotunjirea JavaScript”.
După ce ați citit 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, ce distinge diviziunea cu 0. Fără a-mi schimba principiile, voi atașa exemple la punctele cheie ale material și descrieți fiecare acțiune în detaliu. Acum să începem să învățăm!
Note importante despre numereMai întâi, amintiți-vă că în js toate tipurile de numere (fracționale și întregi) sunt de tip Number. Î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 modul obișnuit:
var numb = 35; // număr natural
var drob = 0,93; //reprezentare zecimală
var numb16 = 0xFF; //Sistem de numere hexazecimale
Acceptă alte reprezentări numerice. Deci, puteți crea și numere în virgulă mobilă (uneori sunt numite „numere științifice”).
Acum există suport pentru o metodă toLocaleString() foarte interesantă, care formatează toți parametrii numerici conform specificațiilor prescrise în ECMA 402. Datorită acestui fapt, numerele mari, numere 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 diverse funcții matematice, al căror nume este Math .
În plus, există și alte metode care rotunjesc valorile numerice la numere întregi, zecimi, sutimi etc. Să le privim pe toate în detaliu.
Matematica Mare și PuternicăObiectul Math global include o mare varietate de elemente matematice și funcții trigonometrice. Acesta este un obiect foarte necesar și ajută adesea dezvoltatorii atunci când lucrează cu date digitale.
Există analogi ale matematicii pe alte platforme. De exemplu, în limbaje atât de populare precum Java și C#, Math este o clasă care acceptă toate la fel caracteristici standard. Deci, după cum puteți vedea, acest instrument este cu adevărat grozav și puternic.
Acum vreau să parcurg metodele specifice responsabile de rotunjire și să vorbesc despre ele în detaliu.
Math.floor()Voi începe cu matematica. podea Atenție la numele metodei. În mod logic devine clar că o dată despre care vorbim despre rotunjire, iar traducerea literală a cuvântului „etaj” înseamnă „podă”, atunci acest instrument va rotunji în jos valorile procesate.
De asemenea, este posibil ca numărul procesat folosind această funcție să rămână același. Acest lucru se datorează faptului că rotunjirea este efectuată utilizând o inegalitate nestrictă (=).
alert(Math.ceil(4.5));
După cum probabil ați ghicit, răspunsul va fi numărul 5.
Math.round()Această metodă se rotunjește număr fracționar la cel mai apropiat număr întreg. Deci, dacă parte fracționată este în intervalul de la 0 la 0,5 nu inclusiv, apoi rotunjirea are loc la o valoare mai mică. Și dacă partea fracțională se află în intervalul de la 0,5 inclusiv la următorul număr întreg, atunci este rotunjită la un număr întreg mai mare.
alert(Math.round(4.5));
Sper că toată lumea s-a gândit sau a spus că răspunsul corect este 5.
Încă câteva metodeJavaScript are, de asemenea, alte 2 metode care se ocupă de rotunjirea reprezentărilor numerice. Cu toate acestea, ele sunt oarecum diferite.
Vom vorbi despre instrumente precum toFixed() și toPrecision(). Ei sunt responsabili nu doar pentru rotunjire, ci și pentru acuratețea acesteia la anumite caractere. Să săpăm mai adânc.
toFixed()Folosind acest mecanism, puteți specifica la câte zecimale trebuie rotunjită valoarea. Metoda returnează rezultatul ca șir. Mai jos am atașat o opțiune cu trei opțiuni diferite. Analizați răspunsurile primite.
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, toFixed() va rotunji valoarea fracțională la un număr întreg. În a treia linie s-a efectuat rotunjirea la 2 cifre, iar în a patra linie s-au adăugat încă trei 0 datorită parametrului „7”.
la Precizie()Această metodă funcționează puțin diferit. În locul argumentului, puteți fie să lăsați un spațiu gol, fie să setați un parametru. Cu toate acestea, acesta din urmă va rotunji numerele la numărul specificat de cifre, indiferent de virgulă. Iată rezultatele produse de program, rescrise 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
Caracteristica împărțirii cu 0 î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, la împărțirea la zero, toate programele generează o eroare.
Cu toate acestea, JavaScript excelează și aici. Așadar, în timpul executării unei astfel de operațiuni, nu sunt ridicate mesaje de bug... pentru că o astfel de operație returnează „Infinit”!
De ce este așa? După cum se știe din aceleași științe matematice, cu cât divizorul este mai mic, rezultatul este număr mai mare. De aceea, creatorii acestui limbaj orientat spre prototip au decis să abandoneze șabloanele și să meargă pe drumul lor.
Pentru cei care întâlnesc valoarea Infinity pentru prima dată, am explicat mai jos caracteristicile acesteia.
Infinit – înseamnă infinit și corespunde pe deplin semnului matematic ∞.
Poate fi negativ. Toate regulile standard pentru lucrul cu operatori aritmetici sunt de asemenea păstrate.
alertă (12/ 0); // Infinit
alerta(12.34/ 0); // Infinit
alertă (-3/ 0); // -Infinit
Presupun că voi încheia aici. Dacă v-a plăcut publicația, asigurați-vă că vă abonați la blogul meu. Nu fi lacom cu link-uri către articole interesante și distribuie-le prietenilor tăi. Pa! Pa!
Adesea, calculele produc rezultate care sunt în afara intervalelor dorite. Ca rezultat, JavaScript trebuie să se rotunjească la o anumită valoare.
De ce numere rotunde?JavaScript nu stochează numere întregi deoarece valorile lor sunt reprezentate ca numere în virgulă mobilă. Multe fracții nu pot fi reprezentate ca un număr cu un anumit număr finit de zecimale, astfel încât JavaScript poate genera rezultate precum următoarele:
0.1 * 0.2; > 0.020000000000000004
În practică, acest lucru nu va face nicio diferență, deoarece vorbim despre o eroare de 2 chintilioane. Dar acest lucru poate afecta rezultatele atunci când lucrați cu numere care reprezintă valori monetare, procente sau dimensiunea fișierului. Prin urmare, trebuie să faceți sau la o anumită zecimală.
Rotunjirea numerelor zecimalePentru a „taia” un număr zecimal, utilizați metodele toFixed() sau toPrecision(). Ambele au un singur argument, care specifică numărul de locuri semnificative și zecimale care trebuie incluse în rezultat:
- dacă toFixed() nu are niciun argument specificat, valoarea implicită este 0 , adică fără zecimale; valoarea maximă a argumentului este 20;
- dacă nu i se dă niciun argument lui toPrecision(), numărul nu este schimbat.
var randNum = 6,25; randNum.toFixed(); > „6” Math.PI.toPrecision(1); > "3" var randNum = 87,335; randNum.toFixed(2); > "87,33" var randNum = 87,337; randNum.toPrecision(3); > "87,3"
Nota
Atât toFixed() cât și toPrecision returnează o reprezentare șir rotunjită a rezultatului, mai degrabă decât un număr. Aceasta înseamnă că adăugarea rotunjită la randNum va avea ca rezultat o concatenare de șiruri, mai degrabă decât un singur număr:
console.log(RandNum + rotunjit); > „6.256”
Dacă doriți ca JavaScript să rotunjească un număr la cele mai apropiate sutimi, utilizați parseFloat() :
var randNum = 6,25; var rounded = parseFloat(randNum.toFixed(1)); console.log(rotunjit); > 6.3
toFixed() și toPrecision() sunt de asemenea metode utile pentru a trunchia un număr mare de zecimale. Acest lucru este util atunci când lucrați cu numere care reprezintă unități monetare:
var wholeNum = 1 var dollarsCents = wholeNum.toFixed(2); console.log(dollarsCents); > „1.00”
Rețineți că, dacă un număr are mai multe cifre decât precizia specificată, toPrecision va scoate rezultatul în format științific:
var num = 123,435 num.toPrecision(2); > „1.2e+2”
Cum să evitați greșelile atunci când rotunjiți zecimaleÎn unele cazuri, toFixed și toPrecision fac ca JavaScript să rotunjească 5 în jos în loc de sus:
var numTest = 1,005; numTest.toFixed(2); > 1;
Rezultatul exemplului de mai sus ar trebui să fie 1.01, nu 1. Dacă doriți să evitați această eroare, vă recomand să utilizați numere exponențiale:
funcția rotund(valoare, zecimale) ( returnează Număr(Math.round(valoare+"e"+zecimale)+"e-"+zecimale); )
Aplicație:
rotund(1.005,2); > 1.01
Dacă doriți o soluție și mai robustă decât rotunjirea, este disponibilă pe MDN.
Rotunjire cu epsilonAlternativă Metoda JavaScript Rotunjirea la cea mai apropiată zecime a fost introdusă în ES6 (cunoscut și ca JavaScript 2015). „Machine 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 folosit într-o funcție pentru a obține o comparație validă:
funcția epsEqu(x, y) ( returnează Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Funcția ia două argumente: unul conține calculul, al doilea rezultatul așteptat (rotunjit). Returnează o comparație a acestor doi parametri:
epsEqu(0,1 + 0,2, 0,3) > adevărat
Toate browserele moderne acceptă funcțiile matematice ES6. Dar dacă trebuie să oferiți asistență în browsere mai vechi, atunci trebuie să utilizați polyfills.
Trunchierea numerelor zecimaleToate metodele prezentate mai devreme efectuează rotunjirea JavaScript la cea mai apropiată zecime. Pentru a trunchia un număr pozitiv la două zecimale, înmulțiți-l cu 100, trunchiați-l din nou și apoi împărțiți rezultatul la 100:
funcția trunchiat(num) ( returnează Math.trunc(num * 100) / 100; ) trunchiat(3.1416) > 3.14
Dacă aveți nevoie de ceva mai flexibil, puteți utiliza operatorul pe biți:
funcția trunchiată(num, decimalPlaces) ( var numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Utilizare:
var randInt = 35,874993; trunchiat(randInt,3); > 35.874
Rotunjiți la cel mai apropiat numărPentru a implementa rotunjirea JavaScript la un număr întreg, utilizați Math.round() :
Math.round(4.3) > 4 Math.round(4.5) > 5
Rețineți că „valorile pe jumătate” precum .5 sunt rotunjite în sus.
Rotunjiți în jos la cel mai apropiat număr întregDacă doriți să rotunjiți în jos, utilizați metoda Math.floor():
Math.floor(42,23); > 42 Math.floor(36,93); > 36
Rotunjirea în jos are o singură direcție pentru toate numerele, inclusiv pentru cele negative. Acesta poate fi gândit ca un zgârie-nori cu un număr infinit de etaje, inclusiv cele sub nivelul fundației (reprezentând numere negative). Dacă vă aflați într-un lift între etajele 2 și 3 (care corespunde unei valori de -2,5), Math.floor vă va duce la etajul -3:
Math.floor(-2,5); > -3
Dacă trebuie să evitați acest lucru, utilizați rotunjirea JavaScript Math folosind Math.trunc(), acceptat în toate browserele moderne (cu excepția IE/Edge):
Math.trunc(-41,43); > -41
MDN oferă, de asemenea, un polyfill cu trei linii pentru a oferi suport pentru Math.trunc în browsere mai vechi și IE/Edge.
Rotunjiți până la cel mai apropiat număr întregDacă doriți să rotunjiți numerele zecimale în sus, utilizați Math.ceil . Această metodă poate fi considerată și ca un lift infinit: Math.ceil te duce întotdeauna „în sus”, indiferent dacă numărul este negativ sau pozitiv:
Math.ceil(42,23); > 43 Math.ceil(36,93); > 37 Math.ceil(-36,93); -36
Rotunjiți la cel mai apropiat multipluDacă trebuie să rotunjiți o valoare la cel mai apropiat multiplu de 5, creați o funcție care împarte numărul la 5, îl rotunjește și apoi înmulțește rezultatul cu aceeași valoare:
funcția roundTo5(num) ( returnează Math.round(num/5)*5; )
Utilizare:
roundTo5(11); > 10
Dacă aveți nevoie de JavaScript pentru a rotunji la două cifre, puteți trece atât sămânța, cât și multiplul funcției:
funcția roundToMultiple(num, multiple) ( returnează Math.round(num/multiplu)*multiplu; )
Pentru a utiliza funcția, includeți numărul de rotunjit și multiplu în apelul său:
var initialNumber = 11; var multiplu = 10; roundToMultiple(initialNumber, multiple); > 10;
Pentru a rotunji doar valorile în sus sau în jos, înlocuiți rotunjirea cu tavan sau podea în funcție.
Legătura de gamăUneori trebuie să obțineți o valoare pentru x care trebuie să fie într-un anumit interval. De exemplu, avem nevoie de o valoare de la 1 la 100, dar obținem valoarea 123. Pentru a remedia acest lucru, puteți utiliza min() (returnează cel mai mic număr) și max (returnează numărul maxim permis).
Utilizare:
var lowBound = 1; var highBound = 100; var numInput = 123; var blocat = Math.max(lowBound, Math.min(numInput, highBound)); console.log(blocat); > 100;
Puteți crea o funcție sau o extensie a clasei Number.
Funcția Math.round() 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 la proiectul de exemple interactive, clonează https://github.com/mdn/interactive-examples și trimite-ne o cerere de extragere.
Sintaxă Math.round(x) Parametri x Un număr. Valoarea returnatăValoarea numărului dat rotunjită la cel mai apropiat număr întreg.
DescriereDacă 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 numărul întreg cu valoarea absolută mai mică. Dacă porțiunea fracțională este exact 0,5, argumentul este rotunjit la următorul întreg în direcția +∞. Rețineți că aceasta diferă de multe limbi" funcții round(), care rotunjesc adesea acest caz la următorul întreg departe de zero, dând în schimb un rezultat diferit în cazul numerelor negative cu o parte fracțională de exact 0,5.
Deoarece round() este o metodă statică a Math, 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 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); // -21 Implementare demonstrativăMai jos este un fragment de cod care este echivalent din punct de vedere 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 cum funcționează Math.round.
Funcția vanilla_round(x) ( var y = Math.abs(x) + 0,5; // astfel încât mai puțin de 1/2 rotunjire în jos; mai mare rotunjire în sus returnează Math.floor(x+0,5) )
Operatorul de modul de mai sus obține partea zecimală a lui x. În plus, fragmentul de cod de mai sus poate fi modificat pentru a rotunji la o anumită precizie pe un număr:
Funcția round_to_precision(x, precizie) ( var y = +x + (precizie === nedefinit ? 0,5: precizie/2); return y - (y % (precizie === nedefinit ? 1: +precizie)); )
Rotunjire_la_precizie(11, 2); // scoate 12 round_to_precision(11, 3); // scoate 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); // scoate 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); // iese 4
Specificații| ECMAScript prima ediție (ECMA-262) | Standard | Definiție 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 | |
| Ultima versiune ECMAScript (ECMA-262) Definiția „Math.round” din specificația respectivă. |
Proiect |
Tabelul de compatibilitate din această pagină este generat din date structurate. Dacă doriți să contribuiți la date, vă rugăm să consultați https://github.com/mdn/browser-compat-data și să ne trimiteți o cerere de extragere.
Actualizați datele de compatibilitate pe GitHub
| Desktop Mobile Server | ||||||||||||
| Chrome Edge Firefox Internet Explorer Opera Safari Vizualizare web Android Chrome pentru Android Firefox pentru Android Opera pentru Android Safari pe iOS Samsung Internet Node.js | ||||||||||||
| Suport complet Chrome 1 | Edge Suport complet 12 | Suport complet pentru Firefox 1 | IE suport complet 3 | Opera Suport complet Da | Safari Suport complet Da | WebView Android Suport complet 1 | Chrome Android Suport complet 18 | Firefox Android Suport complet 4 | Opera Android Suport complet Da | Safari iOS Suport complet Da | Samsung Internet Android Suport complet 1.0 | nodejs Suport complet Da |
În acest articol vom analiza în detaliu numere, operatori matematici, modalități de a converti un număr într-un șir și invers, precum și multe alte puncte importante.
funcția isFiniteFuncția isFinite vă permite să verificați dacă un argument este un număr finit.
Ca răspuns această funcție returnează false dacă argumentul este Infinity , -Infinity , NaN , sau va fi turnat la una dintre aceste valori numerice speciale. În caz contrar, această funcție va returna true.
IsFinite(73); // adevărat este finit(-1/0); // false este Finit(Infinit); // false este finit(NaN); // false este finit("Text"); // fals
Cu excepţia functie globala isFinite JavaScript are și o metodă Number.isFinite . Spre deosebire de isFinite, nu forțează ca argumentul să fie convertit într-un număr.
IsFinite("73"); // true Number.isFinite("73"); // fals
funcția isNaNFuncția isNaN este concepută pentru a determina dacă un argument este un număr sau poate fi convertit în unul. Dacă da, atunci funcția isNaN returnează false. În caz contrar, se întoarce adevărat.
IsNaN(NaN); //true isNaN ("25px"); //adevărat, pentru că 20px nu este un număr isNaN(25,5); //false isNaN ("25.5"); //false isNaN(" "); //fals, pentru că un spațiu sau mai multe spații sunt convertite în 0 isNaN(null); //fals, pentru că null este convertit la 0 isNaN(true); //fals, pentru că adevărat este convertit la 1 isNaN(fals); //fals, pentru că false este convertit la 0
Dacă această acțiune trebuie efectuată fără un tip cast, atunci utilizați metoda Number.isNaN. Această metodă a fost introdusă în limbaj începând cu ECMAScript 6.
Cum se transformă în mod explicit un șir într-un număr?Puteți converti explicit un șir într-un număr folosind următoarele metode:
1. Folosiți operatorul unar +, care trebuie plasat înaintea valorii.
+"7,35"; // 7.35 +"text"; // NaN
Această metodă ignoră spațiile de la începutul și sfârșitul liniei, precum și \n (line feed).
+" 7,35 "; //7.35 +"7.35 \n "; //7.35
Folosind această metodă Rețineți că un șir gol sau un șir format din spații și \n este convertit la numărul 0. În plus, convertește și tipul de date nul și valorile booleene într-un număr.
Nul; //0 +adevărat; //1 +fals; //0 +" "; //0
2. Funcția ParseInt. Această funcție este concepută pentru a converti un argument într-un număr întreg. Spre deosebire de utilizarea operatorului unar +, această metodă vă permite să convertiți un șir într-un număr în care nu toate caracterele sunt numerice. Începe să convertească șirul, începând de la primul caracter. Și de îndată ce întâlnește un caracter nenumeric, această funcție își oprește activitatea și returnează numărul rezultat.
ParseInt("18px"); //18 parseInt("33,3%"); //33
Această funcție poate funcționa cu diferite sisteme de numere (binar, octal, zecimal, hexazecimal). Baza sistemului numeric este specificată folosind 2 argumente.
ParseInt("18px", 10); //18 parseInt("33,3%", 10); //33 parseInt("101",2); //5 parseInt("B5",16); //181
Pe lângă funcția parseInt, JavaScript are metoda Number.parseInt. Această metodă nu este diferită de funcția parseInt și a fost introdusă în JavaScript cu specificația ECMASCRIPT 2015 (6).
3. funcția parseFloat. Funcția parseFloat este similară cu parseInt , cu excepția faptului că vă permite să convertiți argumentul într-un număr fracționar.
ParseFloat("33,3%"); //33.3
În plus, funcția parseFloat, spre deosebire de parseInt, nu are 2 argumente și, prin urmare, încearcă întotdeauna să trateze șirul ca un număr în sistem zecimal Socoteala.
ParseFloat("3.14"); parseFloat("314e-2"); parseFloat("0.0314E+2");
Pe lângă funcția parseFloat, JavaScript are metoda Number.parseFloat. Această metodă nu este diferită de funcția parseFloat și a fost introdusă în JavaScript cu specificația ECMASCRIPT 2015 (6).
Conversia unui număr într-un șirPuteți transforma un număr într-un șir folosind metoda toString.
(12.8).toString(); //"12,8"
Metoda toString vă permite, de asemenea, să specificați baza sistemului de numere, ținând cont de care trebuie să convertiți în mod explicit numărul într-un șir:
(255).toString(16); //"ff"
Cum se verifică dacă o variabilă este un numărPuteți determina dacă valoarea unei variabile este un număr utilizând una dintre următoarele metode:
1. Folosind funcțiile isNaN și isFinite:
// myVar este o variabilă dacă (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar este un număr sau poate fi turnat la acesta);
Ca functie:
// funcția funcției isNumeric(valoare) ( return !isNaN(parseFloat(valoare)) && isFinite(parseFloat(valoare)); ) // folosește var myVar = "12px"; console.log(isNumeric(myVar)); //adevărat
Această metodă vă permite să determinați dacă valoarea specificată este un număr sau poate fi convertită în unul. Această opțiune nu numără șirul gol, șirul de spații, nul, Infinity, -Infinity, true și false ca număr.
2. Folosind operatorul typeof și isFinite, funcțiile isNaN:
// funcție care verifică dacă valoarea este un număr." && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}
Această funcție determină dacă valoarea specificată este de tip Number și dacă este una dintre valorile speciale Infinity, -Infinity și NaN. Dacă da, atunci această funcție returnează true.
3. Folosind metoda ECMAScript 6 Number.isInteger(value). Această metodă vă permite să determinați dacă valoarea specificată este un număr întreg.
Number.isInteger("20"); //fals, pentru că această metodă nu convertește un șir într-un număr Number.isInteger(20); //adevărat, pentru că valoare dată este un număr
Numere pare și imparePuteți verifica dacă un număr este par sau impar folosind următoarele funcții:
// Funcție pentru verificarea unui număr pentru funcția de paritate pară isEven(n) ( return n % 2 == 0; ) // Funcție pentru verificarea unui număr pentru funcția de paritate impară isOdd(n) ( return Math.abs(n % 2) == 1;
Dar înainte de a efectua o astfel de verificare, este recomandabil să vă asigurați că valoarea specificată este un număr:
Valoare = 20; dacă (Număr.isInteger(valoare)) ( dacă (este Even(valoare)) ( console.log(„Număr „ + valoare.toString() + „ - par”); ) )
Numerele prime în JavascriptSă ne uităm la un exemplu în care vom afișa numere prime de la 2 la 100 folosind Javascript.
// Funcția care verifică dacă un număr este primă funcție isPrime(valoare) ( dacă (isNaN(valoare) || !isFinite(valoare) || valoare%1 || valoare< 2) return false; var max=Math.floor(Math.sqrt(value)); for (var i = 2; i< = max; i++) { if (value%i==0) { return false; } } return true; } // создать массив, который будет содержать простые числа от 2 до 100 var primaryNumber = ; for (var i = 2; i (больше), < (меньше), >= (mai mare sau egal cu), 3); //false console.log(5>=3); //adevărat
La compararea numerelor cu o parte fracțională, este necesar să se țină cont de erorile care pot apărea în timpul acestor calcule.
De exemplu, în JavaScript, suma numerelor (0,2 + 0,4) nu este egală cu 0,6:
Console.log((0,2+0,4)==0,6); //fals
Erorile apar deoarece toate calculele sunt efectuate de calculator sau de alt tip dispozitiv electronic produce în sistem cu 2 numere. Aceste. Înainte de a efectua orice acțiune, computerul trebuie mai întâi să convertească numerele prezentate în expresie în al 2-lea sistem numeric. Dar nu orice număr zecimal fracționar poate fi reprezentat exact în al 2-lea sistem numeric.
De exemplu, numărul 0,25 10 in sistem binar convertit exact.
0,125 × 2 = 0,25 | 0 0,25 × 2 = 0,5 | 0 0,5 × 2 = 1 | 1 0,125 10 = 0,001 2
De exemplu, numărul 0,2 10 poate fi convertit în sistemul 2 numai cu o anumită precizie:
0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 ... 0,2 10 = 0,001100110011... 2
Ca urmare, aceste erori vor afecta calculul sumei a două numere și rezultatele comparației. Aceste. Se pare că JavaScript va vedea de fapt această intrare după cum urmează:
0.6000000000000001==0.6
Când calculați sau afișați numere cu părți fracționale, trebuie să indicați întotdeauna precizia cu care doriți să faceți acest lucru.
De exemplu, comparați numere cu până la 2 zecimale folosind metodele toFixed() și toPrecision():
//metoda toFixed() console.log(((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //metoda toPrecision() console.log(((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //adevărat
Operații matematice de bazăUrmătorii operatori matematici există în JavaScript: + (adunare), - (scădere), * (înmulțire), / (împărțire), % (modulo), ++ (creștere o valoare cu 1), -- (scădere o valoare cu 1).
6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, i.e. 6:3=2 => 6-3*2 => rest(0) 5%2 //1, i.e. 5:2=2(.5) => 5-2*2 => rest(1) 7.3%2 //1.3, i.e. 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //semnul rezultatului operației % este egal cu semnul primei valori -9%2.5 //-1.5 , adică 9:2.5=3(.6) => 9-2.5*3 => rest(1.5) -9%-2.5 //-1.5, i.e. 9:2.5=3(.6) => 9-2.5*3 => rest(1.5) -2%5 //-2, i.e. 2:5=0(.4) => 2-5*0 => rest(2) x = 3; console.log(x++); // scoate 3, apoi setează 4 console.log(x); //4 x = 3; console.log(++x); //setează 4 și iese x = 5; console.log(x--); // scoate 5, apoi setează 4 console.log(x); //4 x = 5; console.log(--x); //seturile 4 și iese În plus, JavaScript are operatori de combinație: x+=y (x=x+y), x-=y (x=x-y), x*=y (x=x*y), x/= y (x=x/y), x%=y (x=x%y).
x = 3; y = 6; x+=y; console.log(x); //9 x = 3; y = 6; x-=y; console.log(x); //-3 x = 3; y = 6; x*=y; console.log(x); //18 x = 3; y = 6; x/=y; console.log(x); //0,5 x = 3; y = 6; x%=y; console.log(x); //3 Acum să ne uităm la metoda podelei(tradus ca gen)
, care funcționează opus metodei plafonului, adică. se rotunjește o fracțiune în jos.
var varsta = 35,97;
varsta = Math.floor(varsta); /* Rotunjește valoarea variabilei de vârstă în jos */
document.write(varsta); După cum puteți vedea, metoda podelei a rotunjit numărul de la 35,97 la 35, adică în jos. În ciuda faptului că 0,97 este mai mare decât 0,5.
(cm. )
Această lecție a analizat metodele obiectului Math pentru rotunjirea numerelor zecimale fracționale.
Acum trebuie să-ți faci temele.
Sarcina ta este să scrii o funcție care ia doi parametri.
1. Un tablou format din numere cu fracții.
La ieșire, funcția ar trebui să scoată aceeași matrice, dar în același timp pe toate elemente de matrice, trebuie rotunjit folosind metoda obiect Math specificată în al doilea parametru.
Matrice sursă:
var numberArray = ;
La început, rezolvarea acestei sarcini poate părea aproape identică cu rezolvarea problemelor legate de teme primii trei lecții pe această temă. Dar nu totul este atât de simplu...
Soluția #1 - Atenție
În funcție de condițiile sarcinii, funcția trebuie să ia doi parametri - matricea originală și una dintre metodele: „rotund”, „tavan” sau „podeu” . Pe baza asta, am încercat să fac asta...
funcția zecimală (anyArray ,method ) /* Creați o funcție cu doi parametri */
{
pentru (i = 0; i< anyArray .length ; i ++ )
{
document.write(anyArray
"
)
anyArray = Math.method(anyArray); /* Folosind una dintre metodele obiectului Math, rotunjim elementul curent al tabloului */
document.write(anyArray + "
"
)
}
decimal (numberArray, round ) /* Apelați funcția și specificați doi parametri pentru aceasta. Dar NU PUTEȚI specifica metoda NAME ca parametru de funcție */
În această soluție, creăm o funcție cu doi parametri, iar atunci când o apelăm, încercăm să specificăm matricea originală și NUMELE unei metode ca parametrii funcției:
decimal(numberArray, round) - în acest caz rotund.
Dar nu vom obține niciun rezultat, deoarece NU PUTEȚI specifica metoda NAME ca parametru al funcției.
Vă rugăm să rețineți: nu este o coincidență că în enunțul problemei denumirile metodelor „rotund”, „tavan” și „pardoseală” sunt cuprinse între ghilimele.
zecimală (numberArray, "round") - dar nici o astfel de notație nu va fi corectă!!!
Soluția nr. 2 - Corectarea soluției anterioare
Puteți rezolva problema specificând un parametru pentru funcție.
var numberArray = ;
function decimal (anyArray ) /* Creați o funcție cu un parametru */
{
pentru (i = 0; i< anyArray .length ; i ++ ) /* Перебираем элементы массива */
{
document.write(anyArray + " - element de matrice sursă
" ) /* Afișează elementul curent al matricei */
/* Folosind metoda rotunjită a obiectului Math, rotunjim elementul curent al tabloului */
document.write(anyArray + " - Element rotunjit
" ) /* Afișează elementul de matrice ROUNDED */
}
decimal (numberArray ) /* Apelați funcția și specificați un parametru - tabloul original */
35 - Element rotunjit
13 - Element rotunjit
17 - Element rotunjit
79 - Element rotunjit
Aici am reușit să realizăm rezultatul dorit: Metoda rotunjite 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, trebuia să-mi amintesc tema condițiilor în javascript și să aplic mai multe condiții în același timp.
var numberArray = ;
funcție zecimală (anyArray,method)
{
pentru (i = 0; i<
anyArray
.length
; i
++
)
{
document.write(anyArray + " - element de matrice sursă
"
);
dacă (metoda
{
anyArray = Math.round(anyArray);
document.write(anyArray + " - rotunjire standard
"
)
}
Altfel, dacă (metoda
{
document.write (anyArray + " - rotunjiți în sus
"
)
}
else if(metoda
{
document.write (anyArray + " - rotunjiți în jos
"
)
}
}
}
decimal (numberArray, "ceil") /* Al doilea parametru al funcției - între ghilimele, indicați numele uneia dintre metode */
34.82 - elementul inițial al tabloului
35 - rotunjiți în sus
12.9 - element de matrice inițial
13 - rotunjiți în sus
17.01 - elementul inițial al matricei
18 - rotunjiți în sus
78.51 - elementul inițial al tabloului
79 - rotunjiți în sus
Aceasta este soluția corectă pentru temele dvs. Aici sunt specificați doi parametri pentru funcție în funcție de condiție.
Încercați ultima linie a acestei soluții:
decimal(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 + metoda promptă
Am decis să optimizez puțin soluția anterioară și am adăugat o metodă promptă, care apelează o fereastră modală care conține un câmp pentru introducerea informațiilor.
Acum, datorită acestui lucru, puteți introduce numele uneia dintre metodele rotund, podea sau tavan în câmpul de introducere și obțineți rezultatul corespunzător.
var numberArray = ;
funcție zecimală (anyArray,method)
{
pentru (i = 0; i<
anyArray
.length
; i
++
)
{
document.write(anyArray + " - element de matrice sursă
"
);
if (metoda == "rotundă" ) /* Prima condiție */
{
anyArray = Math.round(anyArray);
document.write(anyArray + "
"
)
}
Else if(metoda == "tavan" ) /* A doua condiție */
{
anyArray = Math.ceil(anyArray);
document.write(anyArray + "
"
)
}
else if(metoda == "etaj" ) /* A treia condiție */
{
anyArray = Math.floor(anyArray);
document.write(anyArray + "
"
)
}
/* Adăugați metoda prompt */
var method = prompt ("Introduceți una dintre metodele: rotund, tavan sau podea" );
if (metoda == "etaj" ) /* Prima condiție */
{
document.write("Ați introdus o metodă " + metoda + " care rotunjește numerele în jos
"
)
}
else if (metoda == "rotundă" ) /* A doua condiție */
{
document.write("Ați introdus o metodă " + metoda + " care rotunjește numerele conform regulilor standard
"
)
}
else if (metoda == "tavan" ) /* A treia condiție */
{
document.write("Ați introdus o metodă " + metoda + " care rotunjește numerele în sus
"
)
}
else /* Altfel... */
{
document.write("Nu ați introdus sau ați introdus incorect o metodă
"
)
}
zecimal (numberArray, metoda) /* Apelați funcția */
Acesta este modul în care funcționează metodele rotund, podea sau plafon ale obiectului Math, care rotunjesc numerele fracționale.