Javascript noapaļošana līdz tuvākajam veselam skaitlim. Matemātikas objekts javascript — apaļas, griestu un grīdas metodes — daļskaitļu noapaļošana

25.11.2023

Bieži vien aprēķinu rezultāts ir skaitlis ar lielu skaitu zīmju aiz komata. Ja šo skaitli izmanto turpmākiem aprēķiniem, tad to var atstāt šajā formā. Bet dažreiz skaitlis ir jānoapaļo, piemēram, lai parādītu lapā. JavaScript noapaļo skaitļus, izmantojot vairākas metodes.

Metode Math.round() noapaļo vērtību līdz veselam skaitlim.

Math.round (skaitlis)

Skaitļi tiek noapaļoti saskaņā ar matemātikas likumiem. Tas ir, ja aiz komata ir skaitlis no 0 līdz 4, tad daļdaļa tiek vienkārši izmesta. Un, ja aiz komata ir skaitlis no 5 līdz 9, tad daļdaļa tiek izmesta, un viena tiek pievienota visai daļai. piemērs:

JavaScript:

Ir vēl divas metodes, kas noapaļo skaitli līdz veselam skaitlim. Metode Math.floor() noapaļo uz leju. Tas atmet skaitļa daļējo daļu. Un Math.ceil() metode noapaļo uz augšu. Tas atmet daļējo daļu un pievieno vienu visai daļai. Piemērs:

Protams, 5 - (-2) ir 5+2. Neaizmirstiet, ka šajā formulā jūs neiegūsit skaitli 5. Maksimālā summa būs 4,999999999. Iegūtās vērtības var noapaļot līdz vajadzīgajai precizitātei.

Ja nepieciešami tikai veseli skaitļi, iegūtās vērtības var noapaļot uz leju līdz tuvākajam veselajam skaitlim. Viens jāpieskaita līdz maksimumam, lai arī šis maksimums būtu iespējams. Formula izskatās šādi:

vesels skaitlis = Math.floor(min + Math.random() * (maks. + 1 - min)

Drukāsim skaitļus no 10 līdz 15:

20
21
22
23
24

ja (i=1; i= (lielāks vai vienāds ar), 3); //false console.log(5>=3); //tiesa

Salīdzinot skaitļus ar daļēju daļu, ir jāņem vērā kļūdas, kas var rasties šo aprēķinu laikā.

Piemēram, JavaScript skaitļu summa (0,2 + 0,4) nav vienāda ar 0,6:

Console.log((0,2+0,4)==0,6); //nepatiess

Kļūdas rodas tāpēc, ka visi aprēķini tiek veikti ar datoru vai citu elektroniskā ierīce ražo 2 skaitļu sistēmā. Tie. Pirms jebkuru darbību veikšanas datoram vispirms ir jāpārvērš izteiksmē uzrādītie skaitļi 2. skaitļu sistēmā. Bet ne katru daļskaitli aiz komata var precīzi attēlot 2. skaitļu sistēmā.

Piemēram, skaitlis 0,25 10 collas binārā sistēma precīzi konvertēts.

0,125 × 2 = 0,25 | 0 0,25 × 2 = 0,5 | 0 0,5 × 2 = 1 | 1 0,125 10 = 0,001 2

Piemēram, skaitli 0,2 10 var pārvērst sistēmā 2 tikai ar noteiktu precizitāti:

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

Rezultātā šīs kļūdas ietekmēs divu skaitļu summas aprēķinu un salīdzināšanas rezultātus. Tie. Izrādās, ka JavaScript faktiski redzēs šo ierakstu šādi:

0.6000000000000001==0.6

Aprēķinot vai attēlojot skaitļus ar daļdaļām, vienmēr ir jānorāda precizitāte, ar kādu vēlaties to izdarīt.

Piemēram, salīdziniet skaitļus līdz 2 zīmēm aiz komata, izmantojot metodes toFixed() un toPrecision():

//metode toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //method toPrecision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //tiesa

Matemātikas pamatoperācijas

JavaScript ir šādi matemātiskie operatori: + (saskaitīšana), - (atņemšana), * (reizināšana), / (dalīšana), % (modulo), ++ (palielināt vērtību par 1), -- (samazināt vērtību par 1).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, t.i. 6:3=2 => 6-3*2 => atpūta(0) 5%2 //1, t.i. 5:2=2(.5) => 5-2*2 => atpūta(1) 7,3%2 //1,3, t.i. 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //operācijas % rezultāta zīme ir vienāda ar pirmās vērtības zīmi -9%2.5 //-1.5 , t.i. 9:2,5=3(,6) => 9-2,5*3 => atpūta(1,5) -9%-2,5 //-1,5, t.i. 9:2.5=3(.6) => 9-2.5*3 => atpūta(1.5) -2%5 //-2, t.i. 2:5=0(.4) => 2-5*0 => atpūta(2) x = 3; konsole.log(x++); //izvada 3, tad iestata 4 console.log(x); //4 x = 3; konsole.log(++x); //iestata 4 un izvada x = 5; konsole.log(x--); //izvada 5, tad iestata 4 console.log(x); //4 x = 5; konsole.log(--x); //iestata 4 un izvada Turklāt JavaScript ir kombinēti operatori: 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).

Ļoti bieži aprēķini JavaScript nesniedz tieši tādus rezultātus, kādus mēs vēlamies. Protams, ar cipariem varam darīt, ko vien vēlamies – noapaļot uz augšu vai uz leju, iestatīt diapazonus, nogriezt nevajadzīgos skaitļus līdz noteiktam cipariem aiz komata, tas viss ir atkarīgs no tā, ko ar šo ciparu vēlaties darīt turpmāk.

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Kāpēc ir nepieciešama noapaļošana?

Viens no interesantajiem JavaScript aspektiem ir tas, ka tajā faktiski netiek saglabāti veseli skaitļi, mēs strādājam uzreiz ar peldošā komata skaitļiem. Tas, apvienojumā ar faktu, ka daudzas daļskaitļu vērtības nevar izteikt ar ierobežotu skaitu zīmju aiz komata, JavaScript mēs varam iegūt šādus rezultātus:

Praktiskiem nolūkiem šai neprecizitātei nav nozīmes, mūsu gadījumā mēs runājam par kļūdu kvintiljonos daļās, tomēr tas dažus var pievilt. Mēs varam iegūt arī dīvainus rezultātus, strādājot ar skaitļiem, kas apzīmē valūtas, procentus vai failu izmērus. Lai šīs neprecizitātes labotu, mums vienkārši jāspēj noapaļot rezultātus, un pietiek ar decimāldaļas precizitātes iestatīšanu. Skaitļu noapaļošanai ir praktisks pielietojums, mēs varam manipulēt ar skaitli noteiktā diapazonā, piemēram, mēs vēlamies noapaļot vērtību līdz tuvākajam veselajam skaitlim, nevis strādāt tikai ar decimāldaļu. Decimālskaitļu noapaļošana Lai apgrieztu decimāldaļu, izmantojiet toFixed vai toPrecision metodi. Abi izmanto vienu argumentu, kas attiecīgi nosaka, cik

nozīmīgi skaitļi (t.i., kopējais ciparā izmantoto ciparu skaits) vai decimālzīmēm (cipars aiz komata) jāiekļauj rezultāts: Ja parametram toFixed() nav definēts arguments, tas tiks iestatīts pēc noklusējuma

vienāds ar nulli

, kas nozīmē 0 ciparu aiz komata, argumenta maksimālā vērtība ir 20.
Ja parametram toPrecision netiek dots neviens arguments, skaitlis netiek aizskarts

lai randNum = 6,25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" randNum = 87,335; randNum.toFixed(2); > "87,33" randNum = 87,337; randNum.toPrecision(3); > "87.3"
Gan metodes toFixed(), gan toPrecision() atgriež rezultāta virknes attēlojumu, nevis skaitli. Tas nozīmē, ka, summējot noapaļotu vērtību ar randNum, tas radīs virkņu savienošanu, nevis skaitļu summu: Ļaujiet randNum = 6,25; let noapaļots = randNum.toFixed(); // "6" konsole.log(randNum + noapaļots); > "6.256" datus, tad jums būs jāpiemēro parseFloat:

Ļaujiet randNum = 6,25; let noapaļots = parseFloat(randNum.toFixed(1)); konsole.log(noapaļots); > 6.3
Lūdzu, ņemiet vērā, ka vērtības 5 ir noapaļotas, izņemot retus gadījumus.

Metodes toFixed() un toPrecision() ir noderīgas, jo tās var ne tikai nogriezt daļdaļu, bet arī pievienot decimāldaļas, kas ir ērti, strādājot ar valūtu:

Lai veselaisSipars = 1 lai dolāriCenti = veselsSkaits.toFixed(2); konsole.log(dolāriCenti); > "1.00"
Ir vērts atzīmēt, ka toPrecision sniegs rezultātu eksponenciālā apzīmējumā, ja veselu skaitļu skaits ir lielāks par pašu precizitāti:

Ļaujiet num = 123,435 num.toPrecision(2); > "1.2e+2"

Kā izvairīties no noapaļošanas kļūdām ar decimāldaļām Dažos gadījumos toFixed un toPrecision noapaļo vērtību 5 uz leju un uz augšu:

Ļaujiet numTest = 1,005; numTest.toFixed(2); > "1.00"
Iepriekš minētā aprēķina rezultātam vajadzēja būt 1,01, nevis 1. Ja vēlaties izvairīties no līdzīgas kļūdas, mēs varam izmantot Džeka L Mūra piedāvāto risinājumu, kurā aprēķinam tiek izmantoti eksponenciālie skaitļi:

Funkcijas kārta(vērtība, decimālzīmes) (atgriež Skaitlis(Math.round(vērtība+"e"+decimālskaitļi)+"e-"+decimāldaļas); )
Tagad:

kārta(1,005,2); > 1.01
Ja vēlaties izturīgāku risinājumu, nekā parādīts iepriekš, varat doties uz MDN.

Mašīnas epsilona noapaļošana ES6 tika ieviesta alternatīva decimālo skaitļu noapaļošanas metode. Mašīnas epsilona noapaļošana nodrošina saprātīgu kļūdas robežu, salīdzinot divus peldošā komata skaitļus. Bez noapaļošanas salīdzinājumi var radīt līdzīgus rezultātus:

0,1 + 0,2 === 0,3 > nepatiess
Mēs savā funkcijā izmantojam Math.EPSILON, lai iegūtu derīgu salīdzinājumu:

Funkcija epsEqu(x, y) ( atgriež Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Funkcijai ir divi argumenti: pirmais ir pašreizējais aprēķins, otrais ir paredzamais rezultāts. Tas atgriež abu salīdzinājumu:

EpsEqu(0,1 + 0,2, 0,3) > patiess
Visas mūsdienu pārlūkprogrammas jau atbalsta ES6 matemātikas funkcijas, taču, ja vēlaties atbalstīt tādas pārlūkprogrammas kā IE 11, izmantojiet polifills.

Daļējas daļas nogriešana Visas iepriekš aprakstītās metodes var noapaļot līdz decimālskaitļiem. Lai vienkārši samazinātu skaitli līdz divām zīmēm aiz komata, vispirms tas jāreizina ar 100 un pēc tam iegūtais rezultāts jādala ar 100:

Funkcija truncated(num) ( atgriešanās Math.trunc(num * 100) / 100; ) truncated(3,1416) > 3,14
Ja vēlaties pielāgot metodi jebkuram zīmju skaitam aiz komata, varat izmantot divkāršo noliegumu bitu veidā:

Funkcija truncated(num, decimalPlaces) (lai numPowerConverter = Math.pow(10, decimalPlaces); atgriež ~~(num * numPowerConverter)/numPowerConverter; )
Tagad:

Ļaujiet randInt = 35,874993; saīsināts(randInt,3); > 35,874

Noapaļošana līdz tuvākajam skaitlim Lai noapaļotu decimālskaitli līdz tuvākajam skaitlim uz augšu vai uz leju atkarībā no tā, kuram mēs esam vistuvāk, izmantojiet Math.round():

Math.round(4.3) > 4 Math.round(4.5) > 5
Lūdzu, ņemiet vērā, ka “puse no vērtības”, 0,5 tiek noapaļota uz augšu saskaņā ar matemātikas noteikumiem.

Noapaļošana uz leju līdz tuvākajam veselajam skaitlim Ja vēlaties vienmēr noapaļot uz leju, izmantojiet Math.floor:

Matem.stāvs(42.23); > 42 Math.floor(36.93); > 36
Lūdzu, ņemiet vērā, ka noapaļošana uz leju darbojas visiem skaitļiem, tostarp negatīviem skaitļiem. Iedomājieties debesskrāpi ar bezgalīgu stāvu skaitu, ieskaitot grīdas apakšējā līmenī (attēlo negatīvus skaitļus). Ja atrodaties liftā zemākajā līmenī no 2 līdz 3 (kas apzīmē vērtību -2,5), Math.floor jūs aizvedīs uz -3:

Math.floor(-2,5); > -3
Bet, ja vēlaties izvairīties no šīs situācijas, izmantojiet Math.trunc, ko atbalsta visas mūsdienu pārlūkprogrammas (izņemot IE/Edge):

Math.trunc(-41,43); > -41
MDN jūs atradīsiet polifill, kas nodrošinās Math.trunc atbalstu pārlūkprogrammās un IE/Edge.

Noapaļošana uz augšu līdz tuvākajam veselajam skaitlim Savukārt, ja vienmēr ir nepieciešams noapaļot uz augšu, izmantojiet Math.ceil. Atkal atcerieties bezgalīgo liftu: Math.ceil vienmēr virzīsies uz augšu, neatkarīgi no tā, vai skaitlis ir negatīvs vai nē:

Math.griesti(42,23); > 43 Math.ceil(36,93); > 37 Math.ceil(-36,93); > -36

Noapaļošana uz augšu/uz leju līdz vajadzīgajam skaitlim Ja vēlamies noapaļot līdz tuvākajam reizinājumam 5, vienkāršākais veids ir izveidot funkciju, kas dala skaitli ar 5, noapaļo un pēc tam reizina ar tādu pašu summu:

Funkcija roundTo5(num) ( atgriešanās Math.round(num/5)*5; )
Tagad:

RoundTo5(11); > 10
Ja vēlaties noapaļot līdz savas vērtības reizinātājiem, mēs izmantojam vispārīgāku funkciju, nododot tai sākotnējo vērtību un daudzkārtni:

Funkcija roundToMultiple(num, multiple) (atgriezt Math.round(num/multiple)*multiple; )
Tagad:

Lai sākotnējais skaits = 11; ļaut vairākiem = 10; roundToMultiple(sākotnējaisCipars, vairākkārtējs); > 10;

Skaitļa fiksēšana diapazonā Ir daudz gadījumu, kad mēs vēlamies iegūt x vērtību, kas atrodas diapazonā. Piemēram, mums var būt nepieciešama vērtība no 1 līdz 100, taču mēs saņēmām vērtību 123. Lai to labotu, mēs varam izmantot min (atgriež mazāko no skaitļu kopas) un max (atgriež lielāko no jebkuras kopas). no skaitļiem). Mūsu piemērā diapazons ir no 1 līdz 100:

Ļaujiet zemākajai robežai = 1; let highBound = 100; lai numInput = 123; let clamped = Math.max(lowBound, Math.min(numInput, highBound)); console.log(clamped); > 100;
Atkal mēs varam atkārtoti izmantot darbību un ietīt visu funkcijā, izmantojot Daniela X. Mūra piedāvāto risinājumu:

Number.prototype.clamp = funkcija(min, max) ( return Math.min(Math.max(this, min), max); );
Tagad:

NumInput.clamp(lowBound, highBound); > 100;

Gausa noapaļošana Gausa noapaļošana, kas pazīstama arī kā baņķiera noapaļošana, šajā gadījumā tiek noapaļota līdz tuvākajam pāra skaitlim. Šī noapaļošanas metode darbojas bez statistiskām kļūdām. Labākais risinājums ieteica Tims Dauns:

Funkcija gaussRound(num, decimalPlaces) ( lai d = decimālvietas || 0, m = Math.pow(10, d), n = +(d ? cipars * 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; }
Tagad:

GaussRound(2.5) > 2 gaussRound(3.5) > 4 gaussRound(2.57,1) > 2.6
Decimāldaļa CSS:

Tā kā JavaScript bieži tiek izmantots, lai izveidotu pozicionālo kartējumu HTML elementiem, jums varētu rasties jautājums, kas notiktu, ja mēs saviem elementiem ģenerētu decimālvērtības:

#box (platums: 63,667731993px;)
Labā ziņa ir tā, ka mūsdienu pārlūkprogrammas bloku modelī ievēros decimālvērtības, tostarp procentuālās vai pikseļu vienības.

Kārtošana Ļoti bieži mums ir jāsakārto daži elementi, piemēram, mums ir spēļu ierakstu masīvs, un tiem jābūt sakārtotiem spēlētāju ranga dilstošā secībā. Diemžēl, standarta metode Sort() ir daži pārsteidzoši ierobežojumi: tas labi darbojas ar vispārpieņemtiem angļu valodas vārdiem, bet nekavējoties sabojājas, kad tas saskaras ar cipariem, unikālām rakstzīmēm vai lielajiem vārdiem. Kārtošana alfabētiskā secībā Šķiet, ka masīva kārtošanai alfabētiskā secībā ir jābūt vienkāršam uzdevumam:

Ļaujiet augļiem = ["sviesta ķirbis", "aprikoze", "kantalupa"]; fruit.sort(); > "aprikoze", "sviesta ķirbis", "kantalupa"]
Tomēr rodas problēma, tiklīdz viens no elementiem ir rakstīts ar lielajiem burtiem:

Ļaujiet augļiem = ["sviesta skvošs", "aprikoze", "Cantalope"]; fruit.sort(); > "Kantalopa", "aprikoze", "sviesta ķirbis"]
Tas ir tāpēc, ka pēc noklusējuma kārtotājs salīdzina pirmo Unicode attēloto rakstzīmi. Unicode ir unikāls kods jebkurai rakstzīmei neatkarīgi no platformas, neatkarīgi no programmas, neatkarīgi no valodas. Piemēram, ja skatāties uz kodu tabulu, rakstzīmei "a" ir vērtība U+0061 (heksadecimālā 0x61), savukārt rakstzīmei "C" ir kods U+0043 (0x43), kas ir agrāk Unicode. tabulā nekā rakstzīme "a".

Lai kārtotu masīvu, kurā var būt jaukti pirmie burti, mums ir vai nu īslaicīgi jāpārvērš visi elementi mazajos burtos, vai arī jādefinē kārtošanas secība, izmantojot metodi localeCompare() ar dažiem argumentiem. Parasti šādā gadījumā ir labāk nekavējoties izveidot funkciju atkārtotai lietošanai:

Funkcija alphaSort(arr) ( arr.sort(funkcija (a, b) ( atgriež a.localeCompare(b, "en", ("jutīgums": "bāze")); )); ) let fruit = ["sviesta ķirbis ", "aprikoze", "Kantalopa"]; alfaSort(augļi) >
Ja vēlaties, lai masīvs tiktu sakārtots apgrieztā alfabētiskā secībā, vienkārši samainiet a un b pozīcijas funkcijā:

Funkcija alphaSort(arr) ( arr.sort(funkcija (a, b) ( return b.localeCompare(a, "en", ("jutīgums": "bāze")); )); ) let fruit = ["sviesta ķirbis ", "aprikoze", "Kantalopa"]; alfaSort(augļi) > ["Kantalopa", "sviesta ķirbis", "aprikoze"]
Šeit ir vērts atzīmēt, ka localeCompare tiek izmantots ar argumentiem, mums arī jāatceras, ka to atbalsta IE11+, vecākām IE versijām mēs to varam izmantot bez argumentiem un mazajiem burtiem:

Funkcija caseSort(arr) ( arr.sort(funkcija (a, b) ( atgriež a.toLowerCase().localeCompare(b.to LowerCase()); )); ) let fruit = ["sviesta ķirbis", "aprikoze", "Kantalupa"]; caseSort(fruit) > ["aprikoze", "sviesta ķirbis", "kantalupa"]

Skaitliskā šķirošana Tas viss neattiecas uz piemēru, par kuru mēs runājām iepriekš par spēļu ierakstu masīvu. Izmantojot dažus ciparu masīvus, šķirošana darbojas lieliski, taču kādā brīdī rezultāts var būt neparedzams:

Ļaujiet augstākajiem rādītājiem = ; high Scores.sort(); >
Lieta tāda, ka sort() metode veic leksikogrāfisku salīdzinājumu: tas nozīmē, ka skaitļi tiks pārvērsti virknē un atkal tiks veikti salīdzinājumi, saskaņojot šīs virknes pirmo rakstzīmi Unikoda tabulas rakstzīmju secībā. . Tāpēc mums atkal jādefinē kārtošanas secība:

Ļaujiet augstākajiem rādītājiem = ; highScores.sort(funkcija(a,b) ( atgriež a - b; )); >
Atkal, lai kārtotu skaitļus apgrieztā secībā, apmainiet a un b pozīcijas funkcijā.

JSON līdzīgas struktūras kārtošana Visbeidzot, ja mums ir JSON līdzīga datu struktūra, kas attēlota kā spēļu ierakstu masīvs:

Let scores = [ ( "vārds": "Daniels", "rezultāts": 21768 ), ( "vārds": "Maikls", "rezultāts": 33579 ), ( "vārds": "Alison", "rezultāts": 38395 ) ];
Programmā ES6+ varat izmantot bultiņu funkcijas:

Scores.sort((a, b) => b.score - a.score));
Vecākām pārlūkprogrammām, kurām nav šī atbalsta:

Scores.sort(function(a, b) ( atgriež a.score - b.score ));
Kā redzat, kārtošana JavaScript ir diezgan neskaidra lieta, ceru, ka šie piemēri kaut kā atvieglos dzīvi.

Darbs ar pakāpju funkcijām Eksponentēšana ir darbība, kas sākotnēji definēta kā naturāla skaitļa atkārtotas reizināšanas rezultāts ar kvadrātsakni. Šīs funkcijas mēs varētu pastāvīgi izmantot ikdienas dzīvē matemātikas stundās, tostarp aprēķinot laukumus, apjomus vai pat fiziskajā modelēšanā.

JavaScript jaudas funkcija ir attēlota kā Math.pow(), jaunajā ES7 standartā tā tika ieviesta jauns operators kāpināšana - " * * ".

Paaugstināšana līdz pakāpei Lai palielinātu skaitli līdz n-tajam pakāpim, izmantojiet funkciju Math.pow(), kur pirmais arguments ir skaitlis, kas tiks palielināts līdz pakāpei, bet otrais arguments ir eksponents:

Math.pow(3,2) > 9
Šī apzīmējuma forma nozīmē 3 kvadrātā vai 3 × 3, kas noved pie rezultāta 9. Protams, var sniegt citu piemēru:

Math.pow(5,3); > 125
Tas ir, 5 kubi jeb 5 × 5 × 5 ir vienāds ar 125.

ECMAScript 7 ir nākamā JavaScript versija, principā mēs varam izmantot jauno ierosināto kāpināšanas operatoru - * *, šī apzīmējuma forma var būt aprakstošāka:

3 ** 2 > 9
Ieslēgts šobrīd Atbalsts šim operatoram ir diezgan ierobežots, tāpēc tā lietošana nav ieteicama.

Jaudas 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ātsakne un kubsakne Math.sqrt() un Math.cbrt() ir pretstats Math.pow(). Kā mēs atceramies, kvadrātsakne no a ir skaitlis, kas dod kvadrātu.

Math.sqrt(9) > 3
Tajā pašā laikā a kuba sakne ir skaitlis, kas dod a, kad to paceļ kubā.

Math.cbrt(125) > 5
Math.cbrt() tikai nesen tika ieviests JavaScript specifikācijā, un tāpēc to atbalsta tikai mūsdienu pārlūkprogrammas: Chrome 38+, Firefox un Opera 25+ un Safari 7.1+. Jūs to ievērosiet Internet Explorer nav šajā sarakstā, bet jūs atradīsiet polifili MDN.

Piemēri Protams, vienā no šīm funkcijām mēs varam izmantot vērtības, kas nav veseli skaitļi:

Math.pow(1,25, 2); > 1,5625 Math.cbrt(56,57) > 3,8387991760286138
Lūdzu, ņemiet vērā, ka tas darbojas diezgan labi arī tad, ja tiek izmantotas negatīvas argumentu vērtības:

Math.pow(-5,2) > 25 Math.pow(10,-2) > 0,01
Tomēr tas nedarbosies kvadrātsaknei:

Math.sqrt(-9) > NaN
No matemātiskās analīzes mēs zinām, ka iedomāts skaitlis attiecas uz negatīvu skaitļu kvadrātsaknēm. Un tas var mūs novest pie citas metodes darbam ar kompleksajiem skaitļiem, bet tas ir cits stāsts.

Varat izmantot daļskaitļus programmā Math.pow(), lai atrastu skaitļu kvadrātsaknes un kubsaknes. Kvadrātsakne izmanto eksponentu 0,5:

Math.pow(5, 0,5); // = Math.sqrt(5) = 5 ** (1/2) > 2,23606797749979
Tomēr peldošā komata kaprīžu dēļ jūs nevarat precīzi uzminēt pareizo rezultātu:

Math.pow(2.23606797749979,2) > 5,000000000000001
Šādās situācijās jums nāksies ķerties pie zīmju nogriešanas no skaitļa vai noapaļošanas līdz kādai vērtībai.

Daži cilvēki nezināmu iemeslu dēļ JavaScript jauc funkciju Math.pow() ar Math.exp() , kas ir skaitļu eksponenciāla funkcija. Piezīme: iekšā angļu valoda"eksponents" tiek tulkots kā "eksponents", tāpēc tas, visticamāk, attieksies uz angliski runājošajiem, lai gan eksponentam ir arī alternatīvi nosaukumi, piemēram, indekss, jauda.

Matemātiskās konstantes Darbu ar matemātiku JavaScript atvieglo vairākas iebūvētās konstantes. Šīs konstantes ir matemātikas objekta īpašības. Ir vērts atzīmēt, ka konstantes tiek rakstītas ar lielajiem burtiem, nevis CamelCase apzīmējumiem. Math.abs, parseInt, parseFloat Darbs ar skaitļiem JavaScript var būt daudz sarežģītāks, nekā šķiet. Iegūtās vērtības ne vienmēr iekļaujas paredzētajās robežās, dažreiz rezultāts var nebūt tāds, kādu mēs gaidījām. Math.abs() Metode Math.abs() atgriež skaitļa absolūto vērtību, kas mums atgādina līdzīgu matemātisko funkciju skaitļa modulim.

Ļaujiet newVal = -57,64; Math.abs(newVal); > 57,64
Math.abs(0) vienmēr atgriež nulli, bet, ja funkcijas -Math.abs(NUM) priekšā ievietosim mīnusa zīmi, mēs vienmēr iegūsim negatīvu vērtību.

Math.abs(0); > -0

parseInt() Mēs zinām, ka JavaScript saprot, ka “15” ir virkne, nevis skaitlis, un, piemēram, parsējot CSS rekvizītus, izmantojot JavaScript, vai saņemot jebkuru vērtību no nesagatavota masīva, mūsu rezultāti var būt neparedzami. Kā ievadi mēs varētu saņemt virkni, kas attēlota kā “17px”, un tas mums nav nekas neparasts. Jautājums ir par to, kā pārvērst šo virkni faktiskajā vērtībā un izmantot to turpmākajos aprēķinos.

Sintakse: parseInt(string, radix);

Funkcija parseInt pārvērš pirmo tai nodoto argumentu par virknes tipu, interpretē to un atgriež veselu skaitli vai NaN vērtību. Rezultāts (ja nav NaN) ir vesels skaitlis un ir pirmais arguments (virkne), kas tiek uzskatīts par skaitli norādītajā radiksā. Piemēram, 10. bāze norāda reklāmguvumu no decimālskaitlis, 8 - oktāls, 16 - heksadecimāls un tā tālāk. Ja bāze ir lielāka par 10, tad skaitļus, kas lielāki par 9, izmanto burti. Piemēram, priekš heksadecimālie skaitļi(16. bāze) tiek izmantoti burti A līdz F.

Apskatīsim piemēru darbam ar CSS rekvizītiem, kur, nosacīti runājot, mēs varam iegūt šādu vērtību:

Let elem = document.body; let centerPoint = window.getComputedStyle(elem).transformOrigin; > "454 pikseļi 2087,19 pikseļi"
Mēs varam sadalīt vērtības pa atstarpēm:

Ļaujiet centriem = centerPoint.split(" "); > ["454px", "2087,19px"]
Tomēr katrs elements joprojām ir virkne, mēs varam no tā atbrīvoties, izmantojot mūsu funkciju:

Lai centrsX = parseInt(centri, 10); > 454 let centerY = parseInt(centri, 10); >2087
Kā redzat, ar otro argumentu mēs norādām skaitļu sistēmu, kurā skaitlis tiks pārveidots, šis parametrs nav obligāts, taču ieteicams to izmantot, ja nezināt, kura virkne tiks saņemta kā ievade.

parseFloat() Iepriekš minētajā piemērā jūs, iespējams, pamanījāt, ka parseInt izmet daļējo daļu. Mūsu gadījumā parseFloat var darboties ar peldošā komata skaitļiem. Atkal, tas var būt noderīgi, analizējot CSS un citus uzdevumus, īpaši strādājot ar peldošā komata procentiem.

Sintakse: parseFloat(virkne)

Lai FP = "33,33333%"; konsole.log(parseFloat(FP)); > 33,33333
Ņemiet vērā, ka parseFloat sintaksē nav otrā argumenta.

Lai gan mēs saprotam, ka parseInt() un parseFloat() ir ārkārtīgi noderīgas funkcijas, ir svarīgi paturēt prātā, ka tās nav bez kļūdām, tāpēc ir jāpārbauda paredzamo vērtību diapazons un galu galā jāanalizē rezultāts, lai nodrošinātu ka iegūtās vērtības ir pareizas.
Sūtīt anonīmi

Saistītie raksti