Rotunjirea numerelor js în sus. Reguli simple de rotunjire în javascript. Studiem metode și le punem în practică
Adesea, calculele produc rezultate care sunt în afara intervalelor dorite. Ca urmare, este necesar să se implementeze Rotunjire JavaScript până la o anumită valoare.
De ce numere rotunde?
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ță de atunci despre care 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 zecimale
A tăia" numar decimal, sunt utilizate 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”
Notă
Atât toFixed() cât și toPrecision returnează o reprezentare șir rotunjită a rezultatului, mai degrabă decât un număr. Aceasta înseamnă că adăugarea rotunjită la randNum va avea ca rezultat o concatenare de șiruri, mai degrabă decât un singur număr:
console.log(RandNum + rotunjit); > „6.256”
Dacă doriți ca JavaScript să rotunjească un număr la cea mai apropiată sutime, utilizați parseFloat() :
var randNum = 6,25; var rotunjit = parseFloat(randNum.toFixed(1)); console.log(rotunjit); > 6.3
toFixed() și toPrecision() sunt, de asemenea, metode utile pentru tăiere cantitate mare zecimale. Acest lucru este util atunci când lucrați cu numere care reprezintă unități monetare:
var wholeNum = 1 var dollarsCents = wholeNum.toFixed(2); console.log(dollarsCents); > „1.00”
Rețineți că, dacă un număr are mai multe cifre decât precizia specificată, toPrecision va scoate rezultatul în format științific:
var num = 123,435 num.toPrecision(2); > „1.2e+2”
Cum să evitați greșelile atunci când rotunjiți zecimale
În unele cazuri, se implementează Fixed și Precision JavaScript rotunjind 5 în jos, și nu la mai mult:
var numTest = 1,005; numTest.toFixed(2); > 1;
Rezultatul exemplului de mai sus ar trebui să fie 1.01, nu 1. Dacă doriți să evitați această eroare, vă recomand să utilizați numere exponențiale:
funcția rotund(valoare, zecimale) ( returnează Număr(Math.round(valoare+"e"+zecimale)+"e-"+zecimale); )
Aplicație:
rotund(1.005,2); > 1.01
Dacă aveți nevoie de o soluție și mai robustă decât rotunjirea, aceasta este disponibilă la MDN.
Rotunjire cu epsilon
Metodă alternativă JavaScript rotunjit la zecimi a fost introdus în ES6 ( cunoscut și sub numele de JavaScript 2015). « Epsilon de mașină" oferă o marjă rezonabilă de eroare atunci când se compară două numere în virgulă mobilă. Fără rotunjire, comparațiile pot produce rezultate similare cu următoarele:
0,1 + 0,2 === 0,3 > fals
Math.EPSILON poate fi folosit într-o funcție pentru a obține o comparație validă:
funcția epsEqu(x, y) ( returnează Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Funcția ia două argumente: unul conține calculele, al doilea rezultatul așteptat (rotunjit). Returnează o comparație a acestor doi parametri:
epsEqu(0,1 + 0,2, 0,3) > adevărat
Toate browserele moderne acceptă functii matematice ES6. Dar dacă trebuie să oferiți asistență în browsere mai vechi, atunci trebuie să utilizați polyfills.
Trunchierea numerelor zecimale
Toate metodele prezentate anterior funcționează JavaScript rotunjit la zecimi. Pentru a trunchia un număr pozitiv la două zecimale, înmulțiți-l cu 100, trunchiați-l din nou și apoi împărțiți rezultatul la 100:
funcția trunchiată(num) ( returnează Math.trunc(num * 100) / 100; ) trunchiat(3.1416) > 3.14
Dacă aveți nevoie de ceva mai flexibil, puteți utiliza operatorul pe biți:
funcția trunchiată(num, decimalPlaces) ( var numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Utilizare:
var randInt = 35,874993; trunchiat(randInt,3); > 35.874
Rotunjiți la cel mai apropiat număr
A implementa JavaScript rotunjit la cel mai apropiat număr întreg, Math.round() este folosit:
Math.round(4.3) > 4 Math.round(4.5) > 5
Rețineți că " jumatate de valori", cum ar fi .5, sunt rotunjite în sus.
Rotunjiți în jos la cel mai apropiat număr întreg
Dacă doriți să rotunjiți în jos, utilizați metoda Math.floor():
Math.floor(42,23); > 42 Math.floor(36,93); > 36
Rotunjirea în jos are o singură direcție pentru toate numerele, inclusiv pentru cele negative. Acesta poate fi imaginat ca un zgârie-nori cu un număr infinit de etaje, inclusiv sub nivelul fundației ( reprezentând numere negative). Dacă vă aflați în liftul dintre etajele 2 și 3 de la subsol ( care corespunde unei valori de -2,5), Math.floor vă va duce la etajul -3:
Math.floor(-2,5); > -3
Dacă trebuie să evitați acest lucru, utilizați JavaScript Math rotunjire folosind Math.trunc() , acceptat în toate browsere moderne(cu exceptia IE/Edge):
Math.trunc(-41,43); > -41
MDN oferă, de asemenea polyfill cu trei linii pentru a oferi suport pentru Math.trunc în browserele mai vechi și IE/Edge.
Rotunjiți până la cel mai apropiat număr întreg
Dacă doriți să rotunjiți numerele zecimale în sus, utilizați Math.ceil . Această metodă poate fi considerată și ca un lift infinit: Math.ceil te duce întotdeauna „în sus”, indiferent dacă numărul este negativ sau pozitiv:
Math.ceil(42,23); > 43 Math.ceil(36,93); > 37 Math.ceil(-36,93); -36
Rotunjiți la cel mai apropiat multiplu
Dacă trebuie să rotunjiți o valoare la cel mai apropiat multiplu de 5, creați o funcție care împarte numărul la 5, îl rotunjește și apoi înmulțește rezultatul cu aceeași valoare:
funcția roundTo5(num) ( returnează Math.round(num/5)*5; )
Utilizare:
roundTo5(11); > 10
Dacă aveți nevoie de JavaScript pentru a rotunji la două cifre, puteți trece atât sămânța, cât și multiplul funcției:
funcția roundToMultiple(num, multiple) ( returnează Math.round(num/multiplu)*multiplu; )
Pentru a utiliza funcția, includeți numărul care trebuie 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 valoarea lui x, care trebuie să fie în interior anumit interval. De exemplu, avem nevoie de o valoare de la 1 la 100, dar obținem valoarea 123. Pentru a remedia acest lucru, puteți folosi min() ( returnează cel mai mic număr) și max ( returnează numărul maxim permis).
Utilizare:
var lowBound = 1; var highBound = 100; var numInput = 123; var blocat = Math.max(lowBound, Math.min(numInput, highBound)); console.log(blocat); > 100;
Puteți crea o funcție sau o extensie a clasei Number:
Number.prototype.clamp = function(min, max) ( return Math.min(Math.max(this, min), max); );
Utilizare:
(numInput).clamp(lowBound, highBound);
rotunjire gaussiană
rotunjire gaussiană („bancare”, convergentă sau olandeză) este o metodă de rotunjire fără eroare statistică. Standard Rotunjire JavaScript uneori dă erori într-o direcție mai mare. Rotunjirea gaussiană evită această eroare prin rotunjirea la cel mai apropiat număr par. Cea mai bună decizie, pe care o cunosc.
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 numere
În primul rând, amintiți-vă că în js toate tipurile de numere (fracționale și întregi) aparțin tipului Număr. În plus, toate sunt pe 64 de biți, deoarece sunt stocate în formatul „dublă precizie”, cunoscut și sub numele de standard IEEE-754.
Variabilele numerice sunt create în mod obișnuit:
var numb = 35; // numar 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 și „numere științifice”).
Acum există suport pentru o metodă foarte interesantă toLocaleString(), 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 Matematică.
În afară de aceasta, există și alte metode care efectuează rotunjirea valori numerice până la numere întregi, până la zecimi, sutimi etc. Să le privim pe toate în detaliu.
Matematica Mare și Puternică
Obiectul Math global include o cantitate mare diverse 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 astfel de limbi populare, la fel ca Java și C#, Math este o clasă care acceptă la fel specificații 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 Matematică.podea. Acordați atenție denumirii metodei. În mod logic, devine clar că, din moment ce 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 se efectuează conform unei inegalități nestricte (<=). Таким образом, при отработке этой строчки кода:
alert(Math.floor(4.5));
răspunsul va fi numărul 4.
Math.ceil()
Din nou, uită-te la nume (în acest fel materialul este absorbit mai repede). Dacă cineva nu știe, „tavan” înseamnă „tavan”. Aceasta înseamnă că datele numerice vor fi rotunjite folosind 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 un număr fracționar la cel mai apropiat număr întreg. Deci, dacă partea fracțională este în intervalul de la 0 la 0,5 nu inclusiv, atunci 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 metode
JavaScript 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 la Precizie(). Ei sunt responsabili nu doar pentru rotunjire, ci și pentru precizia 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, atunci toFixed ()) va rotunji valoarea fracțională la intreg numere. A treia linie este rotunjită până la 2 caractere, iar în al patrulea, datorită parametrului „7”, s-au adăugat încă trei 0-uri.
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 cantitate specificată numere, 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. Deci, în timpul executării unei astfel de operațiuni, nu apar mesaje de eroare... deoarece o astfel de operație revine "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 semn 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 un link către articole interesanteși împărtășește-le cu prietenii tăi. Pa! Pa!
Cu stima, Roman Chueshov
Citit: de 194 de ori
În acest articol ne vom uita în detaliu la numere, operatori matematici, modalități de a converti un număr într-un șir și invers, precum și multe alte puncte importante.
funcția isFinite
Funcția isFinite vă permite să verificați dacă un argument este un număr finit.
Ca răspuns această funcție returnează false dacă argumentul este Infinity , -Infinity , NaN , sau va fi turnat la una dintre aceste valori numerice speciale. În caz contrar, această funcție va returna true.
IsFinite(73); // adevărat este finit(-1/0); // false este Finit(Infinit); // false este finit(NaN); // false este finit("Text"); // fals
Cu exceptia 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 isNaN
Funcția isNaN este concepută pentru a determina dacă un argument este un număr sau poate fi convertit în unul. Dacă da, atunci funcția isNaN returnează false. În caz contrar, se întoarce adevărat.
IsNaN(NaN); //true isNaN ("25px"); //adevărat, pentru că 20px nu este un număr isNaN(25,5); //false isNaN ("25.5"); //false isNaN(" "); //fals, pentru că un spațiu sau mai multe spații sunt convertite la 0 isNaN(null); //fals, pentru că valoare nulă convertit la 0 isNaN(adevărat); //fals, pentru că adevărat este convertit la 1 isNaN(fals); //fals, pentru că false este convertit la 0
Dacă această acțiune trebuie efectuată fără un tip cast, atunci utilizați metoda Number.isNaN. Această metodă a fost introdusă în limbaj începând cu ECMAScript 6.
Cum se transformă în mod explicit un șir într-un număr?
Puteți converti explicit un șir într-un număr folosind următoarele metode:
1. Utilizare operator unar +, care trebuie plasat înaintea valorii.
+"7,35"; // 7.35 +"text"; // NaN
Această metodă ignoră spațiile de la începutul și sfârșitul liniei, precum și \n (line feed).
+" 7,35 "; //7.35 +"7.35 \n "; //7.35
Folosind aceasta metoda este necesar să se acorde atenţie faptului că linie goală sau un șir format din spații și \n este convertit la numărul 0. În plus, convertește și tipul date nuleși valori booleene la număr.
Nul; //0 +adevărat; //1 +fals; //0 +" "; //0
2. Funcția ParseInt. Această funcție este concepută pentru a converti argument la număr întreg. Spre deosebire de folosire operator unar +, aceasta metoda vă permite să convertiți un șir într-un număr, în care nu toate caracterele sunt numerice. Începe să convertească șirul, începând de la primul caracter. Și de îndată ce întâlnește un caracter nenumeric, această funcție își oprește activitatea și returnează numărul rezultat.
ParseInt("18px"); //18 parseInt("33,3%"); //33
Această funcție poate funcționa cu sisteme diferite Numere (binare, octale, zecimale, hexazecimale). Baza sistemului numeric este specificată folosind 2 argumente.
ParseInt("18px", 10); //18 parseInt("33,3%", 10); //33 parseInt("101",2); //5 parseInt("B5",16); //181
Pe lângă funcția parseInt, JavaScript are metoda Number.parseInt. Această metodă nu este diferită de funcția parseInt și a fost introdusă în JavaScript cu specificația ECMASCRIPT 2015 (6).
3. funcția parseFloat. Funcția parseFloat este similară cu parseInt , cu excepția faptului că vă permite să convertiți argumentul într-un număr fracționar.
ParseFloat("33,3%"); //33.3
În plus, funcția parseFloat, spre deosebire de parseInt, nu are 2 argumente și, prin urmare, încearcă întotdeauna să trateze șirul ca un număr în 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).
Transformarea unui număr într-un șir
Puteți transforma un număr într-un șir folosind metoda toString.
(12.8).toString(); //"12,8"
Metoda toString vă permite, de asemenea, să specificați baza sistemului de numere, ținând cont de care este necesar să convertiți în mod explicit numărul într-un șir:
(255).toString(16); //"ff"
Cum se verifică dacă o variabilă este un număr
Stabiliți dacă valoarea este număr variabil puteți folosi 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 o funcție:
// 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 impare
Puteți verifica dacă un număr este par sau impar folosind următoarele funcții:
// Funcție pentru verificarea unui număr pentru funcția de paritate pară isEven(n) ( return n % 2 == 0; ) // Funcție pentru verificarea unui număr pentru funcția de paritate impară isOdd(n) ( return Math.abs(n % 2) == 1;
Dar înainte de a efectua o astfel de verificare, este recomandabil să vă asigurați că valoarea specificată este un număr:
Valoare = 20; dacă (Număr.isInteger(valoare)) ( dacă (este Even(valoare)) ( console.log(„Număr „ + valoare.toString() + „ - par”); ) )
Numerele prime în Javascript
Să ne uităm la un exemplu din care derivăm folosind Javascript numere prime de la 2 la 100.
// Funcția care verifică dacă un număr este funcție primă isPrime(valoare) ( dacă (isNaN(valoare) || !isFinite(valoare) || valoare%1 || valoare< 2) return false; var max=Math.floor(Math.sqrt(value)); for (var i = 2; i< = max; i++) { if (value%i==0) { return false; } } return true; } // создать массив, который будет содержать простые числа от 2 до 100 var primaryNumber = ; for (var i = 2; i
Rotunjirea unui număr în Javascript
Există diferite moduri de a rotunji o fracție la un număr întreg în JavaScript.
1. Folosind metodele Math.floor, Math.ceil și Math.round special concepute pentru aceasta. Metoda Math.floor rotunjește o fracție la cel mai apropiat număr întreg, adică. pur și simplu aruncă partea fracționată. Math.ceil rotunjește o fracție până la cel mai apropiat număr întreg. Math.round rotunjește un număr în sus sau în jos, în funcție de valoarea părții fracționale. Dacă partea fracțională este mai mare sau egală cu 0,5, atunci în sus, în caz contrar, răsucirea este în jos.
Console.log(Math.floor(7.9)); //7 console.log(Math.ceil(7.2)); //8 console.log(Math.round(7.5)); //8
2. Folosind metoda toFixed(precision). Această metodă rotunjește partea fracțională a unui număr la precizie specificată. Rezultatul rotunjirii este returnat ca șir.
Console.log(7.987.toFixed(2)); //"7,99"
Dacă nu există suficiente zecimale pentru a forma precizia specificată a numărului, atunci acesta este umplut cu zerouri.
Console.log(7.987.toFixed(5)); //"7,98700"
3. Folosind metoda toPrecision(accuracy). Această metodă reprezintă un număr cu o precizie specificată. În același timp, el poate rotunji nu numai fracționarea, ci și întreaga parte a numărului. În funcție de rezultat, această metodă poate prezenta numărul rezultat cu punct fix sau sub formă exponențială.
Console.log((1001).toPrecision(2)); //"1.0e+3" console.log((1001).toPrecision(5)); //"1001.0" console.log((12.4).toPrecision(1)); //"1e+1" console.log((12.4).toPrecision(2)); //"12" console.log((12.4).toPrecision(3)); //"12.4" console.log((12.4).toPrecision(5)); //"12.400"
4. Folosind operatori logici NU sau SAU.
//prin negație logică dublă console.log(~~7.9); //7 // folosind SAU logic cu zero: console.log(7.9^0); //7
Parte întreagă și fracționară a unui număr
Puteți obține partea întreagă a unui număr folosind metodele Math.floor() și parseInt():
Console.log(Math.floor(7.21)); // 7 console.log(parseInt(7.21)); // 7
Puteți obține partea fracționară a unui număr folosind operatorul procent (%). Acest operator returnează restul care se va obține din împărțirea primului număr la al doilea. În acest caz, trebuie să utilizați 1 ca al doilea număr.
Console.log(7,21%1); // 0,2099999999999996 // precis cu 2 zecimale console.log((7,21%1).toFixed(2)); // "0,21"
În plus, partea fracțională poate fi obținută și folosind calcule:
Număr var = 7,21; var fractionNumber = număr - Math.floor(Math.abs(număr)); console.log(fractionNumber); // 0,2099999999999996
Numărul este divizibil cu un număr întreg?
Puteți determina dacă un număr este divizibil cu un număr întreg folosind operatorul procentual:
Număr var = 9; // dacă restul numărului împărțit la 3 este 0, atunci da, altfel nu dacă (număr%3==0) ( console.log ("Numărul " + numărul + " este divizibil cu 3"); ) else ( consolă ("Numărul " + numărul + " nu este divizibil cu 3");
Formatarea numerelor
În JavaScript, formatați numărul de ieșire conform standardele regionale (Setările de limbă sistem de operare) permite metoda toLocaleString().
De exemplu, să formatăm un număr în conformitate cu standardele regionale care sunt instalate implicit în sistem:
Număr var = 345,46; console.log(number.toLocaleString()); //"345,46"
De exemplu, să formatăm numărul în conformitate cu standardele regionale ale Rusiei (ru):
Console.log((108.1).toLocaleString("ru-RU")); //"108.1"
Această metodă poate fi folosită și pentru a formata un număr ca monedă:
Console.log((2540.125).toLocaleString("ru-RU",(style:"currency", currency:"RUB"))); //"2.540,13 ₽" console.log((89.3).toLocaleString("ru-RU",(style:"currency", currency:"USD"))); //"89.30 $" console.log((2301.99).toLocaleString("ru-RU",(style:"currency", currency:"EUR"))); //"2.301,99 EUR"
Reprezentarea unui număr ca procent:
Console.log((0.45).toLocaleString("ru-RU",(stil:"procent"))); //"45%"
Împărțiți un număr în cifre (proprietatea useGrouping):
Console.log((125452.32).toLocaleString("ru-RU",(useGrouping:true))); //"125.452,32"
Tipăriți un număr cu un anumit număr de cifre (2) după virgulă:
Console.log((1240.4564).toLocaleString("ru-RU",(minimumFractionDigits:2, maximumFractionDigits:2))); //"1.240,46"
Comparația numerelor
Următorii operatori sunt utilizați pentru a compara numerele în JavaScript: == (egal), != (nu este egal), > (mai mare decât),< (меньше), >= (mai mare sau egal cu),<= (меньше или равно).
De exemplu, să comparăm două numere:
Console.log(2>3); //false console.log(5>=3); //Adevărat
La compararea numerelor cu o parte fracțională, este necesar să se țină cont de erorile care pot apărea în timpul acestor calcule.
De exemplu, în JavaScript, suma numerelor (0,2 + 0,4) nu este egală cu 0,6:
Console.log((0,2+0,4)==0,6); //fals
Erorile apar deoarece toate calculele sunt efectuate de calculator sau de alt tip dispozitiv electronic produce în sistem cu 2 numere. Acestea. Înainte de a efectua orice acțiune, computerul trebuie mai întâi să convertească numerele prezentate în expresie în al 2-lea sistem numeric. Dar nu orice număr zecimal fracționar poate fi reprezentat exact în al 2-lea sistem numeric.
De exemplu, numărul 0,25 10 este convertit exact în binar.
0,125 × 2 = 0,25 | 0 0,25 × 2 = 0,5 | 0 0,5 × 2 = 1 | 1 0,125 10 = 0,001 2
De exemplu, numărul 0,2 10 poate fi convertit în sistemul 2 numai cu o anumită precizie:
0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 ... 0,2 10 = 0,001100110011... 2
Ca urmare, aceste erori vor afecta calculul sumei a două numere și rezultatele comparației. Acestea. Se pare că JavaScript va vedea de fapt această intrare după cum urmează:
0.6000000000000001==0.6
Când calculați sau afișați numere cu părți fracționale, trebuie să indicați întotdeauna precizia cu care doriți să faceți acest lucru.
De exemplu, comparați numere cu până la 2 zecimale folosind metodele toFixed() și toPrecision():
//metoda toFixed() console.log(((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //metoda toPrecision() console.log(((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //Adevărat
Operații matematice de bază
Următorii operatori matematici există în JavaScript: + (adunare), - (scădere), * (înmulțire), / (împărțire), % (modulo), ++ (creștere o valoare cu 1), -- (scădere o valoare cu 1).
6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, i.e. 6:3=2 => 6-3*2 => rest(0) 5%2 //1, i.e. 5:2=2(.5) => 5-2*2 => rest(1) 7.3%2 //1.3, i.e. 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //semnul rezultatului operației % este egal cu semnul primei valori -9%2.5 //-1.5 , adică 9:2.5=3(.6) => 9-2.5*3 => rest(1.5) -9%-2.5 //-1.5, i.e. 9:2.5=3(.6) => 9-2.5*3 => rest(1.5) -2%5 //-2, i.e. 2:5=0(.4) => 2-5*0 => rest(2) x = 3; console.log(x++); // scoate 3, apoi setează 4 console.log(x); //4 x = 3; console.log(++x); //setează 4 și iese x = 5; console.log(x--); // scoate 5, apoi setează 4 console.log(x); //4 x = 5; console.log(--x); //seturile 4 și iese În plus, JavaScript are operatori de combinație: x+=y (x=x+y), x-=y (x=x-y), x*=y (x=x*y), x/= y (x=x/y), x%=y (x=x%y). x = 3; y = 6; x+=y; console.log(x); //9 x = 3; y = 6; x-=y; console.log(x); //-3 x = 3; y = 6; x*=y; console.log(x); //18 x = 3; y = 6; x/=y; console.log(x); //0,5 x = 3; y = 6; x%=y; console.log(x); //3
Adesea rezultatul calculelor este un număr cu o cantitate mare zecimale. Dacă acest număr este folosit pentru calcule ulterioare, atunci poate fi lăsat așa cum este. Dar uneori un număr trebuie rotunjit, de exemplu pentru afișare pe o pagină. JavaScript rotunjește numerele folosind mai multe metode.
Metoda Math.round() rotunjește valoarea la un număr întreg.
Math.round (număr)
Numerele sunt rotunjite conform regulilor matematice. Adică, dacă după virgulă zecimală există un număr de la 0 la 4, atunci partea fracțională este pur și simplu aruncată. Și dacă după virgulă zecimală există un număr de la 5 la 9, atunci partea fracțională este eliminată și se adaugă una la întreaga parte. exemplu:
JavaScript:
Mai există două metode care rotunjesc un număr la un număr întreg. Metoda Math.floor() rotunjește în jos. Îndepărtează partea fracționară a numărului. Și metoda Math.ceil() se rotunjește în sus. Îndepărtează partea fracțională și adaugă una la întreaga parte. Exemplu:
Desigur, 5 - (-2) este 5+2. Nu uitați că nu veți obține numărul 5 în această formulă. Maximul va fi 4,999999999. Valorile rezultate pot fi rotunjite la precizia necesară.
Dacă sunt necesare numai numere întregi, atunci valorile rezultate pot fi rotunjite în jos la cel mai apropiat număr întreg. Una trebuie adăugată la maxim pentru ca și acest maxim să fie posibil. Formula arată astfel:
întreg = Math.floor(min + Math.random() * (max + 1 - min)
Să tipărim numerele de la 10 la 15:
20 |
pentru (i=1; i<=10; i++) { rand = Math.floor(10 + Math.random() * (15 + 1 - 10)); console.log(rand); } |
Comparația numerelor fracționale
Calculele matematice au o particularitate - rezultatele lor nu sunt întotdeauna absolut exacte. Aceasta este o problemă nu numai cu JavaScript, ci și cu majoritatea limbajelor de programare. Acest lucru se întâmplă deoarece numerele și alte date sunt convertite în cod binar și numai atunci se fac calcule cu ele. În majoritatea cazurilor, acest lucru nu duce la dificultăți deosebite, uneori, calculele au ca rezultat un număr cu un număr mare de zecimale. Dar există o situație în care inexactitatea calculului afectează funcționarea programului. Aceasta este o comparație de numere. Dacă se compară numere diferite, atunci totul ar trebui să fie bine.
5.1 < 5.2
Dar dacă calculul are ca rezultat două numere fracționale identice, atunci rezultatul comparării lor nu este previzibil. Ele pot fi egale, sau unul poate fi mai mare decât celălalt. Când un script folosește o astfel de comparație, trebuie să verificați dacă scriptul funcționează corect. Dacă există o eroare în ea, atunci trebuie să rotunjiți valorile care sunt comparate.
Alte metode matematice
Există destul de multe metode pentru diferite calcule matematice. Sunt simple și nu necesită explicații suplimentare. Metodele care sunt adesea folosite sunt enumerate în următorul tabel:
Încercați să faceți niște calcule folosind aceste metode.
De foarte multe ori, calculele în JavaScript nu dau exact rezultatele pe care ni le dorim. Desigur, putem face ce vrem cu numere - rotunjim în sus sau în jos, setați intervale, tăiați numerele inutile la un anumit număr de zecimale, totul depinde de ce doriți să faceți cu acest număr în viitor.De ce este necesară rotunjirea?
Unul dintre aspectele interesante ale JavaScript este că de fapt nu stochează numere întregi, lucrăm imediat cu numere în virgulă mobilă. Acest lucru, combinat cu faptul că multe valori fracționale nu pot fi exprimate într-un număr finit de zecimale, în JavaScript putem obține rezultate ca acestea:0.1 * 0.2;
> 0.020000000000000004
0.3 - 0.1
> 0.19999999999999998
În scopuri practice, această inexactitate nu contează, în cazul nostru vorbim despre o eroare în chintilioane de piese, totuși, acest lucru îi poate dezamăgi pe unii. De asemenea, putem obține rezultate oarecum ciudate atunci când lucrăm cu numere care reprezintă monede, procente sau dimensiuni de fișiere. Pentru a corecta aceste inexactități, trebuie doar să putem rotunji rezultatele și este suficient să setăm precizia zecimală.
Rotunjirea numerelor are uz practic, este posibil să manipulăm un număr într-un anumit interval, de exemplu, dorim să rotunjim valoarea la cel mai apropiat număr întreg, în loc să lucrăm doar cu partea zecimală.
Rotunjirea numerelor zecimale
Pentru a decupa un număr zecimal, utilizați metoda toFixed sau toPrecision. Ambele au un singur argument care specifică, respectiv, câte cifre semnificative (adică numărul total de cifre utilizate în număr) sau zecimale (numărul după virgulă) rezultatul ar trebui să includă:- Dacă un argument nu este definit pentru toFixed() atunci acesta va fi implicit egal cu zero, ceea ce înseamnă 0 zecimale, argumentul are o valoare maximă de 20.
- Dacă toPrecision nu i se oferă niciun argument, numărul este lăsat neatins
Ambele metode toFixed() și toPrecision() returnează o reprezentare șir a rezultatului, nu un număr. Aceasta înseamnă că, atunci când se însumează o valoare rotunjită cu randNum, se va produce o concatenare de șiruri, mai degrabă decât o sumă de numere:
Fie randNum = 6,25; let rounded = randNum.toFixed(); // "6" console.log(randNum + rotunjit); > „6.256”
Dacă vrei ca rezultatul să fie tip numeric date, atunci va trebui să aplicați parseFloat:
Fie randNum = 6,25; let rounded = parseFloat(randNum.toFixed(1)); console.log(rotunjit); > 6.3
Vă rugăm să rețineți că valorile de 5 sunt rotunjite, cu excepția cazurilor rare.
Metodele toFixed() și toPrecision() sunt utile deoarece nu numai că pot tăia partea fracțională, ci și pot adăuga zecimale, ceea ce este convenabil atunci când lucrați cu moneda:
Let wholeNum = 1 let dollarsCents = wholeNum.toFixed(2); console.log(dollarsCents); > „1.00”
Rețineți că toPrecision va produce rezultatul în notație științifică dacă numărul de numere întregi este mai mare decât precizia în sine:
Fie num = 123,435 num.toPrecision(2); > „1.2e+2”
Cum să evitați erorile de rotunjire cu zecimale
În unele cazuri, toFixed și toPrecision rotunjește valoarea 5 în jos și în sus:Fie numTest = 1,005; numTest.toFixed(2); > „1.00”
Rezultatul calculului de mai sus ar fi trebuit să fie 1,01, nu 1. Dacă doriți să evitați eroare similară, putem folosi soluția propusă de Jack L Moore, care folosește numere exponențiale pentru a calcula:
Funcția rotund(valoare, zecimale) ( returnează Număr(Math.round(valoare+"e"+zecimale)+"e-"+zecimale); )
Acum:
Rotunzi (1,005,2); > 1.01
Dacă doriți o soluție mai robustă decât cea prezentată mai sus, puteți merge la MDN.
Mașină epsilon rotunjire
O metodă alternativă pentru rotunjirea numerelor zecimale a fost introdusă în ES6. Rotunjirea epsilonului 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 === 0,3 > fals
Folosim Math.EPSILON în funcția noastră pentru a obține o comparație validă:
Funcția epsEqu(x, y) ( returnează Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y));
}
Funcția are două argumente: primul este calculul curent, al doilea este rezultatul așteptat. Acesta returnează o comparație a celor două:
EpsEqu(0,1 + 0,2, 0,3) > adevărat
Toate browserele moderne acceptă deja funcțiile matematice ES6, dar dacă doriți suport în browsere precum IE 11, utilizați polyfills.
Tăierea părții fracționale
Toate metodele prezentate mai sus se pot rotunji la numere zecimale. Pentru a reduce pur și simplu un număr la două zecimale, trebuie mai întâi să-l înmulțiți cu 100 și apoi să împărțiți rezultatul rezultat la 100:Funcția trunchiat(num) ( return Math.trunc(num * 100) / 100; ) trunchiat(3.1416) > 3.14
Dacă doriți să adaptați metoda la orice număr de zecimale, puteți utiliza negația dublă pe biți:
Funcția trunchiată(num, decimalPlaces) (let numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Acum:
Fie randInt = 35,874993; trunchiat(randInt,3); > 35.874
Rotunjiți la cel mai apropiat număr
Pentru a rotunji un număr zecimal la cel mai apropiat număr în sus sau în jos, oricare dintre ele ne aflăm cel mai aproape, utilizați Math.round():Math.round(4.3) > 4 Math.round(4.5) > 5
Vă rugăm să rețineți că „jumătate din valoare”, 0,5 este rotunjit în sus conform regulilor matematicii.
Rotunjiți în jos la cel mai apropiat număr întreg
Dacă doriți să rotunjiți întotdeauna în jos, utilizați Math.floor:Math.floor(42,23); > 42 Math.floor(36,93); > 36
Vă rugăm să rețineți că rotunjirea în jos funcționează pentru toate numerele, inclusiv pentru numerele negative. Imaginați-vă un zgârie-nori cu un număr infinit de etaje, inclusiv etaje la nivelul de jos (reprezentând numere negative). Dacă vă aflați într-un lift la cel mai jos nivel între 2 și 3 (care reprezintă o valoare de -2,5), Math.floor vă va duce la -3:
Math.floor(-2,5); > -3
Dar daca vrei sa eviti situație similară, utilizați Math.trunc, acceptat în toate browserele moderne (cu excepția IE/Edge):
Math.trunc(-41,43); > -41
Pe MDN veți găsi un polyfill care va oferi suport pentru Math.trunc în browsere și IE/Edge.
Rotunjiți până la cel mai apropiat număr întreg
Pe de altă parte, dacă întotdeauna trebuie să rotunjiți, utilizați Math.ceil. Din nou, amintiți-vă de liftul infinit: Math.ceil va merge întotdeauna „în sus”, indiferent dacă numărul este negativ sau nu:Math.ceil(42,23); > 43 Math.ceil(36,93); > 37 Math.ceil(-36,93); > -36
Rotunjire în sus/în jos la numărul necesar
Dacă vrem să rotunjim la cel mai apropiat multiplu de 5, cel mai simplu mod este să creăm o funcție care împarte numărul la 5, îl rotunjește și apoi îl înmulțește cu aceeași sumă:Funcția roundTo5(num) ( returnează Math.round(num/5)*5; )
Acum:
RoundTo5(11); > 10
Dacă doriți să rotunjiți la multipli ai valorii dvs., folosim mai mult functia generala, trecând valoarea inițială și un multiplu în ea:
Funcția roundToMultiple(num, multiple) ( returnează Math.round(num/multiple)*multiple; )
Acum:
Fie initialNumber = 11; fie multiplu = 10; roundToMultiple(initialNumber, multiple); > 10;
Fixarea unui număr într-un interval
Există multe cazuri în care dorim să obținem o valoare a lui x care se află într-un interval. De exemplu, s-ar putea să avem nevoie de o valoare între 1 și 100, dar am ajuns la 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 = 1; lasă highBound = 100; fie numInput = 123; let clamped = Math.max(lowBound, Math.min(numInput, highBound)); console.log(blocat); > 100;
Din nou, putem reutiliza operația și înfășura totul într-o funcție, folosind soluția propusă de Daniel X. Moore:
Number.prototype.clamp = function(min, max) ( return Math.min(Math.max(this, min), max); );
Acum:
NumInput.clamp(lowBound, highBound); > 100;
rotunjire gaussiană
Rotunjirea gaussiană, cunoscută și sub denumirea de rotunjire bancheră, implică rotunjirea la cel mai apropiat număr par. Această metodă de rotunjire funcționează fără erori statistice. O soluție mai bună a fost sugerată de Tim Down:Funcția gaussRound(num, decimalPlaces) ( fie d = decimalPlaces || 0, m = Math.pow(10, d), n = +(d ? num * m: num).toFixed(8), i = Math.floor (n), f = n - i, e = 1e-8, r = (f > 0,5 - e && f< 0.5 + e) ?
((i % 2 == 0) ? i: i + 1) : Math.round(n);
return d ? r / m: r;
}
Acum:
GaussRound(2,5) > 2 gaussRound(3,5) > 4 gaussRound(2,57,1) > 2,6
Decimală în CSS:
Deoarece JavaScript este adesea folosit pentru a crea mapări poziționale pentru elementele HTML, s-ar putea să vă întrebați ce s-ar întâmpla dacă am genera valori zecimale pentru elementele noastre:
#box ( lățime: 63,667731993px; )
Vestea bună este că browserele moderne vor respecta valorile zecimale în model bloc, inclusiv unități procentuale sau pixeli.
Triere
De foarte multe ori trebuie să sortăm unele elemente, de exemplu, avem o serie de înregistrări ale jocului și acestea trebuie organizate în ordinea descrescătoare a rangului jucătorului. Din pacate, metoda standard sort() are câteva limitări surprinzătoare: funcționează bine cu cele utilizate frecvent în cuvinte englezești, dar se defectează imediat când întâlniți numere, caractere unice sau cuvinte majuscule.Sortarea alfabetică
S-ar părea că sortarea unei matrice în ordine alfabetică ar trebui să fie o sarcină simplă:Lăsați fructe = [„dovleac”, „caise”, „cântapă”]; fruct.sort(); > „caisă”, „dovleac”, „gustalup”]
Cu toate acestea, ne confruntăm cu o problemă de îndată ce unul dintre elemente este cu majuscule:
Lasa fructe = ["dovleac", "caise", "Cantalope"]; fruct.sort(); > „Cantalup”, „caise”, „dovleac”]
Acest lucru se datorează faptului că, în mod implicit, sortatorul compară primul caracter reprezentat în Unicode. Unicode este cod unic pentru orice simbol, indiferent de platformă, indiferent de program, indiferent de limbă. De exemplu, dacă te uiți la tabelul de coduri, caracterul „a” are valoarea U+0061 (in sistem hexazecimal 0x61), în timp ce caracterul „C” are codul U+0043 (0x43), care apare mai devreme în tabelul Unicode decât caracterul „a”.
Pentru a sorta o matrice care poate conține primele litere mixte cu majuscule, trebuie fie să convertim temporar toate elementele în minuscule, fie să definim ordinea noastră de sortare folosind metoda localeCompare() cu unele argumente. De regulă, pentru un astfel de caz, este mai bine să creați imediat o funcție pentru utilizare repetată:
Funcția alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("sensibilitate": "bază")); )); ) let fruit = ["dovleac butternut „, „caisă”, „Cantalup”]; alphaSort(fructe) >
Dacă doriți să obțineți o matrice sortată invers ordine alfabetică, schimbați doar pozițiile lui a și b în funcție:
Funcția alphaSort(arr) ( arr.sort(function (a, b) ( return b.localeCompare(a, "en", ("sensibilitate": "bază")); )); ) let fruit = ["dovleac butternut „, „caisă”, „Cantalup”]; alphaSort(fructe) > ["Cantalupe", "dovleac", "caise"]
Aici este de remarcat faptul că localeCompare este folosit cu argumente, trebuie să ne amintim, de asemenea, că este suportat de IE11+, pentru versiunile mai vechi de IE, îl putem folosi fără argumente și cu litere mici:
Funcția caseSort(arr) ( arr.sort(funcție (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) let fruit = ["dovleac", "caise", "Pepene galben"]; caseSort(fructe) > ["caise", "dovleac", "Cantalupe"]
Sortare numerică
Toate acestea nu se aplică exemplului despre care am vorbit mai sus despre gama de înregistrări ale jocului. Cu unele matrice numerice, sortarea funcționează bine, dar la un moment dat rezultatul poate fi imprevizibil:Fie highScores = ; highScores.sort(); >
Chestia este că metoda sort() realizează o comparație lexicografică: ceea ce înseamnă că numerele vor fi convertite într-un șir și comparațiile se vor face din nou prin potrivirea primului caracter al acelui șir în ordinea caracterelor din tabelul Unicode. . Prin urmare, trebuie să definim din nou ordinea noastră de sortare:
Fie highScores = ; highScores.sort(function(a,b) ( return a - b; )); >
Din nou, pentru a sorta numerele în ordine inversă, schimbați pozițiile lui a și b în funcție.
Sortarea unei structuri asemănătoare JSON
Și, în sfârșit, dacă avem o structură de date asemănătoare JSON reprezentată ca o serie de înregistrări de joc:Fiți scoruri = [ ( „nume”: „Daniel”, „scor”: 21768 ), ( „nume”: „Michael”, „scor”: 33579 ), ( „nume”: „Alison”, „scor”: 38395 ) ];
În ES6+, puteți utiliza funcții de săgeți:
Scores.sort((a, b) => b.score - a.score));
Pentru browserele mai vechi care nu au acest suport:
Scores.sort(funcție(a, b) ( returnează a.score - b.score ));
După cum puteți vedea, sortarea în JavaScript este un lucru destul de obscur, sper că aceste exemple vor face viața mai ușoară cumva.
Lucrul cu funcții de putere
Exponentiația este o operație definită inițial ca rezultat al înmulțirii repetate a unui număr natural cu el însuși rădăcina pătrată a lui a este numărul care dă a la pătrat. Am putea folosi aceste funcții în mod constant în Viata de zi cu zi la lecțiile de matematică, inclusiv calcularea suprafețelor, volumelor sau chiar modelarea fizică.În JavaScript functie de putere introdus ca Math.pow(), a fost introdus în noul standard ES7 nou operator exponentiație - " * * ".
Exponentiație
Pentru a ridica un număr la a n-a putere, utilizați funcția Math.pow(), unde primul argument este numărul care va fi ridicat la putere, al doilea argument este exponentul:Math.pow(3,2) > 9
Această formă de notație înseamnă 3 pătrat, sau 3 × 3, ceea ce duce la rezultatul 9. Un alt exemplu poate fi dat, desigur:
Math.pow(5,3); > 125
Adică, 5 cuburi, sau 5 × 5 × 5, este egal cu 125.
ECMAScript 7 este următoarea versiune JavaScript, în principiu, putem folosi noul operator de exponențiere propus - * *, această formă de notație poate fi mai descriptivă:
3 ** 2
> 9
Pe acest moment Suportul pentru acest operator este destul de limitat, deci utilizarea lui nu este recomandată.
Funcția de putere poate fi utilă în cele mai multe situatii diferite. Un exemplu simplu, calcularea numărului de secunde într-o oră: Math.pow (60,2).
Rădăcini pătrate și cubice
Math.sqrt() și Math.cbrt() sunt opusul Math.pow(). După cum ne amintim, rădăcina pătrată a lui a este numărul care dă a când este pătrat.Math.sqrt(9) > 3
În același timp, rădăcina cubă a lui a este un număr care dă a atunci când este ridicat la un cub.
Math.cbrt(125) > 5
Math.cbrt() a fost introdus doar recent în specificația JavaScript și, prin urmare, este acceptat doar în browserele moderne: Chrome 38+, Firefox și Opera 25+ și Safari 7.1+. Vei observa asta Internet Explorer nu se află pe această listă, dar veți găsi un polyfill pe MDN.
Exemple
Desigur, putem folosi valori non-întregi în una dintre aceste funcții:Math.pow(1,25, 2); > 1,5625 Math.cbrt(56,57) > 3,8387991760286138
Vă rugăm să rețineți că acest lucru funcționează destul de bine și atunci când utilizați valori negative ale argumentelor:
Math.pow(-5,2) > 25 Math.pow(10,-2) > 0,01
Cu toate acestea, acest lucru nu va funcționa pentru rădăcina pătrată:
Math.sqrt(-9) > NaN
Din analiză matematicăȘtim că prin număr imaginar înțelegem rădăcinile pătrate ale numerelor negative. Și asta ne poate conduce la o altă tehnică de lucru numere complexe, Dar asta este o altă poveste.
Puteți folosi fracții în Math.pow() pentru a găsi rădăcinile pătrate și cubice ale numerelor. Rădăcină pătrată folosește exponentul 0,5:
Math.pow(5, 0,5); // = Math.sqrt(5) = 5 ** (1/2) > 2,23606797749979
Cu toate acestea, din cauza capricilor virgulei mobile, nu puteți ghici exact rezultatul corect:
Math.pow(2,23606797749979,2) > 5,000000000000001
În astfel de situații, va trebui să recurgeți la tăierea semnelor din număr sau rotunjirea la o anumită valoare.
Unii, de din motive necunoscute JavaScript confundă funcția Math.pow() cu Math.exp() , care este o funcție exponențială pentru numere în general. Notă: în Limba engleză„exponent” este tradus ca „exponent”, deci este mai probabil să se aplice vorbitorilor de engleză, deși există denumiri alternative pentru exponent, cum ar fi index, putere.
Constante matematice
Lucrul cu matematica în JavaScript este facilitat de o serie de constante încorporate. Aceste constante sunt proprietăți ale obiectului Math. Este de remarcat faptul că constantele sunt scrise cu majuscule, nu cu notația CamelCase.Numai utilizatorii înregistrați pot participa la sondaj. Intrati va rog.
Etichete:- javascript
- matematică
