Sveiki, mīļotāji JavaScript-A. Jūs jau esat ievērojuši, ka šī valoda ir ļoti neparasta, un katrā sadaļā izceļas tās īpatnībām un neparastiem tehniskiem risinājumiem. Tāpēc šodienas publikācija ir veltīta tēmai: JavaScript noapaļošana.

Izlasot pašreizējo rakstu, jūs uzzināsiet, kāpēc tas ir nepieciešams, lai apaļas numurus, kādas metodes un īpašības JS veic šo funkciju, kā arī sadalījumu 0. nemainot savus principus, es pievienosim piemērus galvenajiem punktiem materiālu un raksta katru darbību detalizēti. Tagad sākam mācīties!

Svarīgas piezīmes par numuriem

Lai sāktu ar, atcerieties, ka JS visos skaitļos (frakcionētie un veseli skaitļi) attiecas uz tipu Numurs. Turklāt visi no tiem ir 64 bitu, jo tie tiek glabāti "dubultā precizitātes" formātā, kas ir pazīstams arī saskaņā ar IEEE-754 standartu.

Izveidoti skaitliski mainīgie ar parasto ceļu:

var sastindzis \u003d 35; // dabiskais numurs

var drob \u003d 0,93; // decimālā pārstāvība

vAR NUMB16 \u003d 0XFF; // 16 bagātību sistēma

Atbalsta citus skaitliskus skatus. Tātad, jūs varat arī izveidot ciparus ar peldošo punktu (dažreiz tos sauc par "skaitļiem zinātniskā formātā").

Parādījās atbalsts par ļoti interesantu metodi tolocalestring ()kas formātus visus skaitliskos parametrus saskaņā ar ECMA 402. Sakarā ar šo lielo skaitu, tālruņu numurus, valūtas un pat procentus ir skaisti parādīti dialoglodziņā.

vAR NUM \u003d 714000.80;

brīdinājums (num.tolocalestring ());

Strādāt ar tipa numura elementiem, veselu globālu objektu ar visu matemātisko funkciju ķekaru, kuru vārds Matemātika..

Turklāt ir citas metodes, kas veic noapaļošanas skaitliskās vērtības veseliem skaitļiem līdz desmitdaļām, simtdaļām utt. Apsveriet tos vēl vairāk.

Lieliska un varens matemātika

Globālais matemātikas objekts ietver lielu skaitu dažādu matemātisko un trigonometrisko funkciju. Tas ir ļoti nepieciešams objekts un bieži samazina izstrādātājus, strādājot ar digitālajiem datiem.

Uz citām platformām ir analoģijas matemātika. Piemēram, populārajās valodās, piemēram, Java un C #, matemātika ir klase, kas atbalsta visas tās pašas standarta funkcijas. Tātad, kā jūs redzat, šis rīks ir patiešām liels un varens.

Tagad es gribu iet cauri konkrētām metodēm, kas atbild par noapaļošanu, un pastāstiet par tiem detalizēti.

Math.floor ()

Es sākšu S. Matemātika.grīda. Pievērsiet uzmanību metodes nosaukumam. Tā loģiski kļūst skaidrs, ka, tā kā mēs runājam par noapaļošanu, un vārda "grīdas" burtiskā tulkošana nozīmē "grīdas", tad šis rīks apaļās pārstrādātās vērtības mazākās taisni.

Iespējama arī iespēja, kad apstrādātais numurs, kas izmanto šo funkciju, paliek nemainīga. Viss, jo noapaļošana tiek veikta neironu nevienlīdzību (<=). Таким образом, при отработке этой строчки кода:

brīdinājums (math.floor (4.5));

atbilde būs 4. numurs.

Math.ceil ()

Atkal, aplūkojiet vārdu (šādā metodē, materiāls ātri uzsūcas). Ja kāds nezina, "griestu" ir "griesti". Tas nozīmē, ka skaitliskā datu noapaļošana tiks veikta visvairāk, izmantojot ne-nevienlīdzību (\u003e \u003d).

brīdinājums (math.ceil (4.5));

Kā jūs jau uzminējāt, atbilde būs 5. numurs.

Math.round ()

Šī metode apaļo daļu līdz tuvākajam veselumam. Tātad, ja daļējā daļa ir robežās no 0 līdz 0,5 neiekļaujošām, noapaļošana notiek mazāku vērtību. Un, ja daļējā daļa ir robežās no iekļaujošām 0,5 un līdz nākamajam veselajam skaitlim, tas ir noapaļots uz vairākiem veseliem.

brīdinājums (math.round (4.5));

Es ceru, ka visi domāja vai teica pareizo atbildi - 5.

Dažas citas metodes

JavaScript ir arī citas 2 metodes, kas nodarbojas ar skaitlisko attēlojumu noapaļošanu. Tomēr tie ir nedaudz atšķirīgi.

Tas būs par šādiem instrumentiem kā tofixed () un topreCision (). Viņi atbild ne tikai noapaļojot, bet tās precizitāti noteiktām pazīmēm. Cīņosimies dziļāk.

tofixed ()

Ar šo mehānismu jūs varat norādīt, cik daudz pazīmju pēc komatiem ir nepieciešams apaļas vērtību. Metode atgriež rezultātu kā virkni. Zemāk es pievienoju iespēju ar trim dažādām iespējām. Analizējiet saņemtās atbildes.

vAR NUM \u003d 5656.9393;

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

document.writeln (num.tofixed (2)); // 5656.94

document.writeln (Num.tofixed (7)); // 5656.9393000

Kā redzams, ja nenorādāt argumentu, tad tikfē ()) Rounds Frakcionālā vērtība vesels numuri. Trešajā rindā pabeidza noapaļošanu līdz 2 rakstzīmēmun ceturtajā - parametra "7" dēļ tika risināti vēl trīs 0 0.

topreCision ()

Šī metode darbojas nedaudz atšķirīgi. Pieņemuma vietā jūs varat atstāt gan tukšu vietu, gan iestatiet parametru. Tomēr pēdējais apaļos skaitļus pirms norādītā skaita skaita, nepievēršot uzmanību komatam. Šeit ir programmas rezultāti, kas pārrakstīti no pagātnes piemēriem:

vAR NUM \u003d 5656.9393;

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

document.writeln (num.toprecision (2)); // 5.7E + 3

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

Nodaļas fails 0 js

Kā zināms no matemātikas stundām, nav iespējams sadalīt līdz nullei. Šis noteikums bija pamats lielākā daļa no plānošanas valodu veidotājiem. Tāpēc, dalot nulli, visas programmas sniedz kļūdu.

Tomēr JavaScript šeit izceļas. Tātad, izpildes laikā šādu operāciju, nav bug ziņojumu rodas ... jo šāda operācijas atgriežas "Infinity"!

Kāpēc tā? Kā tas ir pazīstams no tām pašām matemātiskajām zinātnēm, jo \u200b\u200bmazāks ir dalītājs, rezultāts ir lielāks skaits. Tāpēc šīs prototipa orientētās valodas veidotāji nolēma atteikties no veidnēm un iet savu ceļu.

Tiem, kuri pirmo reizi saskaras ar bezgalības vērtību, zemāk es izskaidroju savas funkcijas.

Infinity - nozīmē bezgalību un pilnībā atbilst matemātisko zīmi ∞.

Var būt negatīvs. Visi standarta noteikumi darbam ar aritmētikas operatoriem tiek saglabāti arī.

brīdinājums (12/0); // bezgalība.

brīdinājums (12.34 / 0); // bezgalība.

brīdinājums (-3 / 0); // -infinity.

Iespējams, un beidzot. Ja vēlaties publikāciju, tad pārliecinieties, lai parakstīties uz manu emuāru. Neaizmirstiet atsauci uz interesantiem rakstiem un dalieties ar draugiem. Bye Bye!

JavaScript-matemātika, noapaļošana līdz divām zīmēm aiz komata (9)

Man ir šāds JavaScript sintakse:

Var atlaide \u003d math.round (100 - (Cena / Lollprice) * 100);

Tas ir noapaļots līdz veselam skaitlim. Kā es varu atgriezt rezultātu ar divām decimālzīmēm?

Šeit ir darba piemērs

VaR vērtība \u003d 200.2365455; Rezultāts \u003d math.round (vērtība * 100) / 100 // rezultāts būs 200.24

Apstrādes noapaļošanai uz jebkuru vairāku zīmju skaitu vairumam vajadzību, būs pietiekami daudz funkciju ar 2 kodu līnijām. Šeit ir spēles piemērs.

Var testnum \u003d 134,9567654; Var decpl \u003d 2; var testres \u003d apaļkoks (testnum, decpl); Brīdinājums (testnum + "noapaļots līdz" + Decpl + "decimāldaļām ir" + testres); Funkcija Apaļš (NBR, Dec_places) (VAR MUT \u003d MATH.POW (10, Dec_places); Atgriezties math.round (NBR * MUS) / MUS;)

Labākais un vienkāršais risinājums, ko atradu ir

Funkcijas apaļa (atgriešanās numurs (math.round (vērtība + e "+ decimāldaļskaitļi) +" E - "+ decimāldaļskaitļi););) apaļa (1.005, 2); // 1,01

Neliela variācija pieņemto atbildi. Tofixed (2) atgriež virkni, un jūs vienmēr saņemsiet divas decimāldaļas zīmes. Tas var būt nulle. Ja vēlaties nomākt galīgo nulli (-us), vienkārši dariet to:

Var atlaide \u003d + (Cena / Lollprice) .Tofixed (2));

Rediģēts: es tikko atklāju, ka tas šķiet kļūda Firefox 35.0.1, kas nozīmē, ka iepriekš minētais var dot nan dažas vērtības.
Es mainīju savu kodu

Var atlaide \u003d math.round (cena / Lollprice * 100) / 100;

Tas sniedz numuru ar divu zīmēm aiz komata. Ja jums ir nepieciešams trīs, jūs reizināt un sadalīsies 1000, un tā tālāk.
OP vēlas, lai divu decimālo izlādi vienmēr, bet, ja tofixed () ir sadalīts Firefox, vispirms ir nepieciešams to salabot.
Skatiet https://bugzilla.mozilla.org/show_bug.cgi?id\u003d1134388.

Lai iegūtu rezultātu ar divām cipariem zīmēm, jūs varat veikt šādas darbības:

Var atlaide \u003d math.round ((100 - (Cena / Clorprice) * 100) * 100) / 100;

Vērtība, kas ir jānoņem, tiek reizināta ar 100, lai saglabātu pirmos divus ciparus, tad mēs sadalām līdz 100, lai iegūtu faktisko rezultātu.

Es domāju, ka labākais veids, kā es redzēju, reizina ar 10 uz numuru skaitu, tad izgatavojiet math.round, un pēc tam beidzot sadalīt 10 pēc skaita skaita. Šeit ir vienkārša funkcija, ko es izmantoju rakstāmmašīnas tekstos:

Funkcija Roundtoxdigits (vērtība: numurs, cipari: numurs) (vērtība \u003d vērtība * math.Pow (10, cipari); vērtība \u003d math.round (vērtība); vērtība \u003d vērtība / math.Pow (10, cipari); atgriešanās vērtība; )

Vai vienkāršs JavaScript:

Funkcija Roundtoxdigitits (vērtība, cipari) (ja (! Cipari) (cipari \u003d 2;) vērtība \u003d vērtība * math.Pow (10, cipari); vērtība \u003d math.round (vērtība); vērtība \u003d vērtība / math.Pow (10 vērtība , cipari); atgriešanās vērtība;)

PIEZĪME. - Skatiet Rediģēt 4. Ja ir svarīga 3 ciparu precizitāte.

Var atlaide \u003d (cena / listprice) .Tofixed (2);

tofixed ir noapaļota uz augšu vai uz leju, atkarībā no vērtībām, kas pārsniedz 2 decimāldaļas zīmes.

Izmaiņas. Kā minēts citi, tas pārvērš rezultātu virknē. Lai izvairītos no tā:

Var atlaide \u003d + (Cena / Lollprice) .Tofixed (2));

Rediģēšana 2. - Kā minēts komentāros, šī funkcija netiek veikta ar kādu precizitāti, piemēram, 1,005 gadījumā tas atgriezīsies 1.00, nevis 1,01. Ja precizitāte ir svarīga tādā mērā, es atklāju šo atbildi: https: ///.com/a/32605063/1726511 Kas, šķiet, darbojas labi ar visām pārbaudēm, ko es mēģināju.

Viena neliela modifikācija prasa, bet iepriekš norādītā atbilde atgriež veselus skaitļus, kad tas ir noapaļots uz vienu, piemēram, 99.004 atgriezīsies 99 vietā 99,00, kas nav ideāli piemērots cenu displejam.

Rediģēt 3. - Šķiet, ka tofixed par faktisko atgriešanos vēl savīti daži skaitļi, tas ir galīgā rediģēšana, šķiet, darbojas. Geez tik daudzas atlīdzības!

Var atlaide \u003d apaļo ((cena / lollprice), 2); Funkcija Roundto (N, cipari) (ja (cipari \u003d\u003d\u003d undefined) (cipari \u003d 0;) var multiplikators \u003d math.Pow (10, cipari); n \u003d paruze ((n * multiplatorators) .tofixed (11)); var tests \u003d (math.round (n) / multiplikators); atgriešanās + (test.tofixed (cipari)););

Rediģēt 4. "Tu puiši mani nogalina." Edit 3 neizdodas par negatīviem skaitļiem, bez rakšanas, kāpēc tas ir vieglāk vienkārši veikt negatīvu skaitli pozitīvs pirms noapaļošanas, un pēc tam atgrieziet to pirms atgriešanās rezultātu.

Funkcija Roundto (N, cipari) (var negatīvs \u003d FALSE; IF (cipari \u003d\u003d\u003d undefined) (cipari \u003d 0;) ja (n< 0) { negative = true; n = n * -1; } var multiplicator = Math.pow(10, digits); n = parseFloat((n * multiplicator).toFixed(11)); n = (Math.round(n) / multiplicator).toFixed(2); if(negative) { n = (n * -1).toFixed(2); } return n; }

Ātrākais veids - ātrāk nekā tofixed ():

Divi dekalenti

x \u003d .123456 Rezultāts \u003d math.round (x * 100) / 100 // rezultāts .12

Trīs zīmes

x \u003d .123456 rezultāts \u003d math.round (x * 1000) / 1000 // rezultāts .123

Funkcija apaļas (num, dec) (Num \u003d math.round (NUM + E "+ DEC) atgriešanās numurs (NUM +" E - "+ DEC)) // kārta, lai decimāli izvēlētos: apaļas (1.3453.2)

Sveiki. Šodien, JavaScript kolonnā, mēs apskatīsim, kā iestatīt JavaScript skaitu seasolines ar peldošo punktu numuriem. Piemēram, jums ir jāatstāj 3 decimālskaitlis, parādot, vai tikai divas.

Uzdevums: JavaScript semikolu skaits

Tātad, mēs saskaramies ar uzdevumu: ir rezultāts aprēķiniem, kuros ir skaitļi pirms semikolu, un pēc komatiem. Decimāldaļu. Pieņemsim, ka rezultāts izrādījās šo 1538.9891200153. Bet, ja izejai jābūt skaitam, kas atspoguļo summu, kur banknošu daudzums ir līdz komats, un pēc - kapeikas.

Ir vairāki veidi, kā atrisināt šo uzdevumu.

1. risinājums: semikolu javascript skaits ar fiksētu metodi

tofixed ir iestrādāts JavaScript metodē, kas tiek izmantota jebkuram skaitlim, precizitāte ņem precizitātes noapaļošanu (tas ir, skaits no seasitage rakstzīmes).

VAR NUM \u003d 1538.9891200153; num_str \u003d num.tofixed (); // num_str \u003d 1538; num_str \u003d num.tofixed (2); //Num_str\u003d1538.98; num_str \u003d num.tofixed (5); //Num_str\u003d1538.98912;

Šīs funkcijas precizitātes parametram jābūt vismaz 0 (neņem negatīvas vērtības), un ne vairāk kā 20.

Jūs varat arī darīt bez mainīgā, piemēram, piemēram:

Num_str \u003d (1538.9891200153) .Tofixed (2); //Num_str\u003d1538.98;

2. risinājums: semikolu javascript skaits ar topreCision metodi

Šis risinājums ir balstīts uz to pašu iebūvēto JavaScript metodi. Šīs metodes atšķirtspēja ir tā, ka ievades parametrs nenorāda, ka nav precizitāte (semikolu skaits), bet kopējais rakstzīmju skaits (gan uz komatu un pēc tā).

VAR NUM \u003d 1538.9891200153; num_str \u003d num.toprecision (5); //Num_str\u003d1538.9; num_str \u003d num.toprecision (7); //Num_str\u003d1538.989;

Risinājums bez zīmēm pēc komata: JavaScript semikolu skaits

Ja decimālzīmēm ir jābūt pilnīgi salocītām, tas ir, ir nepieciešams apaļas daļās visā, tad jūs varat izmantot funkcijas math: apaļas, grila un grīdas.
Apaļas kārtas lielā vai mazākā pusē (atkarībā no numura). Ja vērtība pēc semikolu ir vairāk nekā puse, tad kārtas uz visu pusi, ja mazāk - mazāk. Tas ir, ja 0,51 - būs 1, ja 0,49 - 0.

Griestu - no angļu valodas. Griesti vienmēr ir noapaļoti lielākajā pusē.

Grīdas - no angļu valodas. Pāvila kārtas vienmēr mazākā pusē.

VAR NUM \u003d 1538.9891200153; num_str \u003d math.round (num); // num_str \u003d 1539; num_str \u003d math.floor (num); // num_str \u003d 1538; num_str \u003d math.ceil (num); // num_str \u003d 1539;

Tas ir viss. Es ceru, ka šī piezīme palīdzēja atrisināt uzdevumu. Ja kaut kas neizdevās - uzdot jautājumus, izmantojot zaļo pogu "Uzdot jautājumu ar speciālistu" vai komentāros.

Bieži aprēķini sniedz rezultātus, kas neatbilst vēlamo diapazonu robežām. Tā rezultātā jums ir nepieciešams izmantot JavaScript Noaparāts līdz noteiktai vērtībai.

Kāpēc apaļas numuri?

JavaScript neuzglabā veselus skaitļus, jo to vērtības ir attēlotas peldošās punktu numurus. Daudzas frakcijas nevar pārstāvēt ar numuru ar noteiktu ierobežotu skaitu semikolu, tāpēc JavaScript var radīt rezultātus, piemēram:

0.1 * 0.2; > 0.020000000000000004

Praksē tas nebūs nozīmes, jo runa ir par kļūdu 2 hinilonnē. Bet tas var ietekmēt rezultātu, strādājot ar cipariem, kas atspoguļo vārstu vērtības, procentus vai faila lielumu. Tāpēc jums ir jādara vai līdz noteiktai decimālzīmei.

Noapaļošanas cipariem

Tiek izmantotas "apdares" decimālskaitlis, tofixed () vai TOPRECISION () metodes. Viņi abi veic vienu argumentu, kas nosaka ievērojamu un preču zīmju skaitu pēc komatiem, kas jāiekļauj rezultātā:

• ja par tofixed () Arguments nav definēts, noklusējuma vērtība ir 0, tas ir, bez zīmēm pēc komatiem; Maksimālā vērtība ir 20;
• ja topreCision () nav norādīts arguments, skaits nemainās.

var randnums \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"

Piezīme

Un tofixed (), un TOPRecision atgriež noapaļotu mazo burtu pārstāvību, nevis numuru. Tas nozīmē, ka reklāmas pievienošana randiņam radīs vienošanās virkni, nevis vienu numuru:

konsole.Log (Randnum + noapaļots); \u003e "6.256"

Ja jums ir nepieciešams, lai iegūtu JavaScript noapaļo līdz simtdaļām, izmantojiet paruzeflats ():

var randnums \u003d 6.25; var noapaļoti \u003d paruze (randnum.tofixed (1)); Konsole.Log (noapaļots); \u003e 6.3.

tofixed () un topreCision () ir arī noderīgas metodes, lai atdalītu lielu skaitu semikolu. Tas ir ērti, strādājot ar skaitļiem, kas pārstāv monetārās vienības:

var wholenum \u003d 1 var dolārs \u003d wholenum.tofixed (2); Konsoles.Log (dolaras); \u003e "1.00"

Lūdzu, ņemiet vērā, ka, ja ir vairāk zīmes nekā norādītais precizitātes parametrs, topreCision izdos rezultātu zinātniskā formātā:

var num \u003d 123.435 num.toprecision (2); \u003e "1.2E + 2"

Kā izvairīties no kļūdām, kad noapaļojot decimālās frakcijas

Dažos gadījumos tiek veikta līdzfāla un topreCision JavaScript noapaļojot 5 līdz mazai pusei, ne vairāk kā vairāk:

var Numtest \u003d 1,005; numtest.tofixed (2); \u003e 1;

Iepriekšminētā piemēra rezultātā jābūt 1,01, nevis 1. Ja vēlaties izvairīties no šīs kļūdas, es iesaku izmantot eksponenciālos skaitļus:

funkciju apaļa (atgriešanās numurs (math.round (vērtība + e "+ decimāldaļskaitļi) +" E - "+ decimāldaļas);)

Pieteikums:

apaļa (1.005.2); \u003e 1,01

Ja jums ir nepieciešams vēl uzticamāks risinājums nekā noapaļošana, tas ir pieejams Mdn..

Noapaļošana ar epsilonu

Alternatīva metode JavaScript noapaļo līdz desmitdaļām tika ieviests ES6 ( pazīstams arī kā JavaScript 2015). « Mašīna epsilon»Salīdzinot divus peldošus semicolonus, nodrošina saprātīgu kļūdu ierobežojumu. Bez noapaļošanas salīdzinājumi var dot rezultātus, piemēram, šādi:

0,1 + 0,2 \u003d\u003d\u003d 0.3\u003e FALSE

Math.epsilon var izmantot funkcijā, lai iegūtu pareizu salīdzinājumu:

funkcija (x, y) (atgriešanās math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

Funkcija aizņem divus argumentus: Viens satur aprēķinus, otro paredzamo (noapaļoto) rezultātu. Tā atgriež salīdzinājumu šiem diviem parametriem:

(0.1 + 0,2, 0.3)\u003e TRUE

Visi mūsdienu pārlūkprogrammas atbalsta ES6 matemātiskās funkcijas. Bet, ja jums ir nepieciešams sniegt atbalstu vecajās pārlūkprogrammās, jums ir jāizmanto Polelfa.

Decimālo skaitļu atdalīšana

Visas iepriekš izklāstītās metodes JavaScript noapaļo līdz desmitdaļām. Lai samazinātu pozitīvu skaitu līdz divām vietām pēc komatiem, reiziniet to 100, sile atkal, un pēc tam iegūtais rezultāts ir sadalīts ar 100, jums ir nepieciešams:

funkcija saīsināts (num) (atgriešanās math.trunc (num * 100) / 100;) saīsināts (3.1416)\u003e 3.14

Ja kaut kas ir nepieciešams elastīgāks, varat izmantot šķelto operatoru:

funkcija saīsināts (var numpowerconverter \u003d math.Pow (10, decimalples); atgriezties ~~ (num * numpowerconverter) / numpowerconverter;);

Izmantojot:

vAR Randint \u003d 35.874993; Saīsināts (izlases, 3); \u003e 35.874.

Noapaļošana līdz tuvākajam numuram

Īstenot JavaScript noapaļo uz visu, Math.round () tiek izmantots:

Math.round (4.3)\u003e 4 Math.round (4.5)\u003e 5

Pieraksti to " pusvērtības", Piemēram, .5, noapaļoti uz augšu.

Noapaļojot līdz tuvākajam veselajam skaitlim

Ja vēlaties noapaļot mazākā pusē, izmantojiet Math.Floor () metodi:

Math.floor (42.23); \u003e 42 math.floor (36,93); \u003e 36.

Noapaļošana "uz leju" ir viens virziens visiem numuriem, tostarp negatīviem. To var pārstāvēt kā debesskrāpis ar bezgalīgu grīdu skaitu, tostarp zem pamata līmeņa ( pārstāvot negatīvos skaitļus). Ja esat lifts starp pagraba grīdām 2 un 3 ( kas atbilst vērtībai -2,5), Math.floor piegādās jūs uz grīdas -3:

Math.floor (-2,5); \u003e -3.

Ja jūs vēlaties, lai izvairītos no tā, izmantojiet JavaScript matemātikas noapaļošanu, izmantojot math.trunc (), kas tiek atbalstīta visās mūsdienu pārlūkprogrammās (izņemot Ti / mala):

Math.trunch (-41.43); \u003e -41

MDN nodrošina arī trīs līniju poligoniem, lai nodrošinātu math.trunch atbalstu vecajās pārlūkprogrammās un IE / EDGE.

Noapaļošana līdz tuvākajam veselajam skaitlim

Ja vēlaties noapaļot uz leju decimāldaļu uz augšu, izmantojiet math.ceil. Šīs metodes darbību var pārstāvēt arī kā bezgalīgs lifts: math.ceil vienmēr ir laimīgs "uz augšu", neatkarīgi no tā, vai skaits ir negatīvs vai pozitīvs:

Math.ceil (42.23); \u003e 43 math.ceil (36,93); \u003e 37 math.ceil (-36,93); -36

Noapaļojot līdz tuvākajam skaitlim

Ja jums ir nepieciešams apaļas vērtību uz tuvāko numuru, vairākus 5, izveidot funkciju, kas sadala numuru uz 5, kārtas to, un pēc tam reizina rezultātu ar tādu pašu vērtību:

funkcija Roodto5 (Num) (Atgriezties math.round (Num / 5) * 5;)

Izmantojot:

roundto5 (11); \u003e 10.

Ja vēlaties izpildīt JavaScript noapaļo līdz divām rakstzīmēm, varat pārsūtīt funkcijas kā sākotnējo numuru un daudzveidību:

funkcija apaļš (num, vairāki) (atgriezt math.round (num / vairāki) * vairāki;)

Lai izmantotu funkciju, ieslēdziet noapaļoto skaitu un daudzveidību savā aicinājumā:

var iniciatīvas \u003d 11; var vairāki \u003d 10; Apaļš (iniciatīva, vairāki); \u003e 10;

Apaļas vērtības tikai lielā vai mazākā virzienā, nomainiet apaļā funkciju uz griestiem vai grīdas.

Saistošs diapazons

Dažreiz jums ir nepieciešams iegūt vērtību x, kas būtu noteiktā diapazonā. Piemēram, jums ir nepieciešama vērtība no 1 līdz 100, bet mēs iegūstam vērtību 123. Lai to labotu, varat izmantot min () ( atgriež mazākos skaitļus) un maks atgriež maksimālo pieļaujamo numuru).

Izmantojot:

var lowbound \u003d 1; var highbound \u003d 100; Var Numinput \u003d 123; var nostiprināt \u003d math.max (lowbound, math.min (Numinput, Highbound)); Konsoles.Log (nostiprināts); \u003e 100;

Varat izveidot funkciju vai paplašinājuma klases numuru.

Ļoti bieži JavaScript aprēķini dod ne gluži vēlamos rezultātus. Protams, mēs varam darīt ar cipariem neko - noapaļojot lielā vai mazākā pusē, iestatiet diapazonu, nogrieziet nevajadzīgus numurus uz noteiktu skaitu ciparu aiz komata, tas viss ir atkarīgs no tā, ko jūs vēlaties darīt nākotnē ar šo numuru.

Kāpēc jums ir nepieciešams noapaļojums?

Viens no JavaScript aspektiem ir tas, ka tas neuzglabā veselus skaitļus, mēs uzreiz strādājam ar peldošiem punktu numuriem. Tas kopā ar faktu, ka daudzas frakcionētas vērtības nevar izteikt ar galīgo skaitu decimāldaļām, mēs varam saņemt šādus rezultātus JavaScript:

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Praktiskiem mērķiem, šī neprecizitāte nav nozīmes, mūsu gadījumā mēs runājam par kļūdu Quintillion dolāros, tomēr kāds var vilties. Mēs varam iegūt nedaudz dīvainu rezultātu un strādājot ar cipariem, kas ir vārstu vērtības, procenti vai failu izmēri. Lai labotu šīs neprecizitātes, mums vienkārši ir jāspēj apiet rezultātus, bet tas ir pietiekami, lai izveidotu decimāldaļu precizitāti.

Numuru noapaļošanai ir praktiska pielietošana, mēs varam manipulēt ar numuru noteiktā diapazonā, piemēram, mēs vēlamies apiet vērtību līdz tuvākajam veselajam skaitlim, nevis strādāt tikai ar cipariem.

Noapaļošanas cipariem

Lai noņemtu decimālskaitli, izmantojiet tofixed vai topreecision metodi. Abi tiek ņemti ar vienu argumentu, kas nosaka, attiecīgi, cik daudz nozīmīgu skaitļu (t.i., kopējais skaita skaita skaita skaita skaita skaitu) vai pēc semikola (daudzuma pēc decimālā punkta) jāietver rezultāts:

1. Ja arguments nav definēts kāfixed (), pēc tam pēc noklusējuma tas būs nulle, kas nozīmē 0 zīmes pēc komata, argumentam ir maksimālā vērtība, kas vienāda ar 20.
2. Ja arguments nav noteikts topreCision, numurs paliek neskarts

Ļaujiet Randnum \u003d 6.25; randnum.tofixed (); \u003e "6" math.pi.toprecision (1); \u003e "3" Randnum \u003d 87.335; Randnum.tofixed (2); \u003e "87.33" Randnum \u003d 87.337; Randnum.toprecision (3); \u003e "87.3"
Gan fiksēts (), gan topreCision () metodes atgriež virknes attēlojumu rezultātu, nevis numuru. Tas nozīmē, ka, summējot noapaļoto vērtību ar Randnum, tiks veikti savienojuma rindas, nevis skaitļu summa:

Ļaujiet Randnum \u003d 6.25; Let noapaļoti \u003d randnum.tofixed (); // "6" konsole.Log (Randnum + noapaļots); \u003e "6.256"
Ja vēlaties rezultātu, lai iegūtu ciparu datu tipu, jums būs nepieciešams pieteikties parefloat:

Ļaujiet Randnum \u003d 6.25; Laist noapaļoti \u003d paruzeflats (randnum.tofixed (1)); Konsole.Log (noapaļots); \u003e 6.3.
Lūdzu, ņemiet vērā, ka 5 vērtības ir noapaļotas, izņemot retos gadījumus.

Tofixed () un TOPRECISION () metodes ir noderīgas, jo tās ne tikai nogrieziet frakciju daļu, bet arī papildina zīmes pēc komatiem, kas ir ērta, strādājot ar valūtu:

Ļaujiet wholenum \u003d 1 ļauj dolārds \u003d wholenum.tofixed (2); Konsoles.Log (dolaras); \u003e "1.00"
Nosacījums Ņemiet vērā, ka topreCision dos rezultātu eksponenciālā ierakstā, ja skaitlis veseliem skaitļiem ir lielāks par pašu precizitāti:

Ļaujiet num \u003d 123.435 num.toprecision (2); \u003e "1.2E + 2"

Kā izvairīties no noapaļošanas kļūdas ar decimāliem skaitļiem

Dažos gadījumos, tofixed un topreCision kārtas vērtību 5 līdz mazāka puse, un lielā mērā:

Ļaujiet NUMTEST \u003d 1,005; numtest.tofixed (2); \u003e "1.00"
Iepriekš aprēķina rezultāts bija 1,01, nevis 1. Ja vēlaties izvairīties no līdzīgas kļūdas, mēs varam izmantot Jack L Moore ierosināto risinājumu, kas izmanto eksponenciālos skaitļus, lai aprēķinātu:

Funkciju apaļa (atgriešanās numurs (math.round (vērtība + e "+ decimāldaļskaitļi) +" E - "+ decimāldaļas);)
Tagad:

Apaļa (1.005.2); \u003e 1,01
Ja vēlaties ticamāku risinājumu nekā iepriekš redzamais šķīdums, jūs varat doties uz MDN.

Mašīna epsilona noapaļošana

EM,6 tika ieviesta alternatīva decimālo skaitļu noapaļošanas metode. Mašīna epsilona noapaļošana nodrošina saprātīgu kļūdu ierobežojumu, salīdzinot divus peldošos punktu numurus. Bez noapaļošanas salīdzinājumi var dot rezultātus, piemēram, šādi:

0,1 + 0,2 \u003d\u003d\u003d 0.3\u003e FALSE
Mēs izmantojam math.epsilon mūsu funkciju, lai iegūtu pareizu salīdzinājumu:

Funkcija (x, y) (atgriešanās math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Funkcija aizņem divus argumentus: pirmais - pašreizējais aprēķins, otrais ir paredzamais rezultāts. Tā atgriež divu salīdzinājumu:

(0.1 + 0,2, 0.3)\u003e TRUE
Visas mūsdienu pārlūkprogrammas jau atbalsta ES6 matemātiskās funkcijas, bet, ja vēlaties saņemt atbalstu pārlūkprogrammās, piemēram, 11, izmantojiet polildiņus.

Samazinot frakcionētu daļu

Visas iepriekš izklāstītās metodes spēj noapaļot līdz decimāldaļām. Lai vienkārši nogrieztu numuru līdz divām zīmēm pēc komatiem, vispirms to vispirms reiziniet to par 100, un pēc tam iegūtais rezultāts jau ir sadalīts ar 100:

Funkcija saīsināts (num) (atgriešanās math.trunc (num * 100) / 100;) saīsināts (3.1416)\u003e 3.14
Ja vēlaties pielāgot metodi jebkuram semikolu skaitam, varat izmantot dubultu bitty noliegumu:

Funkcija saīsināts (ļaujiet numpowerconverter \u003d math.Pow (10, decimalplaces); atgriezties ~~ (numpowerconverter) / numpowerconverter;)
Tagad:

Ļaujiet izlasei \u003d 35.874993; Saīsināts (izlases, 3); \u003e 35.874.

Noapaļošana līdz tuvākajam numuram

Lai apaļo decimālo skaitu tuvākajam skaitlim vairāk vai mazākā pusē, atkarībā no tā, ko mēs esam vistuvāk, izmantot math.round ():

Math.round (4.3)\u003e 4 Math.round (4.5)\u003e 5
Lūdzu, ņemiet vērā, ka "puse no vērtības", 0,5 ir noapaļota lielā virzienā atbilstoši matemātikas noteikumiem.

Noapaļojot līdz mazākam līdz tuvākajam veselajam skaitlim

Ja vēlaties vienmēr noapaļot pie mazākā pusē, izmantojiet math.floor:

Math.floor (42.23); \u003e 42 math.floor (36,93); \u003e 36.
Lūdzu, ņemiet vērā, ka noapaļošana mazākā pusē darbiem visiem numuriem, tostarp negatīviem. Iedomājieties debesskrāpi ar bezgalīgu grīdu skaitu, ieskaitot zema līmeņa grīdas (kas atspoguļo negatīvos skaitļus). Ja esat lifātā zemākā līmenī starp 2 un 3 (kas ir vērtība -2,5), math.floor piegādās jūs uz -3:

Math.floor (-2,5); \u003e -3.
Bet, ja vēlaties izvairīties no līdzīgas situācijas, izmantojiet math.trunc, atbalstot visās mūsdienu pārlūkprogrammās (izņemot IE / EDGE):

Math.trunch (-41.43); \u003e -41
Jūs atradīsiet polisbert uz MDN, lai nodrošinātu math.trunch atbalstu pārlūkprogrammās un IE / EDGE.

Noapaļojot līdz tuvākajam veselajam skaitlim

No otras puses, ja jums vienmēr ir nepieciešams, lai apaļo līdz lielākajiem, izmantot math.ceil. Atkal, atcerieties nebeidzamo liftu: math.ceil vienmēr iet uz augšu, neatkarīgi no tā, vai numurs ir negatīvs vai nav:

Math.ceil (42.23); \u003e 43 math.ceil (36,93); \u003e 37 math.ceil (-36,93); \u003e -36

Noapaļošana uz lielāku / mazāku skaitu

Ja mēs vēlamies noapaļot līdz tuvākajam skaitlim, vairākus 5, vienkāršākais veids, kā izveidot funkciju, kas sadala numuru 5 kārtās, un pēc tam to reizina to pašu summu:

Funkcija Roodto5 (Num) (Atgriezties math.round (Num / 5) * 5;)
Tagad:

Roundto5 (11); \u003e 10.
Ja vēlaties noapaļot līdz vairākām jūsu vērtībām, mēs izmantojam vispārīgāku funkciju, nododot sākotnējo vērtību un vairākus to:

Funkcija apaļš (num, vairāki) (atgriezt math.round (num / vairāki) * vairāki;)
Tagad:

Ļaujiet iniciatīvai \u003d 11; Ļaujiet vairākiem \u003d 10; Apaļš (iniciatīva, vairāki); \u003e 10;

Nosaka numuru diapazonā

Ir daudz gadījumu, kad mēs vēlamies iegūt vērtību X, kas atrodas diapazonā. Piemēram, mums var būt nepieciešama vērtība no 1 līdz 100, bet tajā pašā laikā mēs saņēmām vērtību 123. Lai to labotu, mēs varam izmantot minimālo (atgriež mazāko skaitu skaitu) un maksimālo summu ( atgriež lielākos no vairākiem skaitļiem). Mūsu piemērā diapazons no 1 līdz 100:

Ļaujiet Lowbound \u003d 1; Ļaujiet Highbound \u003d 100; Ļaujiet Numinput \u003d 123; Ļaujiet nostiprināt \u003d math.max (lowbound, math.min (Numinput, Highbound)); Konsoles.Log (nostiprināts); \u003e 100;
Atkal, mēs varam atkārtoti izmantot darbību un ietiniet to funkcijā, mēs izmantojam Daniel X. Moore ierosināto risinājumu:

Numurs.prototipe.clamp \u003d funkcija (min, max) (atgriešanās math.min (math.max (tas, min), max););
Tagad:

Numinput.clamp (lowbound, highbound); \u003e 100;

Gausa noapaļošana

Gausa noapaļošana, kas pazīstama arī kā bankas noapaļošana, ir tas, ka šīs lietas noapaļošana notiek tuvākajā melnā krāsā. Šī noapaļošanas metode darbojas bez statistiskas kļūdas. Labākais risinājums tika ierosināts ar THP leju:

Funkcija Gaussround (Ļaujiet D \u003d decimalples || 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; }
Tagad:

Gaussround (2.5)\u003e 2 Gausa (3.5)\u003e 4 Gausa (2,57,1)\u003e 2.6
Decimālā zīme CSS:

Tā kā JavaScript bieži izmanto, lai izveidotu pozicionālo HTML elementu konversijas, jūs varat brīnīties, kas notiek, ja mēs radām decimālās vērtības mūsu vienumiem:

#Box (platums: 63.667731993PX;)
Laba ziņa ir tā, ka mūsdienu pārlūkprogrammas ņems vērā decimālvērtības bloka modelī, tostarp procentos vai pikseļu mērvienībās.

Šķirošana

Ļoti bieži mums ir jānorāda visi elementi, piemēram, mums ir virkne spēļu ierakstus, bet tie ir jāorganizē kā dalībnieku dilstošā secībā. Diemžēl standarta kārtošanas () metodei ir daži pārsteidzoši ierobežojumi: tas darbojas labi ar bieži lieto angļu vārdiem, bet nekavējoties pārtraukumiem tikšanās ar skaitļiem, unikālām rakstzīmēm vai vārdiem lielajiem burtiem.

Kārtot alfabētiskā secībā

Šķiet, ka masīvs šķirošanas alfabētiski vajadzētu būt vienkāršākajam uzdevumam:

Ļaujiet augļiem \u003d ["Butternut Squash", "aprikožu", "Cantaloupe"]; fruit.sort (); \u003e "Aprikožu", "Butternut Squash", "Cantaloupe"]
Neskatoties uz to, mēs saskaramies ar problēmu, tiklīdz viens no elementiem ir lielajos gadījumos:

Ļaujiet augļiem \u003d ["Butternut Squash", "Aprot", "Cantalope"]; fruit.sort (); \u003e "Cantaloupe", "Aprot", "Butternut Squash"]
Tas ir saistīts ar to, ka pēc noklusējuma šķirotājs salīdzina pirmo simbolu, kas iesniegts Unicode. Unicode ir unikāls kods jebkuram simbolam, neatkarīgi no platformas neatkarīgi no programmas, neatkarīgi no valodas. Piemēram, ja jūs skatāties caur koda tabulu, "A" raksturs ir u + 0061 (heksadecimālā sistēmā 0x61), bet simbolam "C" ir koda u + 0043 (0x43), kas notiek pirms Unicode tabulā nekā simbols "A".

Lai kārtotu masīvu, kas var saturēt dažus pirmos burtu jauktos reģistrus, mums ir jāpārvērš visi vienumi uz laiku zemākajā reģistrā, vai noteikt jūsu šķirošanas rīkojumu, izmantojot vietējo meklēšanu () metodi ar dažiem argumentiem. Parasti šādā gadījumā labāk ir nekavējoties izveidot funkciju atkārtotai lietošanai:

Funkcija Alphasort (ARR) (Atgriezties A.Localecompare (B, EN ", (" Sensitititivs ":" Base "));)), ļaujiet augļiem \u003d [" Butternut skvošs "," aprikožu "," cantaloupe "]; Alphasort (augļi)\u003e
Ja jūs vēlaties saņemt masīvu, kas sakārtota apgrieztā alfabētiskā secībā, vienkārši nomainiet A un B pozīciju funkcijai:

Funkcija Alphasort (ARR) (atgriešanās B.Localecompare (A, EN ", (" Sensitititive ":" bāze ")));) Ļaujiet augļiem \u003d [" Butternut skvošs "," aprikožu "," cantaloupe "]; Alphasort (augļi)\u003e ["Cantaloupe", "Butternut Squash", "aprikožu"]
Ir vērts pievērst uzmanību tam, ka vietējā meklēšana tiek izmantota ar argumentiem, joprojām ir jāatceras, ka to atbalsta IE11 +, vecākiem, ti, versijām, mēs varam to izmantot bez argumentiem un zemākajā reģistrā:

Funkcija Tautasorts (ARR) (atgriešanās A.Tolowercase (). Localecompare (B.Tolowercase ());));) Ļaujiet augļiem \u003d ["Butternut Squash", "Aprikožu", "Cantaloupe"]; TautasIort\u003e [aprikožu, "Butternut Squash", "Cantaloupe"]

Skaitliskā šķirošana

Tas viss neattiecas uz piemēru, no kura mēs runājām par iepriekš minēto spēļu ierakstu klāstu. Ar dažiem ciparu masīviem, šķirošana darbojas tikai perfekti, bet kādā brīdī rezultāts var būt neparedzams:

Ļaujiet Highscores \u003d; highscores.sort (); \u003e
Fakts ir tāds, ka šāda veida () metode rada leksikogrāfisko salīdzinājumu: un tas nozīmē, ka skaitļi tiks pārvērsti uz virkni, un salīdzinājumi tiks veikti atkal, kartējot šīs virknes pirmo raksturu Unicode tabulas simbolos. Tāpēc mums ir jānosaka jūsu kārtošanas kārtība:

Ļaujiet Highscores \u003d; Highscores.sort (atgriešanās A - B;)); \u003e
Atkal, lai kārtotu numurus apgrieztā secībā, mainīt pozīcijas A un B funkciju.

Kārtot JSON līdzīgu struktūru

Un, visbeidzot, ja mums ir JSON līdzīga datu struktūra, kas pārstāvēta kā spēļu ierakstu klāsts:

Ļaujiet rādītājiem \u003d [("Vārds": "Daniel", "Score": 21768), ("Vārds": "Michael", "Score": 33579), ("Vārds": "Alison", "Score": 38395 )];
ES6 + varat izmantot bultiņas funkcijas:

Rezultāti.Sort ((A, b) \u003d\u003e B.Score - A.Score));
Veciem pārlūkiem, kuriem nav šāda atbalsta:

Rādītāji.Sort (atgriešanās A.Score - B.Score));
Kā jūs varat redzēt, šķirošana JavaScript ir diezgan acīmredzama lieta, es ceru, ka šie piemēri padarīs to viegli dzīvi.

Darbs ar enerģijas funkcijām

Vingrinājums ir operācija, kas sākotnēji definēta kā rezultātā daudzkārtēju reizināšanu dabas numuru uz sevi, kvadrātveida sakne numuru A ir skaitlis, kas piešķirts laukumam. Ar šīm funkcijām mēs varētu pastāvīgi baudīt ikdienas dzīvē matemātikas nodarbībās, tostarp aprēķinot teritorijas, apjomus vai pat fizisko modelēšanu.

JavaScript, jaudas funkcija ir pārstāvēta kā math.Pow (), jaunajā ES7 standartā, jaunais vingrošanas operators tika prezentēts grādu - "* *".

Uzrāda grādu

Lai izveidotu numuru N-Uy grādos, izmantojiet math.Pow () funkciju, kur pirmais arguments ir skaitlis, kas tiks uzcelts grādu, otrais arguments ir rādītājs grādu:

Math.Pow (3.2.)\u003e 9
Šāda ieraksta veids nozīmē 3 kvadrātmetru vai 3 × 3, kas izraisa rezultātu 9. citu piemēru, protams, var norādīt:

Math.pow (5.3); \u003e 125.
Tas ir, 5 Kubā vai 5 × 5 × 5, vienāds ar 125.

Ecmascript 7 ir šāda JavaScript versija, principā, mēs varam izmantot jauno ierosināto vingrošanas operatoru līdz līmenim - * *, šāda veida ierakstu var būt vairāk vizuālu:

3 ** 2 > 9
Šobrīd atbalsts šim operatoram ir diezgan ierobežots, tāpēc nav ieteicams to izmantot.

Spēcīgā funkcija var būt noderīga dažādās situācijās. Vienkāršs piemērs, aprēķinot sekunžu skaitu stundā: math.pow (60.2).

Kvadrātveida un kubiskā sakne

Math.sqrt () un math.cbrt () ir pretēji math.Pow () funkcijām. Kā mēs atceramies, numura kvadrātsakne ir numurs, kas dod a, kad kvadrāts ir uzcelts.

Math.sqrt (9)\u003e 3
Tajā pašā laikā, cubic sakne numuru A ir skaitlis, kas dod a, kad kubs ir uzcelts.

Math.cbrt (125)\u003e 5
Math.CBRT () tika ieviesta JavaScript specifikācijā nesen, un tāpēc atbalstīja tikai mūsdienu pārlūkprogrammās: Chrome 38+, Firefox un Opera 25+ un Safari 7.1+. Jūs pamanīsiet, ka šajā sarakstā trūkst Internet Explorer, tomēr jūs atradīsiet poliscilu uz MDN.

Piemēri

Protams, mēs varam izmantot un ne vesels skaitlis vienā no šīm funkcijām:

Math.pow (1.25, 2); \u003e 1.5625 Math.CBRT (56,57)\u003e 3.8387991760286138
Lūdzu, ņemiet vērā, ka tas darbojas diezgan labi, izmantojot argumentu negatīvās vērtības:

Math.Pow (-5.2)\u003e 25 math.Pow (10, -2)\u003e 0.01
Tomēr kvadrātsaknei tas nedarbosies:

Math.sqrt (-9)\u003e Nan
No matemātiskās analīzes mēs zinām, ka iedomātā numurā viņi saprot kvadrātveida saknes no negatīviem skaitļiem. Un tas var mūs novest pie cita tehnika, kurā strādājat ar sarežģītiem skaitļiem, bet tas ir vēl viens stāsts.

Jūs varat izmantot frakcionētās vērtības math.Pow (), lai atrastu kvadrātveida un kubisko sakņu numurus. Kvadrātsakne izmanto rādītāju 0,5:

Math.pow (5, 0.5); // \u003d math.sqrt (5) \u003d 5 ** (1/2)\u003e 2.23606797749979
Tomēr, ņemot vērā peldošo punktu kaprīzēm, jūs nevarat precīzi uzņemties pareizo rezultātu:

Math.Pow (2.23606797749979,2)\u003e 5.0000000000001
Šādās situācijās, jums būs jāizmanto cut-off zīmes numuros vai noapaļojot uz jebkuru vērtību.

Daži, nesaprotamiem iemesliem JavaScript sajauc Math.Pow () funkciju ar math.exp (), kas ir eksponenciālā funkcija attiecībā uz cipariem kopumā. Piezīme: angļu valodā, "eksponents" indikators tiek tulkots kā "eksponents", tāpēc tas drīzāk attiecas uz angļu valodā runājošo, lai gan ir alternatīvi indikatoru nosaukumi, piemēram, indekss, jauda.

Matemātiskās konstantes

Darbs ar matemātiku JavaScript veicina vairākas iebūvētas konstantes. Šīs konstantes ir matemātikas objekta īpašības. Ir vērts atzīmēt, ka konstantes ir uzrakstītas lielajos burājos, nevis kamele.

Math.abs, Parseint, Parsefloat

Darbs ar cipariem JavaScript var būt daudz sarežģītāka nekā šķiet. Iegūtās vērtības ne vienmēr iekļūst gaidāmajos diapazonos, dažreiz rezultāts var nebūt vispār par to, ko mēs gaidījām.

Math.abs ()

Math.abs () metode atgriež skaitļa absolūto vērtību, kas mums atgādina to pašu A numura matemātisko funkciju.

Ļaujiet Newval \u003d -57,64; Math.abs (Newval); \u003e 57.64
Math.abs (0) Vienmēr atgriež nulli, bet, ja jūs ievietojat mīnusa zīmi pirms -Math.abs funkcijas (num), mēs vienmēr būs negatīva vērtība.

Math.abs (0); \u003e -0

parpsint ()

Mēs zinām, ka JavaScript saprot, ka "15" ir virkne, nevis numurs, un, piemēram, parsējot CSS īpašības ar JavaScript ar jebkuru vērtību no nesagatavotas masīva, mūsu rezultāti var būt neparedzami. Mēs varētu nokļūt ieejas līnijā, kas pārstāvēta kā "17px", un mums tas nav reti. Jautājums ir par to, kā pārvērst šo virkni faktiskajā vērtībā un izmantot to turpmākos aprēķinos.

Syntax: Parseint (string, RADIX);

Parseint funkcija pārvērš pirmo argumentu, kas nosūtīts tai stīgu tipa, interpretē to un atgriež veselu skaitli vai nan vērtību. Rezultāts (ja ne Nan) ir vesels skaitlis un atspoguļo pirmo argumentu (virkni), kas tiek uzskatīta par numuru norādītajā numuru sistēmā (RADIX). Piemēram, bāze 10 norāda uz konversiju no decimālā numura, 8 - oktāls, 16 heksadecimāls un tā tālāk. Ja bāze ir lielāka par 10, tad burti tiek izmantoti, lai apzīmētu skaitļus vairāk nekā 9. Piemēram, heksadecimālajiem numuriem (bāze 16), burti no A līdz F.

Apsveriet piemēru darbam ar CSS īpašībām, kur tradicionāli runājot, mēs varam saņemt šādu vērtību:

Ļaujiet Elem \u003d Document.Body; Ļaujiet Centerpoint \u003d Window.GetComputedStyle (ELEM) .Transformorigin; \u003e "454px 2087.19px"
Mēs varam sadalīt vērtības uz vietas:

Ļaujiet centriem \u003d Centerpoint.Split ("); \u003e ["454px", "2087.19px"]
Tomēr katrs elements joprojām ir virkne, mēs varam atbrīvoties no tā, piemērojot mūsu funkciju:

Ļaujiet Centerx \u003d prenteint (centri, 10); \u003e 454 Ļaujiet centriem \u003d prenteint (centri, 10); \u003e 2087.
Kā jūs varat redzēt, mēs norādām skaitu skaitu, uz kuru skaitlis tiks pārvērsts, kura šis parametrs nav obligāts, bet ir ieteicams to izmantot, ja jūs nezināt, kura līnija dosies uz ievadi.

parsefloats ()

No iepriekš minētā parauga jūs, iespējams, pamanījāt, ka parseint izmetiet frakciju daļu. Mūsu gadījumā Parsefloats var strādāt ar peldošām punktu numuriem. Atkal, tas var būt noderīgi, analizējot CSS un citus uzdevumus, jo īpaši, strādājot ar peldošo punktu procentos.

Syntax: Parsefloats (virkne)

Ļaujiet FP \u003d "33.33333%"; Konsoles.Log (paruze (fP)); \u003e 33.33333
Lūdzu, ņemiet vērā, ka nav otrā argumenta parefloat sintaksē.

Mēs saprotam, ka iepsint () un paruze () ir ļoti noderīgas iezīmes, ir svarīgi ņemt vērā, ka nav nepieciešams veikt bez kļūdām, tāpēc ir nepieciešams pārbaudīt diapazonu gaidāmo vērtību un galu galā analizē rezultātu lai nodrošinātu, ka vērtības ir pareizas.
Nosūtīt anonīmi