Mycket ofta ger beräkningar i JavaScript inte exakt de resultat som vi vill ha. Naturligtvis kan vi göra vad som helst med siffror – avrunda uppåt eller nedåt, sätta intervall, skära bort onödiga siffror till ett visst antal decimaler, allt beror på vad du vill göra med detta nummer i framtiden.

Varför behövs avrundning?

En av de märkliga aspekterna av JavaScript är att det faktiskt inte lagrar heltal, vi arbetar med flyttal direkt. Detta, i kombination med det faktum att många bråkvärden inte kan uttryckas med ett ändligt antal decimaler, kan vi i JavaScript få resultat så här:

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
För praktiska ändamål spelar denna felaktighet ingen roll, i vårt fall talar vi om ett fel i quintillion aktier, dock kan detta göra någon besviken. Vi kan också få några konstiga resultat när vi arbetar med siffror som representerar valutor, procentsatser eller filstorlekar. För att korrigera dessa felaktigheter behöver vi bara kunna runda resultaten, och det räcker med att ställa in decimalprecisionen.

Avrundande tal har praktisk användning, vi kan manipulera talet i något område, till exempel vill vi avrunda värdet till närmaste heltal, och inte bara arbeta med decimaldelen.

Avrundning av decimaler

För att trimma ett decimaltal, använd toFixed eller toPrecision-metoden. Båda tar ett enda argument, som bestämmer hur många signifikanta siffror (dvs det totala antalet siffror som används i numret) eller decimaler (talet efter decimalkomma) resultatet ska innehålla:

1. Om argumentet inte är definierat för toFixed(), kommer det som standard till noll, vilket betyder 0 decimaler, argumentet har maximalt värde lika med 20.
2. Om inget argument ges till Precision, lämnas numret orört

låt 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"
Både metoderna toFixed() och toPrecision() returnerar en strängrepresentation av resultatet, inte ett tal. Detta betyder att när man summerar det avrundade värdet med randNum , kommer strängar att sammanfogas, inte siffror som läggs till:

Låt randNum = 6,25; let rounded = randNum.toFixed(); // "6" console.log(randNum + avrundad); > "6.256"
Om du vill att resultatet ska vara av en numerisk datatyp, måste du använda parseFloat:

Låt randNum = 6,25; let rounded = parseFloat(randNum.toFixed(1)); konsollogg (avrundad); > 6.3
Observera att 5 värden är avrundade utom i sällsynta fall.

Metoderna toFixed() och toPrecision() är användbara, eftersom de inte bara kan skära av bråkdelen, utan också fylla decimalerna, vilket är praktiskt när man arbetar med valutor:

Låt wholeNum = 1 låt dollarCents = wholeNum.toFixed(2); console.log(dollarscent); > "1.00"
Observera att toPrecision returnerar resultatet i exponentiell notation om antalet heltal är större än själva precisionen:

Låt num = 123.435 num.toPrecision(2); > "1.2e+2"

Hur man undviker avrundningsfel med decimaler

I vissa fall avrundar toFixed och toPrecision värdet 5 nedåt och uppåt:

Låt numTest = 1,005; numTest.toFixed(2); > "1.00"
Resultatet av beräkningen ovan borde ha blivit 1,01, inte 1. Om du vill undvika liknande misstag, kan vi använda lösningen som föreslås av Jack L Moore, som använder exponentiella tal för att beräkna:

Funktion round(värde, decimaler) ( return Number(Math.round(värde+"e"+decimaler)+"e-"+decimaler); )
Nu:

Rund(1,005,2); > 1,01
Om du vill ha en mer robust lösning än den som visas ovan kan du gå till MDN.

Maskin epsilon avrundning

En alternativ metod för avrundning av decimaltal introducerades i ES6. Maskin epsilon-avrundning ger en rimlig felmarginal när man jämför två flyttal. Utan avrundning kan jämförelser ge resultat som liknar följande:

0,1 + 0,2 === 0,3 > falskt
Vi använder Math.EPSILON i vår funktion för att få rätt jämförelse:

Funktion epsEqu(x, y) ( return Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Funktionen tar två argument: det första är den aktuella beräkningen, det andra är det förväntade resultatet. Det ger en jämförelse av de två:

EpsEqu(0,1 + 0,2, 0,3) > sant
Alla moderna webbläsare stöder redan ES6 matematiska funktioner, men om du vill ha stöd i webbläsare som IE 11 använd polyfills .

Bråkklippning

Alla metoder som presenteras ovan kan avrunda till decimaltal. För att helt enkelt skära av ett tal med två decimaler måste du först multiplicera det med 100 och sedan dividera resultatet med 100:

Funktion truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3.1416) > 3.14
Om du vill anpassa metoden till valfritt antal decimaler kan du använda bitvis dubbel negation:

Funktion trunkerad(tal, decimalplatser) (låt numPowerConverter = Math.pow(10, decimalPlaces); returnera ~~(num * numPowerConverter)/numPowerConverter; )
Nu:

Låt randInt = 35,874993; truncated(randInt,3); > 35,874

Avrundning till närmaste tal

För att avrunda ett decimaltal uppåt eller nedåt till närmaste tal, beroende på vad vi är närmast, använd Math.round():

Math.round(4.3) > 4 Math.round(4.5) > 5
Observera att "halva värdet", 0,5 avrundas uppåt av matematikens regler.

Avrundning nedåt till närmaste heltal

Om du alltid vill avrunda nedåt, använd Math.floor:

Math.floor(42.23); > 42 Math.floor(36.93); > 36
Observera att avrundning nedåt fungerar för alla tal, inklusive negativa. Föreställ dig en skyskrapa med ett oändligt antal våningar, inklusive lägre nivåer (representerar negativa tal). Om du befinner dig i en hiss på bottennivån mellan 2 och 3 (vilket är ett värde på -2,5), tar Math.floor dig till -3:

Math.floor(-2,5); > -3
Men om du vill undvika den här typen av situation, använd Math.trunc , som stöds i alla moderna webbläsare (förutom IE/Edge):

Math.trunc(-41.43); > -41
På MDN hittar du en polyfill som kommer att ge stöd för Math.trunc i webbläsare och IE/Edge.

Avrundning uppåt till närmaste heltal

Å andra sidan, om du alltid behöver runda uppåt, använd Math.ceil. Återigen, kom ihåg den oändliga hissen: Math.ceil kommer alltid att gå "upp", oavsett om siffran är negativ eller inte:

Math.ceil(42.23); > 43 Math.ceil(36.93); > 37 Math.ceil(-36.93); > -36

Runda upp/ner efter behov

Om vi ​​vill avrunda uppåt till närmaste multipel av 5 är det enklaste sättet att skapa en funktion som delar ett tal med 5, avrundar det uppåt och sedan multiplicerar det med samma belopp:

Funktion roundTo5(num) ( return Math.round(num/5)*5; )
Nu:

RoundTo5(11); > 10
Om du vill avrunda till multiplar av ditt värde använder vi en mer allmän funktion, som skickar in det initiala värdet och en multipel:

Funktion roundToMultiple(tal, multipel) ( return Math.round(num/multipel)*multipel; )
Nu:

Låt initialNumber = 11; låt multipla = 10; roundToMultiple(initialNumber, multipel); > 10;

Fixa ett nummer i ett intervall

Det finns många fall där vi vill få ett x-värde som ligger inom ett intervall. Till exempel, vi kanske vill ha ett värde från 1 till 100, men vi slutade med värdet 123. För att fixa detta kan vi använda min (returnerar det minsta av en uppsättning siffror) och max (returerar det största av alla uppsättningar) av siffror). I vårt exempel är intervallet från 1 till 100:

Låt låggräns = 1; låt höggräns = 100; låt numInput = 123; let clamped = Math.max(lowBound, Math.min(numInput, highBound)); konsollogg (klämd); > 100;
Återigen kan vi återanvända operationen och slå in det hela i en funktion, med hjälp av lösningen som föreslås av Daniel X. Moore:

Number.prototype.clamp = function(min, max) ( return Math.min(Math.max(this, min), max); );
Nu:

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

Gaussisk avrundning

Gaussisk avrundning, även känd som bankers avrundning, är att avrundningen för detta fall är till närmaste jämna tal. Denna avrundningsmetod fungerar utan statistiska fel. Den bästa lösningen det föreslogs av Tim Down:

Funktion gaussRound(tal, decimalPlatser) ( låt d = decimalPlatser || 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; }
Nu:

GaussRound(2.5) > 2 gaussRound(3.5) > 4 gaussRound(2.57,1) > 2.6
Decimalkomma i CSS:

Eftersom JavaScript ofta används för att skapa positionella transformationer för HTML-element, kanske du undrar vad som händer om vi genererar decimalvärden för våra element:

#box ( bredd: 63,667731993px; )
Den goda nyheten är att moderna webbläsare kommer att respektera decimalvärden i boxmodellen, inklusive procent eller pixelenheter.

Sortering

Mycket ofta behöver vi sortera vissa element, till exempel har vi en rad spelrekord, medan de måste organiseras i fallande ordning efter spelarnas rangordning. Tyvärr, standardmetod sort() har några överraskande begränsningar: det fungerar bra med vanliga engelska ord, men bryts ner omedelbart när det stöter på siffror, unika tecken eller versaler.

Sortera alfabetiskt

Det verkar som att sortering av en array alfabetiskt borde vara den enklaste uppgiften:

Låt frukt = ["butternut squash", "aprikos", "cantaloupe"]; fruktsort(); > "aprikos", "butternut squash", "cantaloupe"]
Men vi stöter på ett problem så snart ett av elementen är med versaler:

Låt frukt = ["butternut squash", "aprikos", "Cantalope"]; fruktsort(); > "Cantaloupe", "aprikos", "butternut squash"]
Detta beror på att sorteraren som standard jämför det första tecknet som representeras i Unicode . Unicode är en unik kod för alla tecken, oavsett plattform, oavsett program, oavsett språk. Till exempel, när man tittar på kodtabellen har tecknet "a" värdet U+0061 (hexadecimalt 0x61), medan tecknet "C" har koden U+0043 (0x43), som kommer före tecknet i Unicode tabell "a".

För att sortera en array som kan innehålla blandade stora bokstäver måste vi antingen konvertera alla element tillfälligt till gemener, eller definiera vår egen sorteringsordning med metoden localeCompare() med några argument. Som regel, för ett sådant fall, är det bättre att omedelbart skapa en funktion för flera användningsområden:

Funktion alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("sensitivity": "base")); )); ) let fruit = ["butternut squash ", "aprikos", "Cantaloupe"]; alphaSort(frukt) >
Om du vill få en array sorterad i omvänd alfabetisk ordning, byt bara ut positionerna för a och b i funktionen:

Funktion alphaSort(arr) ( arr.sort(function (a, b) ( return b.localeCompare(a, "en", ("sensitivity": "base")); )); ) let fruit = ["butternut squash ", "aprikos", "Cantaloupe"]; alphaSort(frukt) > ["Cantaloupe", "butternut squash", "aprikos"]
Här är det värt att notera att localeCompare används med argument, vi måste också komma ihåg att det stöds av IE11+, för äldre versioner av IE kan vi använda det utan argument, och med små bokstäver:

Funktion caseSort(arr) ( arr.sort(function (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) låt frukt = ["butternut squash", "aprikos", "Cantaloupmelon"]; caseSort(frukt) > ["aprikos", "butternut squash", "Cantaloupe"]

Numerisk sortering

Allt detta gäller inte exemplet som vi pratade om ovan om mängden spelrekord. Med vissa numeriska arrayer fungerar sortering bra, men någon gång kan resultatet vara oförutsägbart:

Låt highScores = ; sortera(); >
Faktum är att sort()-metoden utför en lexikografisk jämförelse: vilket innebär att siffrorna kommer att konverteras till en sträng och jämförelser återigen kommer att göras genom att matcha det första tecknet i denna sträng i ordningen för tecknen i Unicode-tabellen. Därför måste vi återigen definiera vår sorteringsordning:

Låt highScores = ; highScores.sort(function(a,b) (retur a - b; )); >
Återigen, för att sortera siffrorna i omvänd ordning, byt ut positionerna för a och b i funktionen.

Sorterar en JSON-liknande struktur

Och slutligen, om vi har en JSON-liknande datastruktur representerad som en rad spelrekord:

Låt poäng = [ ( "name": "Daniel", "score": 21768 ), ( "name": "Michael", "score": 33579 ), ( "name": "Alison", "score": 38395 )];
I ES6+ kan du använda pilfunktioner:

Scores.sort((a, b) => b.score - a.score));
För äldre webbläsare som inte har detta stöd:

Scores.sort(function(a, b) ( return a.score - b.score ));
Som du kan se är sortering i JavaScript en ganska icke självklar sak, jag hoppas att dessa exempel gör livet lättare på något sätt.

Arbeta med Power Functions

Exponentiering är en operation som ursprungligen definierades som resultatet av att multiplicera ett naturligt tal med sig självt, kvadratroten ur a är det tal som ger a när det är kvadratiskt. Vi skulle kunna använda dessa funktioner konstant i vardagen i matematiklektioner, inklusive när vi beräknar arealer, volymer eller till och med i fysisk modellering.

I JavaScript representeras exponentialfunktionen som Math.pow(), i den nya ES7-standarden introducerades en ny exponentieringsoperator - " * * ".

Exponentiering

För att höja ett tal till n:te potens, använd Math.pow()-funktionen, där det första argumentet är talet som ska höjas till potensen, och det andra argumentet är exponenten:

Math.pow(3,2) > 9
Denna notation betyder 3 i kvadrat, eller 3 × 3, vilket resulterar i resultatet 9. Ett annat exempel kan givetvis ges:

Math.pow(5,3); > 125
Det vill säga, 5 kuber, eller 5 × 5 × 5, är lika med 125.

ECMAScript 7 är nästa version av JavaScript, i princip kan vi använda den nya föreslagna exponentieringsoperatorn - * *, denna form av skrivning kan vara mer beskrivande:

3 ** 2 > 9
På det här ögonblicket stödet för den här operatören är ganska begränsat, så dess användning rekommenderas inte.

Power-funktionen kan komma väl till pass i en mängd olika situationer. Ett enkelt exempel, att beräkna antalet sekunder i en timme: Math.pow(60,2).

Kvadratur och kubrot

Math.sqrt() och Math.cbrt() är motsatsen till Math.pow(). Som vi minns är kvadratroten ur a det tal som ger a när det är kvadratiskt.

Math.sqrt(9) > 3
Samtidigt är kubroten av a det tal som ger a när det kuberas.

Math.cbrt(125) > 5
Math.cbrt() introducerades i JavaScript-specifikationen alldeles nyligen och stöds därför endast i moderna webbläsare: Chrome 38+, Firefox och Opera 25+ och Safari 7.1+. Det kommer du att märka Internet Explorer finns inte på den här listan, men du kan hitta en polyfill på MDN.

Exempel

Naturligtvis kan vi också använda icke-heltalsvärden i en av dessa funktioner:

Math.pow(1,25, 2); > 1,5625 Math.cbrt(56,57) > 3,8387991760286138
Observera att detta fungerar lika bra när du använder negativa argumentvärden:

Math.pow(-5,2) > 25 Math.pow(10,-2) > 0,01
Men för kvadratrot kommer detta inte att fungera:

Math.sqrt(-9) > NaN
Från matematisk analys vet vi att det imaginära talet förstås som kvadratrötterna av negativa tal. Och det kan leda oss till en annan teknik med komplexa tal, men det är en annan historia.

Du kan använda bråkvärden i Math.pow() för att hitta kvadrat- och kubrötter av tal. Kvadratroten använder en exponent på 0,5:

Math.pow(5, 0,5); // = Math.sqrt(5) = 5 ** (1/2) > 2,23606797749979
Men på grund av flytpunktens nycker kan du inte gissa det korrekta resultatet exakt:

Math.pow(2.23606797749979.2) > 5.0000000000000001
I sådana situationer måste du ta till att skära bort tecken från siffran eller avrunda till något värde.

Vissa, oförklarligt i JavaScript, blandar ihop Math.pow()-funktionen med Math.exp() , som är en exponentiell funktion för tal i allmänhet. Obs: in engelska språket"exponent" översätts som "exponent", så det är mer relevant för engelsktalande, även om det finns alternativa namn för exponenten, som index, makt.

Matematiska konstanter

Att arbeta med matematik i JavaScript underlättas av ett antal inbyggda konstanter. Dessa konstanter är egenskaper hos Math-objektet. Det är värt att notera att konstanterna skrivs med versaler, inte CamelCase-notation.

Math.abs, parseInt, parseFloat

Att arbeta med siffror i JavaScript kan vara mycket mer komplicerat än du tror. De erhållna värdena faller inte alltid inom de förväntade intervallen, ibland kanske resultatet inte alls blir vad vi förväntade oss.

Math.abs()

Metoden Math.abs() returnerar det absoluta värdet av ett tal, vilket påminner oss om den analoga matematiska modulo a-funktionen.

Låt newVal = -57,64; Math.abs(newVal); > 57,64
Math.abs(0) returnerar alltid noll, men om vi sätter ett minustecken framför funktionen -Math.abs(NUM) kommer vi alltid att ha ett negativt värde.

Math.abs(0); > -0

parseInt()

Vi vet att JavaScript förstår att "15" är en sträng, inte ett nummer, och till exempel när vi analyserar CSS-egenskaper med JavaScript, eller får något värde från en oförberedd array, kan våra resultat visa sig vara oförutsägbara. Vi skulle kunna få en sträng representerad som "17px" som indata, och detta är inte ovanligt för oss. Frågan är hur man konverterar denna sträng till verkligt värde och använder den i ytterligare beräkningar.

Syntax: parseInt(sträng, radix);

Funktionen parseInt konverterar det första argumentet som skickas till det till en strängtyp, tolkar det och returnerar ett heltal eller NaN-värde. Resultatet (om inte NaN) är ett heltal och är det första argumentet (strängen) som behandlas som ett tal i det angivna talsystemet (radix). Till exempel anger bas 10 omvandling från decimal, 8 från oktal, 16 från hexadecimal, och så vidare. Om basen är större än 10 används bokstäver för att beteckna siffror större än 9. Till exempel använder hexadecimala tal (bas 16) bokstäverna A till F.

Betrakta ett exempel på att arbeta med CSS-egenskaper, där vi relativt sett kan få följande värde:

Låt elem = document.body; let centerPoint = window.getComputedStyle(elem).transformOrigin; > "454px 2087.19px"
Vi kan separera värden med mellanslag:

Låt centrera = centerPoint.split(" "); > ["454px", "2087.19px"]
Men varje element är fortfarande en sträng, vi kan bli av med detta genom att använda vår funktion:

Låt centerX = parseInt(center, 10); > 454 låt centerY = parseInt(center, 10); > 2087
Som du kan se, som det andra argumentet anger vi det talsystem som talet ska konverteras till, denna parameter är valfri, men det rekommenderas att använda den om du inte vet vilken sträng som kommer att matas in.

parseFloat()

Från exemplet ovan kanske du har märkt att parseInt kasserar bråkdelen. I vårt fall kan parseFloat fungera med flyttal. Återigen, detta kan vara användbart vid CSS-analys och andra uppgifter, särskilt när det handlar om flyttal i procent.

Syntax: parseFloat(sträng)

LetFP = "33,33333%"; console.log(parseFloat(FP)); > 33,33333
Observera att det inte finns något andra argument i parseFloat-syntaxen.

Vi förstår att parseInt() och parseFloat() är extremt användbara funktioner, det är viktigt att komma ihåg att det måste finnas fel, så du måste kontrollera intervallet av förväntade värden och så småningom analysera resultatet för att säkerställa att de värden du får är korrekta.
Skicka anonymt

Hallå. Idag i spalten om Javascript ska vi titta på hur man ställer in antalet decimaler i flyttal i JavaScript. Till exempel måste du lämna 3 decimaler när du matar ut, eller bara två.

Uppgift: javascript antal decimaler

Så vi står inför en uppgift: det finns ett beräkningsresultat där det finns siffror före decimalkomma och efter decimalkomma. Decimal. Låt oss säga att resultatet är så här 1538.9891200153. Men när du matar ut bör du få en siffra som återspeglar beloppet, där före decimaltecknet är antalet sedlar och efter - kopek.

Det finns flera sätt att lösa detta problem.

Lösning 1: javascript antal decimaler med toFixed-metoden

toFixed är en inbyggd javascript-metod som tillämpas på valfritt tal, den tar avrundningsprecision (det vill säga antalet decimaler) som en parameter.

Varnum=1538.9891200153; num_str=num.toFixed(); //num_str=1538; num_str=num.toFixed(2); //num_str=1538.98; num_str=num.toFixed(5); //num_str=1538.98912;

Precisionsparametern i denna funktion måste vara minst 0 (tar inga negativa värden) och högst 20.

Du kan också klara dig utan en variabel, så här:

Num_str=(1538.9891200153).toFixed(2); //num_str=1538.98;

Lösning 2: javascript antal decimaler med toPrecision-metoden

Denna lösning är baserad på samma inbyggda javascript-metoden. En utmärkande egenskap hos denna metod är att indataparametern inte anger noggrannheten (antalet decimaler), utan det totala antalet decimaler (både före och efter decimalkomma).

Varnum=1538.9891200153; num_str=num.toPrecision(5); //num_str=1538.9; num_str=num.toPrecision(7); //num_str=1538.989;

Lösning utan decimaler: javascript antal decimaler

Om decimalerna måste kasseras helt, det vill säga du måste avrunda ett bråktal till ett heltal, kan du använda funktionerna i Math-klassen: rund, tak och golv.
Runda - avrundar uppåt eller nedåt (beroende på antalet). Om värdet efter decimalkomma är mer än hälften så avrundas det uppåt, om det är mindre avrundas det nedåt. Det vill säga, om 0,51 - blir det 1, om 0,49 - 0.

Ceil - från engelska. taket rundar alltid uppåt.

Golv - från engelska. Kön avrundas alltid nedåt.

Varnum = 1538.9891200153; num_str=math.round(num); //num_str=1539; num_str=Math.floor(num); //num_str=1538; num_str=Math.ceil(num); //num_str=1539;

Det är allt. Jag hoppas att det här meddelandet hjälpte dig att lösa ditt problem. Om något inte fungerade, ställ frågor med den gröna knappen "Ställ en fråga till en specialist" eller i kommentarerna.

Hej JavaScript-älskare. Du har redan märkt att detta språk är mycket extraordinärt och sticker ut i varje avsnitt med sina egna funktioner och ovanliga tekniska lösningar. Därför är dagens publikation tillägnad ämnet: "JavaScript-avrundning".

Efter att ha läst den aktuella artikeln kommer du att ta reda på varför det är nödvändigt att avrunda siffror, vilka metoder och egenskaper i js som utför denna funktion och vad som skiljer division med 0. Utan att ändra mina principer kommer jag att bifoga exempel till nyckelpunkterna i material och beskriv varje åtgärd i detalj. Nu börjar vi lära oss!

Viktiga anmärkningar om siffror

Kom först ihåg att i js är alla typer av tal (bråktal och heltal) av typen siffra. Dessutom är de alla 64-bitars, eftersom de lagras i formatet "dubbel precision", som också är känt som IEEE-754-standarden.

Numeriska variabler skapas på vanligt sätt:

var numb = 35; // naturligt nummer

vardrob = 0,93; //decimalrepresentation

var numb16 = 0xFF; //hexadecimalt talsystem

Stöder även andra numeriska representationer. Så du kan fortfarande skapa flyttal (de kallas ibland "tal i vetenskapligt format").

Lade till stöd för en mycket intressant metod toLocaleString(), som formaterar alla numeriska parametrar enligt specifikationerna som föreskrivs i ECMA 402. På grund av detta, stora antal, telefonnummer, valutor och till och med procentsatser visas snyggt i dialogrutan.

varnum = 714000,80;

alert(num.toLocaleString());

För att arbeta med element av typen Nummer försågs ett helt globalt objekt med en massa olika matematiska funktioner, vars namn är Matematik.

Dessutom finns det andra metoder som avrundar numeriska värden till heltal, till tiondelar, hundradelar och så vidare. Låt oss överväga dem alla mer i detalj.

Stor och mäktig matte

Det globala Math-objektet innehåller ett stort utbud av matematiska och trigonometriska funktioner. Detta är ett mycket nödvändigt objekt och hjälper ofta utvecklare när de arbetar med digital data.

På andra plattformar finns det analogier till Math. Till exempel, i populära språk som Java och C#, är Math en klass som stöder detsamma standardfunktioner. Så som du kan se är det här verktyget riktigt bra och kraftfullt.

Nu vill jag gå igenom de specifika avrundningsmetoderna och prata om dem i detalj.

Math.floor()

Jag börjar med Matematik.golv. Var uppmärksam på namnet på metoden. Logiskt blir det tydligt att eftersom vi pratar om avrundning, och den bokstavliga översättningen av ordet "golv" betyder "golv", kommer detta verktyg att runda de bearbetade värdena nedåt.

Det är också möjligt att det bearbetade numret med denna funktion förblir detsamma. Detta beror på att avrundning utförs enligt en icke strikt ojämlikhet (<=). Таким образом, при отработке этой строчки кода:

alert(Math.floor(4.5));

svaret blir nummer 4.

Math.ceil()

Återigen, titta på titeln (på så sätt absorberas materialet snabbare). Om någon inte vet, betyder "tak" "tak". Detta innebär att numeriska data kommer att avrundas uppåt med en icke-strikt olikhet (>=).

alert(Math.ceil(4.5));

Som du kanske har gissat kommer svaret att vara siffran 5.

matte omgång()

Denna metod avrundar ett bråktal till närmaste heltal. Så, om bråkdelen ligger i intervallet från 0 till 0,5 inklusive, sker avrundning till ett mindre värde. Och om bråkdelen ligger i intervallet från 0,5 inklusive till nästa heltal, så avrundas det uppåt till ett större heltal.

alert(Math.round(4.5));

Jag hoppas att alla trodde eller sa att det rätta svaret är 5.

Några fler metoder

JavaScript har också 2 andra metoder som hanterar avrundning av numeriska representationer. De är dock något olika.

Vi pratar om verktyg som t.ex toFixed() och toPrecision(). De är ansvariga inte bara för avrundning, utan för dess noggrannhet till vissa tecken. Låt oss gräva djupare.

toFixed()

Med denna mekanism kan du ange hur många decimaler värdet ska avrundas till. Metoden returnerar resultatet som en sträng. Nedan har jag bifogat en variant med tre olika alternativ. Analysera de inkomna svaren.

varnum = 5656,9393;

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

document.writeln(num.toFixed(2)); // 5656,94

document.writeln(num.toFixed(7)); // 5656.9393000

Som du kan se, om du inte anger ett argument, kommer toFixed ()) att avrunda bråkvärdet till helheten tal. Den tredje linjen är avrundad upp till 2 tecken, och i den fjärde lades ytterligare tre nollor till på grund av parametern "7".

toPrecision()

Denna metod fungerar lite annorlunda. I stället för argumentet kan du lämna både ett tomt utrymme och ställa in en parameter. Den senare avrundar dock siffror till det angivna antalet siffror, oavsett kommatecken. Här är resultatet av programmet omskrivet från föregående exempel:

varnum = 5656,9393;

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

document.writeln(num.toPrecision(2)); // 5.7e+3

document.writeln(num.toPrecision(7)); // 5656,939

Funktionen för division med 0 i js

Som du vet från mattelektionerna kan du inte dividera med noll. Denna regel togs som grund av de flesta av skaparna av programmeringsspråk. Därför ger alla program ett fel när man dividerar med noll.

Men JavaScript utmärkte sig även här. Så under utförandet av en sådan operation inträffar inga felrapporter ... eftersom en sådan operation återkommer "Oändlighet"!

Varför då? Som bekant från samma matematiska vetenskaper, ju mindre divisor, desto större resultat. Det är därför skaparna av detta prototypbaserade språk bestämde sig för att överge mallar och gå sin egen väg.

För dem som är nya i betydelsen av Infinity, har jag förklarat dess funktioner nedan.

Oändlighet - betyder oändlighet och motsvarar helt det matematiska tecknet ∞.

Kan vara negativt. Alla standardregler för att arbeta med aritmetiska operatorer finns också bevarade.

varning(12/0); // Oändlighet

alert(12.34/0); // Oändlighet

varning(-3/0); // -Oändlighet

Med detta kanske jag avslutar. Om du gillade inlägget, se till att prenumerera på min blogg. Länka gärna till intressanta artiklar och dela dem med dina vänner. Hejdå!

I den här artikeln kommer vi att titta närmare på siffror, matematiska operatorer, sätt att konvertera ett tal till en sträng och vice versa, samt många andra viktiga punkter.

isFinite funktion

Funktionen isFinite låter dig kontrollera om ett argument är ett ändligt tal.

Den här funktionen returnerar false som ett svar om argumentet är Infinity , -Infinity , NaN , eller skulle castas till ett av dessa speciella numeriska värden. Annars kommer den här funktionen tillbaka Sann.

IsFinite(73); // true isFinite(-1/0); // false isFinite(Infinity); // false isFinite(NaN); // false isFinite("Text"); // falskt

Utöver den globala isFinite-funktionen har JavaScript även Number.isFinite-metoden. Det, till skillnad från isFinite, tvingar inte argumentet att konverteras till ett tal.

IsFinite("73"); // true Number.isFinite("73"); // falskt

isNaN-funktionen

Funktionen isNaN är till för att avgöra om ett argument är ett tal eller kan konverteras till ett. Om så är fallet returnerar isNaN-funktionen false. Annars återgår det sant.

IsNaN(NaN); //true isNaN("25px"); //sant, eftersom 20px är inte ett tal isNaN(25.5); //falskt är NaN("25,5"); //falskt ärNaN(" "); //falskt, eftersom ett mellanslag eller flera mellanslag omvandlas till 0 ärNaN(null); //falskt, eftersom nollvärdet omvandlas till 0 isNaN(sant); //falskt, eftersom sant omvandlas till 1 ärNaN(falskt); //falskt, eftersom falskt värde konverteras till 0

Om den här åtgärden måste utföras utan en typcast, använd sedan metoden Number.isNaN. Denna metod har introducerats i språket sedan ECMAScript 6.

Hur konverterar man uttryckligen en sträng till ett tal?

Du kan uttryckligen casta en sträng till ett nummer med följande metoder:

1. Använd unär operator + Den ska placeras före värdet.

+"7,35"; // 7.35 +"text"; // NaN

Denna metod ignorerar mellanslag i början och slutet av raden, såväl som \n (radmatning).

+"7,35"; //7.35 +"7.35\n"; //7,35

Använder sig av den här metoden Observera att en tom sträng eller en sträng som består av mellanslag och \n konverteras till siffran 0. Dessutom konverterar den även nolldatatypen och booleaner till ett tal.

Null; //0 +sant; //1 +falskt; //0 +" "; //0

2. Funktionen parseInt . Denna funktion är utformad för att konvertera argument till ett heltal. I motsats till att använda unär operator +, den här metoden låter dig konvertera en sträng till ett tal, där inte alla tecken är numeriska. Den börjar konvertera strängen, med början från det första tecknet. Och så snart den stöter på ett tecken som inte är ett numeriskt tecken, stoppar denna funktion sitt arbete och returnerar det resulterande talet.

ParseInt("18px"); //18 parseInt("33,3%"); //33

Denna funktion kan fungera med olika talsystem (binära, oktala, decimala, hexadecimala). Indikeringen av talsystemets bas utförs med hjälp av 2 argument.

ParseInt("18px", 10); //18 parseInt("33,3%", 10); //33 parseInt("101",2); //5 parseInt("B5",16); //181

Utöver parseInt-funktionen har JavaScript metoden Number.parseInt. Denna metod skiljer sig inte från parseInt-funktionen och introducerades till JavaScript med ECMASCRIPT 2015(6)-specifikationen.

3. Funktionen parseFloat . Funktionen parseFloat liknar parseInt , förutom att den låter dig konvertera argumentet till ett bråktal.

ParseFloat("33,3%"); //33.3

Dessutom har parseFloat-funktionen, till skillnad från parseInt, inte 2 argument, och därför försöker den alltid betrakta en sträng som ett tal i decimalsystem beräkning.

ParseFloat("3.14"); parseFloat("314e-2"); parseFloat("0,0314E+2");

Förutom funktionen parseFloat har JavaScript metoden Number.parseFloat. Denna metod skiljer sig inte från parseFloat-funktionen och introducerades till JavaScript med ECMASCRIPT 2015(6)-specifikationen.

Konvertera nummer till sträng

Du kan förvandla ett nummer till en sträng med metoden toString.

(12.8).toString(); //"12,8"

ToString-metoden låter dig också specificera basen för talsystemet, med hänsyn till vilken du uttryckligen måste casta numret till strängen:

(255).toString(16); //"ff"

Hur man kontrollerar om en variabel är ett tal

Du kan avgöra om värdet på en variabel är ett tal med någon av följande metoder:

1. Använda funktionerna isNaN och isFinite:

// myVar är en variabel om (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar är ett tal eller kan kastas till det);

Som en funktion:

// function function isNumeric(value) (return !isNaN(parseFloat(value)) && isFinite(parseFloat(value)); ) // usage var myVar = "12px"; console.log(isNumeric(myVar)); //Sann

Denna metod låter dig avgöra om det angivna värdet är ett tal eller kan konverteras till det. Denna variant räknar inte en tom sträng, en sträng av mellanslag, null , Infinity , -Infinity , true och false som ett tal.

2. Med hjälp av typen av operator och isFinite, är NaN-funktioner:

// funktion som kontrollerar om värdet är en talfunktion ärNumber(värde) (returtypvärde === "(!LANG:tal" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Denna funktion avgör om det angivna värdet är av typen Number och inte är ett av specialvärdena Infinity, -Infinity och NaN. Om så är fallet, returnerar denna funktion sant.

3. Använda ECMAScript 6 Number.isInteger(value)-metoden. Denna metod låter dig avgöra om det angivna värdet är ett heltal.

Number.isInteger("20"); //falskt, eftersom denna metod översätter inte strängen till ett tal Number.isInteger(20); //sant, eftersom givet värde är ett tal

Jämna och udda tal

Du kan kontrollera om ett tal är jämnt eller udda med hjälp av följande funktioner:

// Funktion för att kontrollera om ett tal är jämn funktion ärJämn(n) ( return n % 2 == 0; ) // Funktion för att kontrollera om ett tal är udda funktion isOdd(n) ( return Math.abs(n % 2) == 1; )

Men innan du utför en sådan kontroll är det önskvärt att se till att det angivna värdet är ett nummer:

värde=20; if (Number.isInteger(value)) ( if (isEven(value)) ( console.log("Number " + value.toString() + " - jämn"); ) )

Primtal i Javascript

Betrakta ett exempel där vi härleder med Javascript primtal från 2 till 100.

// En funktion som kontrollerar om ett tal är primtal funktion isPrime(värde) (if (isNaN(värde) || !isFinite(värde) || värde%1 || värde< 2) return false; var max=Math.floor(Math.sqrt(value)); for (var i = 2; i< = max; i++) { if (value%i==0) { return false; } } return true; } // создать массив, который будет содержать простые числа от 2 до 100 var primaryNumber = ; for (var i = 2; i <= 100; i++) { if(isPrime(i)) primaryNumber.push(i); } // вывести в консоль простые числа от 2 до 100 console.log(primaryNumber);

Avrunda ett tal i Javascript

Det finns olika sätt att avrunda ett bråktal till ett heltalsvärde i JavaScript.

1. Använd metoderna Math.floor , Math.ceil och Math.round speciellt utformade för detta. Math.floor-metoden avrundar ett bråktal nedåt till närmaste heltal, dvs. kasserar helt enkelt bråkdelen. Math.ceil avrundar ett bråktal uppåt till närmaste heltal. Math.round avrundar ett tal uppåt eller nedåt beroende på värdet på bråkdelen. Om bråkdelen är större än eller lika med 0,5, uppåt, annars är rullningen nedåt.

Console.log(Math.floor(7.9)); //7 console.log(Math.ceil(7.2)); //8 console.log(Math.round(7.5)); //åtta

2. Använda metoden toFixed (precision). Denna metod avrundar bråkdelen av ett tal till den angivna precisionen. Avrundningsresultatet returneras som en sträng.

Console.log(7.987.toFixed(2)); //"7,99"

Om det inte finns tillräckligt med decimaler för att bilda den angivna noggrannheten för talet, är det utfyllt med nollor.

Console.log(7.987.toFixed(5)); //"7,98700"

3. Genom toPrecision(precision)-metoden. Denna metod representerar ett tal med den specificerade precisionen. Samtidigt kan han avrunda inte bara bråktalet, utan också hela delen av talet. Det resulterande talet kan representeras med denna metod beroende på resultatet i en fixpunkt eller i exponentiell form.

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. Använda logiska NOT- eller OR-operatorer.

//via dubbel logisk negation console.log(~~7.9); //7 // genom att använda logiskt ELLER med noll: console.log(7.9^0); //7

Heltal och bråkdel av ett tal

Du kan få heltalsdelen av ett tal med metoderna Math.floor() och parseInt():

Console.log(Math.floor(7.21)); // 7 console.log(parseInt(7.21)); // 7

Du kan få bråkdelen av ett tal med hjälp av operatorn procent (%). Denna operatör returnerar resten som kommer att erhållas genom att dividera det första talet med det andra. I det här fallet ska 1 användas som 2:a siffran.

Console.log(7,21%1); // 0,209999999999999996 // exakt till 2 decimaler console.log((7,21%1).toFixed(2)); // "0,21"

Dessutom kan bråkdelen också erhållas med hjälp av beräkningar:

var nummer = 7,21; var fraktionNumber = tal - Math.floor(Math.abs(tal)); console.log(fraktionsnummer); // 0,209999999999999996

Är talet delbart

Du kan avgöra om ett tal är jämnt delbart med hjälp av procentoperatorn:

varnummer = 9; // om resten av att dividera talet med 3 är 0, ja, annars nej if (tal%3==0) ( console.log ("Siffran " + siffran + " är delbar med 3"); ) else ( console. log("Nummer " + nummer + " är inte delbart med 3"); )

Nummerformatering

I JavaScript låter metoden toLocaleString() dig formatera utdata från ett nummer enligt språkinställningarna för operativsystemet).

Låt oss till exempel formatera ett nummer enligt de regionala standarder som är installerade i systemet som standard:

var nummer = 345,46; console.log(nummer.toLocaleString()); //"345,46"

Låt oss till exempel formatera ett nummer i enlighet med de regionala standarderna i Ryssland (ru):

Console.log((108.1).toLocaleString("ru-RU")); //"108.1"

Den här metoden kan också användas för att formatera ett tal som en valuta:

Console.log((2540.125).toLocaleString("ru-RU",(stil:"valuta", valuta:"RUB"))); //"2,540.13 ₽" console.log((89.3).toLocaleString("ru-RU",(stil:"valuta", valuta:"USD"))); //"$89.30" console.log((2301.99).toLocaleString("ru-RU",(stil:"valuta", valuta:"EUR"))); //"2 301,99 €"

Representerar ett tal i procent:

Console.log((0.45).toLocaleString("ru-RU",(stil:"procent"))); //"45 %"

Dela upp numret i siffror (useGrouping-egenskap):

Console.log((125452.32).toLocaleString("ru-RU",(useGrouping:true))); //"125 452,32"

Skriv ut ett nummer med ett visst antal siffror (2) efter decimalkomma:

Console.log((1240.4564).toLocaleString("ru-RU",(minimumFractionDigits:2, maximumFractionDigits:2))); //"1240,46"

Nummerjämförelse

Följande operatorer används för att jämföra tal i JavaScript: == (lika med), != (inte lika med), > (större än),< (меньше), >= (större än eller lika),<= (меньше или равно).

Låt oss till exempel jämföra två siffror:

Console.log(2>3); //false console.log(5>=3); //Sann

När man jämför tal med en bråkdel är det nödvändigt att ta hänsyn till de fel som kan uppstå under dessa beräkningar.

Till exempel, i JavaScript är summan av talen (0,2 + 0,4) inte lika med 0,6:

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

Fel uppstår eftersom alla beräkningar är datorer eller andra elektronisk anordning producerar i 2 talsystem. De där. innan du utför några åtgärder måste datorn först konvertera talen som presenteras i uttrycket till 2-siffersystemet. Men inget decimaltal kan representeras exakt i det andra talsystemet.

Till exempel konverteras talet 0,25 10 till binärt exakt.

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

Till exempel kan siffran 0,2 10 endast konverteras till 2-systemet med en viss noggrannhet:

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

Som ett resultat kommer dessa fel att påverka beräkningen av summan av två tal och jämförelseresultaten. De där. det visar sig att JavaScript faktiskt kommer att se denna post enligt följande:

0.6000000000000001==0.6

Vid beräkning eller visning av tal med bråkdel måste man alltid ange med vilken precision detta ska göras.

Jämför till exempel tal upp till 2 decimaler med metoderna toFixed() och toPrecision():

//metod toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //toPrecision()-metod console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //Sann

Grundläggande matematikoperationer

JavaScript har följande matematiska operatorer: + (addition), - (subtraktion), * (multiplicera), / (division), % (återstoden av division), ++ (öka värdet med 1), -- (minska värdet med 1 ).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, dvs. 6:3=2 => 6-3*2 => vila(0) 5%2 //1, dvs. 5:2=2(.5) => 5-2*2 => vila(1) 7.3%2 //1.3, d.v.s. 7.3:2=3(.65) => 7.3-2*3 => vila(1.3) //tecknet för operationsresultatet % är lika med tecknet för det första värdet -9%2.5 //-1.5, dvs. 9:2.5=3(.6) => 9-2.5*3 => vila(1.5) -9%-2.5 //-1.5, d.v.s. 9:2.5=3(.6) => 9-2.5*3 => vila(1.5) -2%5 //-2, dvs. 2:5=0(.4) => 2-5*0 => vila(2) x = 3; konsollogg(x++); //visar 3 och sätter sedan y till 4 console.log(x); //4 x = 3; konsollogg(++x); //uppsättningar 4 och utgångar x = 5; konsollogg(x--); //utgångar 5, y sätter sedan 4 console.log(x); //4 x = 5; konsollogg(--x); //sätter till 4 och utdata Dessutom finns det kombinerade operatorer i JavaScript: 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; konsollogg(x); //9 x = 3; y=6; x-=y; konsollogg(x); //-3 x = 3; y=6; x*=y; konsollogg(x); //18 x = 3; y=6; x/=y; konsollogg(x); //0,5 x = 3; y=6; x%=y; konsollogg(x); //3