Javascript naar beneden afgerond. Eenvoudige afrondingsregels in javascript. We bestuderen methoden en brengen ze in de praktijk

Heel vaak geven berekeningen in JavaScript niet precies de gewenste resultaten. Natuurlijk kunnen we met getallen doen wat we willen: naar boven of naar beneden afronden, bereiken instellen, onnodige getallen afsnijden tot een bepaald aantal decimalen, het hangt allemaal af van wat je in de toekomst met dit getal wilt doen.

Waarom is afronding nodig?

Een van de interessante aspecten van JavaScript is dat het eigenlijk geen gehele getallen opslaat; we werken meteen met drijvende-kommagetallen. Dit, gecombineerd met het feit dat veel fractionele waarden niet in een eindig aantal decimalen kunnen worden uitgedrukt, kunnen we in JavaScript de volgende resultaten krijgen:

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Voor praktische doeleinden doet deze onnauwkeurigheid er niet toe, in ons geval hebben we het over een fout in quintiljoen delen, maar dit kan sommigen teleurstellen. We kunnen ook enigszins vreemde resultaten krijgen als we werken met getallen die valuta's, percentages of bestandsgroottes vertegenwoordigen. Om deze onnauwkeurigheden te corrigeren, hoeven we alleen maar de resultaten af te ronden, en het is voldoende om de decimale precisie in te stellen.

Afrondingsgetallen hebben praktische toepassing, kunnen we een getal binnen een bepaald bereik manipuleren. We willen de waarde bijvoorbeeld afronden naar het dichtstbijzijnde gehele getal in plaats van alleen met het decimale deel te werken.

Decimale getallen afronden

Om af te snijden decimaal getal, gebruik toFixed of de toPrecision-methode. Beiden nemen één enkel argument, dat respectievelijk bepaalt hoeveel significante cijfers(d.w.z. het totale aantal cijfers dat in een getal wordt gebruikt) of decimalen (het getal erna). decimaalteken) moet het resultaat bevatten:

Als er geen argument is gedefinieerd voor toFixed(), wordt dit standaard ingesteld gelijk aan nul, wat 0 decimalen betekent, heeft het argument maximale waarde, gelijk aan 20.
Als er geen argument wordt gegeven voor precisie, blijft het getal ongemoeid

laat randNum = 6,25; randNum.toFixed(); > "6" Math.PI.naarPrecisie(1); > "3" randNum = 87,335; randNum.toFixed(2); > "87,33" randNum = 87,337; randNum.toPrecision(3); > "87,3"
Zowel de methoden toFixed() als toPrecision() retourneren een tekenreeksrepresentatie van het resultaat, geen getal. Dit betekent dat bij het optellen van een afgeronde waarde met randNum er een aaneenschakeling van tekenreeksen ontstaat in plaats van een som van getallen:

Stel randNum = 6,25; laat afgerond = randNum.toFixed(); // "6" console.log(randNum + afgerond); > "6.256"
Als je wilt dat het resultaat zo is numeriek type gegevens, dan moet u parseFloat toepassen:

Stel randNum = 6,25; laat afgerond = parseFloat(randNum.toFixed(1)); console.log(afgerond); > 6.3
Houd er rekening mee dat waarden van 5 worden afgerond, behalve in zeldzame gevallen.

De methoden toFixed() en toPrecision() zijn handig omdat ze niet alleen kunnen knippen fractioneel deel, maar ook om decimalen toe te voegen, wat handig is bij het werken met valuta:

Laat WholeNum = 1 laat dollarsCents = WholeNum.toFixed(2); console.log(dollarscent); > "1,00"
Merk op dat toPrecision het resultaat in wetenschappelijke notatie zal opleveren als het aantal gehele getallen groter is dan de precisie zelf:

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

Hoe u afrondingsfouten met decimalen kunt voorkomen

In sommige gevallen rondt toFixed en toPrecision de waarde 5 naar beneden en naar boven af:

Laat numTest = 1,005; numTest.toFixed(2); > "1,00"
Het resultaat van de bovenstaande berekening had 1,01 moeten zijn, en niet 1. Als je een soortgelijke fout wilt voorkomen, kunnen we de oplossing gebruiken die is voorgesteld door Jack L Moore, die exponentiële getallen gebruikt voor de berekening:

Functie round(waarde, decimalen) ( return Number(Wiskunde.round(waarde+"e"+decimalen)+"e-"+decimalen); )
Nu:

Rond(1.005,2); > 1,01
Als u een robuustere oplossing wilt dan hierboven weergegeven, kunt u naar MDN gaan.

Machine-epsilon-afronding

In ES6 is een alternatieve methode voor het afronden van decimale getallen geïntroduceerd. Machine-epsilon-afronding biedt een redelijke foutmarge bij het vergelijken van twee drijvende-kommagetallen. Zonder afronding kunnen vergelijkingen soortgelijke resultaten opleveren:

0,1 + 0,2 === 0,3 > onwaar
We gebruiken Math.EPSILON in onze functie om een geldige vergelijking te krijgen:

Functie epsEqu(x, y) ( retourneert Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
De functie heeft twee argumenten nodig: het eerste is de huidige berekening, het tweede is het verwachte resultaat. Het retourneert een vergelijking van de twee:

EpsEqu(0,1 + 0,2, 0,3) > waar
Alle moderne browsers ondersteunen al ES6 wiskundige functies maar als je ondersteuning wilt in browsers zoals IE 11, gebruik dan polyfills.

Het fractionele deel bijsnijden

Alle hierboven gepresenteerde methoden kunnen worden afgerond op decimale getallen. Om een getal eenvoudigweg terug te brengen tot twee decimalen, moet u het eerst vermenigvuldigen met 100 en vervolgens het resulterende resultaat delen door 100:

Functie afgekapt(num) ( return Math.trunc(num * 100) / 100; ) afgekapt(3,1416) > 3,14
Als u de methode wilt aanpassen aan een willekeurig aantal decimalen, kunt u bitsgewijze dubbele ontkenning gebruiken:

Functie afgekapt(num, decimalPlaces) ( let numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Nu:

Laat randInt = 35,874993; afgekapt(randInt,3); > 35,874

Rond af naar het dichtstbijzijnde getal

Gebruik Math.round() om een decimaal getal naar boven of beneden af te ronden naar het dichtstbijzijnde getal, afhankelijk van wat we het dichtst in de buurt hebben:

Rekenronde(4.3) > 4 Rekenronde(4.5) > 5
Houd er rekening mee dat "de helft van de waarde", 0,5, wordt afgerond naar grote kant volgens de regels van de wiskunde.

Rond naar beneden af op het dichtstbijzijnde gehele getal

Als je altijd naar beneden wilt afronden, gebruik dan Math.floor:

Wiskundevloer(42.23); > 42 Wiskundevloer(36.93); > 36
Houd er rekening mee dat naar beneden afronden voor alle getallen geldt, ook voor negatieve getallen. Stel je een wolkenkrabber voor met een oneindig aantal verdiepingen, inclusief verdiepingen op het onderste niveau (die negatieve getallen vertegenwoordigen). Als je in een lift zit lager niveau tussen 2 en 3 (wat een waarde van -2,5 vertegenwoordigt), brengt Math.floor je naar -3:

Wiskundevloer(-2,5); > -3
Maar als u deze situatie wilt vermijden, gebruikt u Math.trunc , dat in alle gevallen wordt ondersteund moderne browsers(behalve IE/Edge):

Wiskunde.trunc(-41.43); > -41
Op MDN vindt u een polyfill die ondersteuning biedt voor Math.trunc in browsers en IE/Edge.

Rond af naar het dichtstbijzijnde gehele getal

Aan de andere kant, als je altijd naar boven moet afronden, gebruik dan Math.ceil. Nogmaals, onthoud de oneindige lift: Math.ceil gaat altijd "omhoog", ongeacht of het getal negatief is of niet:

Math.ceil(42.23); > 43 Wiskundig plafond(36,93); > 37 Math.ceil(-36.93); > -36

Naar boven/beneden afronden op het gewenste getal

Als we willen afronden naar het dichtstbijzijnde veelvoud van 5, is de eenvoudigste manier om een functie te maken die het getal door 5 deelt, het rondt en vervolgens met hetzelfde bedrag vermenigvuldigt:

Functie roundTo5(num) ( retourneert Math.round(num/5)*5; )
Nu:

RondTo5(11); > 10
Als u wilt afronden op veelvouden van uw waarde, gebruiken we meer algemene functie, waarbij de beginwaarde en een veelvoud erin worden doorgegeven:

Functie roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )
Nu:

Laat aanvankelijk getal = 11; laat meerdere = 10; roundToMultiple(beginnummer, meerdere); > 10;

Een getal in een bereik corrigeren

Er zijn veel gevallen waarin we een waarde van x willen verkrijgen die binnen een bereik ligt. We hebben bijvoorbeeld misschien een waarde tussen 1 en 100 nodig, maar uiteindelijk kwamen we uit op een waarde van 123. Om dit op te lossen, kunnen we min (retourneert de kleinste van een reeks getallen) en max (retourneert de grootste van een reeks getallen) gebruiken. van cijfers). In ons voorbeeld loopt het bereik van 1 tot 100:

Laat ondergrens = 1; laat bovengrens = 100; laat numInput = 123; laat vastgeklemd = Math.max(lowBound, Math.min(numInput, highBound)); console.log (geklemd); > 100;
Nogmaals, we kunnen de bewerking opnieuw gebruiken en het geheel in een functie verpakken, met behulp van de oplossing voorgesteld door Daniel X. Moore:

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

NumInput.clamp(ondergrens, bovengrens); > 100;

Gaussiaanse afronding

Bij Gaussiaanse afronding, ook wel bankiersafronding genoemd, wordt afgerond naar het dichtstbijzijnde even getal. Deze afrondingsmethode werkt zonder statistische fouten. De beste oplossing werd voorgesteld door Tim Down:

Functie gaussRound(num, decimalPlaces) ( let d = decimalPlaces || 0, m = Math.pow(10, d), n = +(d ? num * m: num).toFixed(8), i = Math.floor (n), f = n - i, e = 1e-8, r = (f > 0,5 - e && f< 0.5 + e) ? ((i % 2 == 0) ? i: i + 1) : Math.round(n); return d ? r / m: r; }
Nu:

GaussRond(2,5) > 2 gaussRond(3,5) > 4 gaussRond(2,57,1) > 2,6
Decimaal in CSS:

Omdat JavaScript vaak wordt gebruikt om positionele mappings voor HTML-elementen te maken, vraag je je misschien af wat er zou gebeuren als we decimale waarden voor onze elementen zouden genereren:

#box ( breedte: 63.667731993px; )
Het goede nieuws is dat moderne browsers decimale waarden in het blokmodel zullen respecteren, inclusief percentage- of pixeleenheden.

Sorteren

Heel vaak moeten we bepaalde elementen sorteren. We hebben bijvoorbeeld een reeks spelrecords en deze moeten worden georganiseerd in aflopende volgorde van spelersrang. Helaas, standaard methode sort() heeft een aantal verrassende beperkingen: het werkt goed met gewone Engelse woorden, maar valt onmiddellijk uit elkaar als het cijfers, unieke tekens of woorden tegenkomt in hoofdletter.

Alfabetisch sorteren

Het lijkt erop dat het alfabetisch sorteren van een array een eenvoudige taak zou moeten zijn:

Let fruit = ["pompoen", "abrikoos", "meloen"]; fruit.sort(); > "abrikoos", "pompoen", "meloen"]
We komen echter een probleem tegen zodra een van de elementen in hoofdletters staat:

Let fruit = ["pompoen", "abrikoos", "Cantalope"]; fruit.sort(); > "Cantaloupe", "abrikoos", "pompoen"]
Dit komt omdat de sorteerder standaard het eerste teken vergelijkt dat in Unicode wordt weergegeven. Unicode is een unieke code voor elk personage, ongeacht het platform, ongeacht het programma, ongeacht de taal. Als u bijvoorbeeld naar de codetabel kijkt, heeft het teken “a” de waarde U+0061 (in hexadecimaal systeem 0x61), terwijl het teken "C" de code U+0043 (0x43) heeft, die eerder in de Unicode-tabel voorkomt dan het teken "a".

Om een array te sorteren die hoofdletters met gemengde hoofdletters kan bevatten, moeten we alle elementen tijdelijk converteren naar kleine letters, of definieer uw eigen sorteervolgorde met behulp van de localeCompare() methode met enkele argumenten. In een dergelijk geval is het in de regel beter om onmiddellijk een functie te creëren voor herhaald gebruik:

Functie alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("gevoeligheid": "basis")); )); ) let fruit = ["pompoen ", "abrikoos", "meloen"]; alphaSort(fruit) >
Als u een array omgekeerd wilt sorteren alfabetische volgorde, wissel gewoon de posities van a en b in de functie:

Functie alphaSort(arr) ( arr.sort(function (a, b) ( return b.localeCompare(a, "en", ("gevoeligheid": "basis")); )); ) let fruit = ["pompoen ", "abrikoos", "meloen"]; alphaSort(fruit) > ["Cantaloupe", "pompoen", "abrikoos"]
Hier is het vermeldenswaard dat localeCompare wordt gebruikt met argumenten, we moeten ook onthouden dat het wordt ondersteund door IE11+, voor oudere versies van IE kunnen we het zonder argumenten gebruiken, en in kleine letters:

Functie caseSort(arr) ( arr.sort(function (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) let fruit = ["pompoen", "abrikoos", "meloen"]; caseSort(fruit) > ["abrikoos", "pompoen", "meloen"]

Numeriek sorteren

Dit alles is niet van toepassing op het voorbeeld waar we het hierboven over hadden over de reeks spelrecords. Met sommigen numerieke arrays sorteren werkt gewoon perfect, maar op een gegeven moment kan het resultaat onvoorspelbaar zijn:

Laat highScores = ; hogeScores.sort(); >
Het punt is dat de sort()-methode een lexicografische vergelijking uitvoert: wat betekent dat de getallen worden omgezet in een string en dat de vergelijkingen opnieuw worden gemaakt door het eerste teken van die string te matchen in de volgorde van de tekens in de Unicode-tabel . Daarom moeten we opnieuw onze sorteervolgorde definiëren:

Laat highScores = ; highScores.sort(function(a,b) ( retourneert a - b; )); >
Nogmaals, om getallen in omgekeerde volgorde te sorteren, verwisselt u de posities van a en b in de functie.

Sorteren van een JSON-achtige structuur

En tot slot, als we een JSON-achtige datastructuur hebben die wordt weergegeven als een reeks gamerecords:

Laat scores = [ ( "naam": "Daniel", "score": 21768 ), ( "naam": "Michael", "score": 33579 ), ( "naam": "Alison", "score": 38395 ];
In ES6+ kunt u pijlfuncties gebruiken:

Scores.sort((a, b) => b.score - a.score));
Voor oudere browsers die deze ondersteuning niet hebben:

Scores.sort(functie(a, b) ( retourneer a.score - b.score ));
Zoals je kunt zien, is sorteren in JavaScript nogal obscuur. Ik hoop dat deze voorbeelden het leven op de een of andere manier gemakkelijker zullen maken.

Werken met machtsfuncties

Machtsverheffen is een bewerking die oorspronkelijk werd gedefinieerd als het resultaat van het herhaaldelijk vermenigvuldigen van een natuurlijk getal met zichzelf; de vierkantswortel van a is het getal dat a geeft als het wordt gekwadrateerd. We zouden deze functies voortdurend kunnen gebruiken het dagelijkse leven in wiskundelessen, inclusief het berekenen van gebieden, volumes of zelfs fysieke modellering.

In JavaScript wordt de machtsfunctie weergegeven als Math.pow(), in de nieuwe ES7-standaard werd deze geïntroduceerd nieuwe exploitant machtsverheffen - " * * ".

Machtsverheffing

Om een getal tot de macht nde te verheffen, gebruik je de functie Math.pow(), waarbij het eerste argument het getal is dat tot de macht wordt verheven, het tweede argument de exponent:

Wiskunde.pow(3,2) > 9
Deze notatievorm betekent 3 kwadraat, oftewel 3×3, wat leidt tot het resultaat 9. Er kan uiteraard nog een ander voorbeeld worden gegeven:

Wiskunde.pow(5,3); > 125
Dat wil zeggen, 5 in blokjes, of 5 × 5 × 5, is gelijk aan 125.

ECMAScript 7 is volgende versie JavaScript kunnen we in principe de nieuwe voorgestelde machtsverheffingsoperator gebruiken - * *, deze vorm van notatie kan beschrijvender zijn:

3 ** 2 > 9
Op op dit moment Ondersteuning voor deze operator is vrij beperkt, dus het gebruik ervan wordt niet aanbevolen.

De power-functie kan in verschillende situaties nuttig zijn. Een eenvoudig voorbeeld, het berekenen van het aantal seconden in een uur: Math.pow (60,2).

Vierkant- en kubuswortels

Math.sqrt() en Math.cbrt() zijn het tegenovergestelde van Math.pow(). Zoals we ons herinneren, is de vierkantswortel van a het getal dat a geeft in het kwadraat.

Wiskunde.sqrt(9) > 3
Tegelijkertijd is de derdemachtswortel van a een getal dat a geeft als het wordt verheven tot een kubus.

Math.cbrt(125) > 5
Math.cbrt() is pas onlangs geïntroduceerd in de JavaScript-specificatie en wordt daarom alleen ondersteund in moderne browsers: Chrome 38+, Firefox en Opera 25+ en Safari 7.1+. Dat zul je merken Internet Explorer staat niet op deze lijst, maar je vindt een polyfill op MDN.

Voorbeelden

Natuurlijk kunnen we niet-gehele waarden gebruiken in een van deze functies:

Wiskunde.pow(1.25, 2); > 1,5625 Math.cbrt(56,57) > 3,8387991760286138
Houd er rekening mee dat dit ook redelijk goed werkt bij het gebruik van negatieve argumentwaarden:

Wiskunde.pow(-5,2) > 25 Wiskunde.pow(10,-2) > 0,01
Dit werkt echter niet voor vierkantswortel:

Wiskunde.sqrt(-9) > NaN
Van wiskundige analyse We weten dat we met denkbeeldig getal de vierkantswortels van negatieve getallen bedoelen. En dit kan ons leiden naar een andere techniek om mee te werken complexe getallen, maar dat is een ander verhaal.

Je kunt fractionele waarden gebruiken in Math.pow() om vierkante en te vinden kubus wortels cijfers. Vierkantswortel gebruikt exponent 0,5:

Wiskunde.pow(5, 0,5); // = Math.sqrt(5) = 5 ** (1/2) > 2,23606797749979
Vanwege de grillen van drijvende komma kun je het juiste resultaat echter niet precies raden:

Wiskunde.pow(2,23606797749979,2) > 5,000000000000001
In dergelijke situaties zult u uw toevlucht moeten nemen tot het afsnijden van tekens van het getal of het afronden naar een bepaalde waarde.

Sommige mensen verwarren om onbekende redenen in JavaScript de functie Math.pow() met Math.exp() , wat de exponentiële functie is voor getallen in het algemeen. Let op: binnen Engels"exponent" wordt vertaald als "exponent", dus dit is waarschijnlijker van toepassing op Engelssprekenden, hoewel er alternatieve namen voor exponent zijn, zoals index, macht.

Wiskundige constanten

Het werken met wiskunde in JavaScript wordt eenvoudiger gemaakt door een aantal ingebouwde constanten. Deze constanten zijn eigenschappen van het Math-object. Het is vermeldenswaard dat constanten in hoofdletters worden geschreven en niet in de CamelCase-notatie.

Alleen geregistreerde gebruikers kunnen deelnemen aan het onderzoek. , Alsjeblieft.

Tags: tags toevoegen

In dit artikel zullen we gedetailleerd kijken naar getallen, wiskundige operatoren, manieren om een getal in een string om te zetten en vice versa, evenals vele andere belangrijke punten.

isFinite-functie

Met de functie isFinite kunt u controleren of een argument een eindig getal is.

Als antwoord deze functie retourneert false als het argument Infinity , -Infinity , NaN is of naar een van deze speciale wordt gecast numerieke waarden. Anders keert deze functie terug WAAR.

IsEind(73); // waar isFinite(-1/0); // false isFinite(oneindigheid); // false isFinite(NaN); // false isFinite("Tekst"); // vals

Behalve mondiale functie isFinite JavaScript heeft ook een methode genaamd Number.isFinite . In tegenstelling tot isFinite wordt het argument niet gedwongen om naar een getal te worden geconverteerd.

IsFinite("73"); // waar Aantal.isFinite("73"); // vals

isNaN-functie

De isNaN-functie is ontworpen om te bepalen of een argument een getal is of naar één getal kan worden geconverteerd. Als dat zo is, retourneert de functie isNaN false. Anders retourneert het waar.

IsNaN(NaN); //waar isNaN("25px"); //waar, omdat 20px is geen getal isNaN(25,5); //valse isNaN("25.5"); //valse isNaN(" "); //vals, omdat een spatie of meerdere spaties wordt omgezet naar 0 isNaN(null); //vals, omdat nulwaarde omgezet naar 0 isNaN(waar); //vals, omdat true wordt omgezet naar 1 isNaN(false); //vals, omdat waarde vals omgezet naar 0

Als deze actie zonder typecast moet worden uitgevoerd, gebruik dan de Number.isNaN-methode. Deze methode werd geïntroduceerd in de taal vanaf ECMAScript 6.

Hoe converteer je een string expliciet naar een getal?

U kunt een tekenreeks expliciet naar een getal converteren met behulp van de volgende methoden:

1. Gebruik unaire operator +, die vóór de waarde moet worden geplaatst.

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

Deze methode negeert spaties aan het begin en einde van de regel, evenals \n (regelinvoer).

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

Gebruiken deze methode het is noodzakelijk om aandacht te besteden aan het feit dat lege tekenreeks of een string bestaande uit spaties en \n wordt geconverteerd naar het getal 0. Daarnaast wordt ook het type geconverteerd nul gegevens en Booleaanse waarden om te nummeren.

Nul; //0 +waar; //1 +onwaar; //0 +" "; //0

2. ParseInt-functie. Deze functie is ontworpen om te converteren argument voor geheel getal. In tegenstelling tot gebruik unaire operator +, deze methode Hiermee kunt u een tekenreeks naar een getal converteren, waarin niet alle tekens zijn numeriek. Het begint de string te converteren, beginnend bij het eerste teken. En zodra hij een niet-numeriek teken tegenkomt, stopt deze functie met werken en retourneert het resulterende getal.

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

Deze functie kan werken met verschillende systemen Getallen (binair, octaal, decimaal, hexadecimaal). De basis van het getalsysteem wordt gespecificeerd met behulp van 2 argumenten.

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

Naast de parseInt-functie beschikt JavaScript over de Number.parseInt-methode. Deze methode verschilt niet van de parseInt-functie en werd in JavaScript geïntroduceerd met de ECMASCRIPT 2015 (6)-specificatie.

3. parseFloat-functie. De functie parseFloat is vergelijkbaar met parseInt , behalve dat u hiermee het argument kunt converteren naar fractioneel getal.

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

Bovendien heeft de parseFloat-functie, in tegenstelling tot parseInt, geen 2 argumenten en probeert daarom de string altijd als een getal te behandelen decimaal systeem Afrekening.

ParseFloat("3.14"); parseFloat("314e-2"); parseFloat("0.0314E+2");

Naast de parseFloat-functie beschikt JavaScript over de Number.parseFloat-methode. Deze methode verschilt niet van de parseFloat-functie en werd in JavaScript geïntroduceerd met de ECMASCRIPT 2015 (6)-specificatie.

Een getal naar een string converteren

Je kunt een getal in een string veranderen met behulp van de toString-methode.

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

Met de toString-methode kunt u ook de basis van het getalsysteem opgeven, waarbij u er rekening mee houdt dat u het getal expliciet naar een string moet converteren:

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

Hoe u kunt controleren of een variabele een getal is

U kunt op een van de volgende manieren bepalen of de waarde van een variabele een getal is:

1. De functies isNaN en isFinite gebruiken:

// myVar is een variabele if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar is een getal of kan ernaar worden gecast);

Als functie:

// functie functie isNumeric(waarde) ( retour !isNaN(parseFloat(waarde)) && isFinite(parseFloat(waarde)); ) // gebruik var myVar = "12px"; console.log(isNumeric(mijnVar)); //WAAR

Met deze methode kunt u bepalen of gespecificeerde waarde getal of kan daartoe worden herleid. Deze optie telt de lege string, string met spaties, null, Infinity, -Infinity, true en false niet als een getal.

2. Gebruik type operator en functies isFinite, isNaN:

// functie die controleert of de waarde een getal is function isNumber(value) ( return typeof value === "number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Deze functie bepaalt of de opgegeven waarde van het type Number is en of het een van de speciale waarden Infinity, -Infinity en NaN is. Als dat zo is, retourneert deze functie waar.

3. Met behulp van de ECMAScript 6 Number.isInteger(value)-methode. Met deze methode kunt u bepalen of de opgegeven waarde een geheel getal is.

Getal.isInteger("20"); //vals, omdat deze methode converteert een string niet naar een getal Number.isInteger(20); //waar, omdat gegeven waarde is een getal

Even en oneven getallen

Met behulp van kunt u controleren of een getal even of oneven is volgende functies:

// Functie voor het controleren van een getal op de even pariteitsfunctie isEven(n) ( return n % 2 == 0; ) // Functie voor het controleren van een getal op de oneven pariteitsfunctie isOdd(n) ( return Math.abs(n % 2) == 1;

Maar voordat u een dergelijke controle uitvoert, is het raadzaam ervoor te zorgen dat de opgegeven waarde een getal is:

Waarde = 20; if (Number.isInteger(waarde)) ( if (isEven(waarde)) ( console.log("Number " + value.toString() + " - even"); ) )

Priemgetallen in Javascript

Laten we eens kijken naar een voorbeeld waaruit we voortkomen met behulp van Javascript priemgetallen van 2 tot 100.

// Functie die controleert of een getal een priemgetal is, functie isPrime(waarde) ( if (isNaN(waarde) || !isFinite(waarde) || waarde%1 || waarde< 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

Een getal afronden in Javascript

Er zijn verschillende manieren om een breuk op een geheel getal af te ronden in JavaScript.

1. Met behulp van de speciaal hiervoor ontworpen methoden Math.floor, Math.ceil en Math.round. De Math.floor-methode rondt een breuk naar beneden af op het dichtstbijzijnde gehele getal, d.w.z. gooit eenvoudigweg het fractionele deel weg. Math.ceil rondt een breuk af naar het dichtstbijzijnde gehele getal. Math.round rondt een getal naar boven of naar beneden af, afhankelijk van de waarde van het breukdeel. Als het fractionele deel groter is dan of gelijk is aan 0,5, dan omhoog, anders is de twist omlaag.

Console.log(Wiskunde.vloer(7.9)); //7 console.log(Math.ceil(7.2)); //8 console.log(Math.round(7.5)); //8

2. Gebruik de toFixed(precision)-methode. Deze methode rondt het fractionele deel van een getal af tot een bepaalde precisie. Het afrondingsresultaat wordt geretourneerd als een tekenreeks.

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

Als er niet genoeg decimalen zijn om de opgegeven precisie van het getal te bepalen, wordt het opgevuld met nullen.

Console.log(7.987.toFixed(5)); //"7.98700"

3. Met behulp van de toPrecision(nauwkeurigheid)-methode. Deze methode vertegenwoordigt een getal met een gespecificeerde precisie. Tegelijkertijd kan hij niet alleen de breuken, maar ook het hele deel van het getal afronden. Afhankelijk van het resultaat kan deze methode het resulterende getal presenteren met een vast punt of in exponentiële vorm.

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. Gebruik logische operatoren NIET of OF.

//via dubbele logische ontkenning console.log(~~7.9); //7 // door logische OR met nul te gebruiken: console.log(7.9^0); //7

Geheel en gebroken deel van een getal

U kunt het gehele deel van een getal verkrijgen met behulp van de methoden Math.floor() en parseInt():

Console.log(Wiskunde.vloer(7.21)); // 7 console.log(parseInt(7.21)); // 7

U kunt het fractionele deel van een getal verkrijgen met behulp van de percentageoperator (%). Deze exploitant retourneert de rest die wordt verkregen door het eerste getal door het tweede te delen. IN in dit geval U moet 1 als 2e getal gebruiken.

Console.log(7,21%1); // 0,20999999999999996 // nauwkeurig tot op 2 decimalen console.log((7,21%1).toFixed(2)); // "0,21"

Bovendien kan het fractionele deel ook worden verkregen met behulp van berekeningen:

Var-nummer = 7,21; var fractionNumber = getal - Math.floor(Math.abs(getal)); console.log(fractionNumber); // 0,20999999999999996

Is het getal deelbaar door een geheel getal?

Met de percentageoperator kunt u bepalen of een getal deelbaar is door een geheel getal:

Var-nummer = 9; // als de rest van getal gedeeld door 3 0 is, dan ja, anders nee als (getal%3==0) ( console.log ("Het getal " + getal + " is deelbaar door 3"); ) else ( console. log("Het getal " + getal + " is niet deelbaar door 3");

Getallen opmaken

In JavaScript wordt de getaluitvoer opgemaakt volgens de lokale standaarden ( taalinstellingen besturingssysteem) staat de methode toLocaleString() toe.

Laten we bijvoorbeeld een getal opmaken in overeenstemming met de regionale standaarden die standaard in het systeem zijn geïnstalleerd:

Var-nummer = 345,46; console.log(nummer.toLocaleString()); //"345.46"

Laten we het getal bijvoorbeeld opmaken in overeenstemming met de regionale normen van Rusland (ru):

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

Deze methode kan ook worden gebruikt om een getal als valuta op te maken:

Console.log((2540.125).toLocaleString("ru-RU",(stijl:"valuta", valuta:"RUB"))); //"2.540.13 ₽" console.log((89.3).toLocaleString("ru-RU",(stijl:"valuta", valuta:"USD"))); //"89.30 $" console.log((2301.99).toLocaleString("ru-RU",(stijl:"valuta", valuta:"EUR"))); //"€ 2.301,99"

Een getal weergeven als een percentage:

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

Een getal opsplitsen in cijfers (eigenschap useGrouping):

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

Druk een getal af met een bepaald aantal cijfers (2) achter de komma:

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

Vergelijking van cijfers

De volgende operatoren worden gebruikt om getallen in JavaScript te vergelijken: == (gelijk), != (niet gelijk), > (groter dan),< (меньше), >= (groter dan of gelijk aan),<= (меньше или равно).

Laten we bijvoorbeeld twee getallen vergelijken:

Console.log(2>3); //valse console.log(5>=3); //WAAR

Bij het vergelijken van getallen met een fractioneel deel moet rekening worden gehouden met de fouten die tijdens deze berekeningen kunnen optreden.

In JavaScript is de som van de getallen (0,2 + 0,4) bijvoorbeeld niet gelijk aan 0,6:

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

Er treden fouten op omdat alle berekeningen door een computer of iets anders worden gemaakt elektronisch apparaat produceert in 2-nummersysteem. Die. Voordat er enige actie wordt uitgevoerd, moet de computer eerst de getallen in de uitdrukking omzetten naar het tweede getalsysteem. Maar niet elk fractioneel decimaal getal kan exact worden weergegeven in het tweede getalsysteem.

Het getal 0,25 10 in binair systeem precies omgezet.

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

Het getal 0,2 10 kan bijvoorbeeld alleen met een bepaalde nauwkeurigheid worden omgezet in het 2-systeem:

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

Als gevolg hiervan hebben deze fouten invloed op de berekening van de som van twee getallen en de vergelijkingsresultaten. Die. Het blijkt dat JavaScript dit bericht feitelijk als volgt ziet:

0.6000000000000001==0.6

Bij het berekenen of weergeven van getallen met breuken moet u altijd de nauwkeurigheid aangeven waarmee u dit wilt doen.

Vergelijk bijvoorbeeld getallen met maximaal twee decimalen met behulp van de methoden toFixed() en toPrecision():

//methode 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)); //WAAR

Basis wiskundige bewerkingen

De volgende wiskundige operatoren bestaan in JavaScript: + (optellen), - (aftrekken), * (vermenigvuldigen), / (delen), % (modulo), ++ (een waarde verhogen met 1), -- (een waarde verlagen met 1).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, d.w.z. 6:3=2 => 6-3*2 => rust(0) 5%2 //1, d.w.z. 5:2=2(.5) => 5-2*2 => rust(1) 7,3%2 //1,3, d.w.z. 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //het teken van het resultaat van de %-bewerking is gelijk aan het teken van de eerste waarde -9%2.5 //-1.5 , d.w.z. 9:2,5=3(.6) => 9-2,5*3 => rust(1,5) -9%-2,5 //-1,5, d.w.z. 9:2.5=3(.6) => 9-2.5*3 => rust(1.5) -2%5 //-2, d.w.z. 2:5=0(.4) => 2-5*0 => rust(2) x = 3; console.log(x++); //voert 3 uit en stelt vervolgens 4 in console.log(x); //4 x = 3; console.log(++x); // stelt 4 in en voert x = 5 uit; console.log(x--); //voert 5 uit en stelt vervolgens 4 in console.log(x); //4 x = 5; console.log(--x); //sets 4 en outputs Daarnaast heeft JavaScript combinatieoperatoren: 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; j = 6; x+=y; console.log(x); //9 x = 3; j = 6; x-=y; console.log(x); //-3 x = 3; j = 6; x*=y; console.log(x); //18 x = 3; j = 6; x/=y; console.log(x); //0,5 x = 3; j = 6; x%=y; console.log(x); //3 Vaak leveren berekeningen resultaten op die buiten het gewenste bereik liggen. Als gevolg hiervan is het noodzakelijk om te implementeren JavaScript-afronding

tot een bepaalde waarde.

Waarom ronde getallen?

0.1 * 0.2; > 0.020000000000000004

JavaScript slaat geen gehele getallen op omdat hun waarden worden weergegeven als drijvende-kommagetallen. Veel breuken kunnen niet worden weergegeven als een getal met een specifiek eindig aantal decimalen, dus JavaScript kan resultaten als de volgende genereren: In de praktijk zal dit sindsdien geen enkel verschil maken waar we het over hebben

over een fout van 2 quintiljoen. Maar dit kan van invloed zijn op de resultaten als u werkt met getallen die valutawaarden, percentages of bestandsgrootte vertegenwoordigen. Daarom moet u dit met een bepaald decimaal doen.

Decimale getallen afronden

als voor toFixed() geen argument is opgegeven, is de standaardwaarde 0 , dat wil zeggen, geen decimalen; de maximale argumentwaarde is 20;
als er geen argument wordt gegeven aan toPrecision(), wordt het getal niet gewijzigd.

var randNum = 6,25; randNum.toFixed(); > "6" Math.PI.naarPrecisie(1); > "3" var randNum = 87,335; randNum.toFixed(2); > "87,33" var randNum = 87,337; randNum.toPrecision(3); > "87,3"

Opmerking

Zowel toFixed() als toPrecision retourneren een afgeronde tekenreeksrepresentatie van het resultaat, in plaats van een getal. Dit betekent dat het toevoegen van afgerond aan randNum zal resulteren in een aaneenschakeling van tekenreeksen in plaats van in één enkel getal:

console.log(randNum + afgerond); > "6.256"

Als u wilt dat JavaScript een getal afrondt op het dichtstbijzijnde honderdtal, gebruikt u parseFloat() :

var randNum = 6,25; var afgerond = parseFloat(randNum.toFixed(1)); console.log(afgerond); > 6.3

toFixed() en toPrecision() zijn ook handige methoden voor trimmen grote hoeveelheid decimalen. Dit is handig bij het werken met getallen die monetaire eenheden vertegenwoordigen:

var WholeNum = 1 var dollarsCents = WholeNum.toFixed(2); console.log(dollarscent); > "1,00"

Houd er rekening mee dat als een getal meer cijfers heeft dan de opgegeven precisie, toPrecision het resultaat in wetenschappelijk formaat zal uitvoeren:

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

Hoe u fouten kunt voorkomen bij het afronden van decimalen

In sommige gevallen wordt gebruik gemaakt van een vast en een precisiewerktuig JavaScript rondt 5 naar beneden af, en niet meer:

var numTest = 1,005; numTest.toFixed(2); > 1;

Het resultaat van het bovenstaande voorbeeld zou 1,01 moeten zijn, en niet 1. Als u deze fout wilt voorkomen, raad ik u aan exponentiële getallen te gebruiken:

function round(waarde, decimalen) ( return Number(Wiskunde.round(waarde+"e"+decimalen)+"e-"+decimalen); )

Sollicitatie:

rond(1.005,2); > 1,01

Als u een nog robuustere oplossing nodig heeft dan afronding, dan is deze verkrijgbaar op MDN.

Afronding met epsilon

Alternatieve methode JavaScript wordt afgerond op tienden werd geïntroduceerd in ES6 ( ook bekend als JavaScript 2015). « Machine-epsilon" biedt een redelijke foutmarge bij het vergelijken van twee getallen met drijvende komma. Zonder afronding kunnen vergelijkingen soortgelijke resultaten opleveren:

0,1 + 0,2 === 0,3 > onwaar

Math.EPSILON kan in een functie worden gebruikt om een geldige vergelijking te krijgen:

functie epsEqu(x, y) ( retourneert Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

De functie heeft twee argumenten nodig: één bevat de berekeningen, de tweede het verwachte (afgeronde) resultaat. Het retourneert een vergelijking van deze twee parameters:

epsEqu(0,1 + 0,2, 0,3) > waar

Alle moderne browsers ondersteunen ES6-wiskundige functies. Maar als u ondersteuning moet bieden in oudere browsers, moet u polyfills gebruiken.

Afkappen van decimale getallen

Alle eerder gepresenteerde methoden presteren JavaScript wordt afgerond op tienden. Inkorten positief getal tot twee decimalen, vermenigvuldig het met 100, kap het opnieuw af en deel het resultaat vervolgens door 100. Je hebt nodig:

functie afgekapt(num) ( retourneert Math.trunc(num * 100) / 100; ) afgekapt(3,1416) > 3,14

Als u iets flexibelers nodig heeft, kunt u de bitwise-operator gebruiken:

functie afgekapt(num, decimalPlaces) ( var numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )

Gebruik:

var randInt = 35,874993; afgekapt(randInt,3); > 35,874

Rond af naar het dichtstbijzijnde getal

Om te implementeren JavaScript wordt afgerond op het dichtstbijzijnde gehele getal, Math.round() wordt gebruikt:

Rekenronde(4.3) > 4 Rekenronde(4.5) > 5

Merk op dat " halve waarden", zoals .5, worden naar boven afgerond.

Rond naar beneden af op het dichtstbijzijnde gehele getal

Als je naar beneden wilt afronden, gebruik dan de Math.floor() methode:

Wiskundevloer(42.23); > 42 Wiskundevloer(36.93); > 36

Afronding naar beneden heeft één richting voor alle getallen, inclusief negatieve getallen. Dit kan worden voorgesteld als een wolkenkrabber met een oneindig aantal verdiepingen, ook onder het funderingsniveau ( negatieve getallen vertegenwoordigen). Als u zich in de lift bevindt tussen kelderverdieping 2 en 3 ( wat overeenkomt met een waarde van -2,5), Math.floor brengt je naar verdieping -3:

Wiskundevloer(-2,5); > -3

Als u dit wilt vermijden, gebruikt u JavaScript Math-afronding met Math.trunc() , ondersteund in alle moderne browsers (behalve IE/Edge):

Wiskunde.trunc(-41.43); > -41

MDN biedt ook polyfill met drie regels om ondersteuning te bieden voor Math.trunc in oudere browsers en IE/Edge.

Rond af naar het dichtstbijzijnde gehele getal

Als u decimale getallen naar boven wilt afronden, gebruikt u Math.ceil . Deze methode kan ook worden gezien als een oneindige lift: Math.ceil brengt je altijd “omhoog”, ongeacht of het getal negatief of positief is:

Math.ceil(42.23); > 43 Wiskundig plafond(36,93); > 37 Math.ceil(-36.93); -36

Rond af op het dichtstbijzijnde veelvoud

Als u een waarde moet afronden op het dichtstbijzijnde veelvoud van 5, maakt u een functie die het getal door 5 deelt, rondt het af en vermenigvuldigt het resultaat vervolgens met dezelfde waarde:

functie roundTo5(num) ( retourneert Math.round(num/5)*5; )

Gebruik:

rondTo5(11); > 10

Als je JavaScript nodig hebt om af te ronden op twee cijfers, kun je zowel het zaad als het veelvoud doorgeven aan de functie:

function roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )

Om de functie te gebruiken, neemt u het af te ronden getal en het veelvoud op in de aanroep:

var beginnummer = 11; var veelvoud = 10; roundToMultiple(beginnummer, meerdere); > 10;

Om waarden alleen naar boven of naar beneden af te ronden, vervangt u rond door plafond of vloer in de functie.

Bereikbinding

Soms moet je de waarde van x verkrijgen, die binnen moet zijn bepaald bereik. We hebben bijvoorbeeld een waarde van 1 tot 100 nodig, maar we krijgen de waarde 123. Om dit op te lossen kun je min() ( geeft het kleinste getal terug) en maximaal ( retourneert het maximaal toegestane aantal).

Gebruik:

var ondergrens = 1; var bovengrens = 100; var numInvoer = 123; var vastgeklemd = Math.max(lowBound, Math.min(numInput, highBound)); console.log (geklemd); > 100;

U kunt een functie of uitbreiding van de klasse Number maken:

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

Gebruik:

(numInput).clamp(ondergrens, bovengrens);

Gaussiaanse afronding

Gaussiaanse afronding (“banking”, convergent of Nederlands) is een afrondingsmethode zonder statistische fouten. Standaard JavaScript-afronding geeft soms fouten in een grotere richting. Gaussiaanse afronding vermijdt deze fout door af te ronden op het dichtstbijzijnde even getal. Beste oplossing die ik ken.

Waarom is afronding nodig?

Het afronden van getallen heeft praktische toepassingen. We kunnen een getal binnen een bepaald bereik manipuleren. We willen bijvoorbeeld een waarde afronden naar het dichtstbijzijnde gehele getal in plaats van alleen met het decimale deel te werken.

Decimale getallen afronden

Om een decimaal getal te knippen, gebruikt u toFixed of de toPrecision-methode. Beiden gebruiken één argument dat respectievelijk specificeert hoeveel significante cijfers (dat wil zeggen het totale aantal cijfers dat in het getal wordt gebruikt) of decimalen (het getal na de komma) het resultaat moet bevatten:

Als er geen argument is gedefinieerd voor toFixed(), wordt het standaard ingesteld op nul, wat betekent dat er 0 cijfers achter de komma staan. Het argument heeft een maximale waarde van 20.
Als er geen argument wordt gegeven voor precisie, blijft het getal ongemoeid

Stel randNum = 6,25; laat afgerond = randNum.toFixed(); // "6" console.log(randNum + afgerond); > "6.256"
Als u wilt dat het resultaat een numeriek gegevenstype is, moet u parseFloat gebruiken:

Stel randNum = 6,25; laat afgerond = parseFloat(randNum.toFixed(1)); console.log(afgerond); > 6.3
Houd er rekening mee dat waarden van 5 worden afgerond, behalve in zeldzame gevallen.

De methoden toFixed() en toPrecision() zijn handig omdat ze niet alleen het breukgedeelte kunnen afsnijden, maar ook decimalen kunnen toevoegen, wat handig is bij het werken met valuta:

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

Hoe u afrondingsfouten met decimalen kunt voorkomen

In sommige gevallen rondt toFixed en toPrecision de waarde 5 naar beneden en naar boven af:

Functie round(waarde, decimalen) ( return Number(Wiskunde.round(waarde+"e"+decimalen)+"e-"+decimalen); )
Nu:

Rond(1.005,2); > 1,01
Als u een robuustere oplossing wilt dan hierboven weergegeven, kunt u naar MDN gaan.

Machine-epsilon-afronding

0,1 + 0,2 === 0,3 > onwaar
We gebruiken Math.EPSILON in onze functie om een geldige vergelijking te krijgen:

EpsEqu(0,1 + 0,2, 0,3) > waar
Alle moderne browsers ondersteunen al wiskundige functies van ES6, maar als je ondersteuning wilt in browsers zoals IE 11, gebruik dan polyfills.

Het fractionele deel bijsnijden

Functie afgekapt(num, decimalPlaces) ( let numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Nu:

Laat randInt = 35,874993; afgekapt(randInt,3); > 35,874

Rond af naar het dichtstbijzijnde getal

Gebruik Math.round() om een decimaal getal naar boven of beneden af te ronden naar het dichtstbijzijnde getal, afhankelijk van wat we het dichtst in de buurt hebben:

Rekenronde(4.3) > 4 Rekenronde(4.5) > 5
Houd er rekening mee dat “de helft van de waarde”, 0,5, naar boven wordt afgerond volgens de regels van de wiskunde.

Rond naar beneden af op het dichtstbijzijnde gehele getal

Als je altijd naar beneden wilt afronden, gebruik dan Math.floor:

Wiskundevloer(42.23); > 42 Wiskundevloer(36.93); > 36
Houd er rekening mee dat naar beneden afronden voor alle getallen geldt, ook voor negatieve getallen. Stel je een wolkenkrabber voor met een oneindig aantal verdiepingen, inclusief verdiepingen op het onderste niveau (die negatieve getallen vertegenwoordigen). Als je in een lift zit op het laagste niveau tussen 2 en 3 (wat een waarde van -2,5 vertegenwoordigt), brengt Math.floor je naar -3:

Wiskundevloer(-2,5); > -3
Maar als je deze situatie wilt vermijden, gebruik dan Math.trunc, ondersteund in alle moderne browsers (behalve IE/Edge):

Wiskunde.trunc(-41.43); > -41
Op MDN vindt u een polyfill die ondersteuning biedt voor Math.trunc in browsers en IE/Edge.

Rond af naar het dichtstbijzijnde gehele getal

Aan de andere kant, als je altijd naar boven moet afronden, gebruik dan Math.ceil. Nogmaals, onthoud de oneindige lift: Math.ceil gaat altijd "omhoog", ongeacht of het getal negatief is of niet:

Math.ceil(42.23); > 43 Wiskundig plafond(36,93); > 37 Math.ceil(-36.93); > -36

Naar boven/beneden afronden op het gewenste getal

Functie roundTo5(num) ( retourneert Math.round(num/5)*5; )
Nu:

RondTo5(11); > 10
Als u wilt afronden op veelvouden van uw waarde, gebruiken we een meer algemene functie, waarbij we de beginwaarde en het veelvoud doorgeven:

Functie roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )
Nu:

Laat aanvankelijk getal = 11; laat meerdere = 10; roundToMultiple(beginnummer, meerdere); > 10;

Een getal in een bereik corrigeren

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

NumInput.clamp(ondergrens, bovengrens); > 100;

Gaussiaanse afronding

GaussRond(2,5) > 2 gaussRond(3,5) > 4 gaussRond(2,57,1) > 2,6
Decimaal in CSS:

Omdat JavaScript vaak wordt gebruikt om positionele mappings voor HTML-elementen te maken, vraag je je misschien af wat er zou gebeuren als we decimale waarden voor onze elementen zouden genereren:

#box ( breedte: 63.667731993px; )
Het goede nieuws is dat moderne browsers decimale waarden in het blokmodel zullen respecteren, inclusief percentage- of pixeleenheden.

Sorteren

Heel vaak moeten we bepaalde elementen sorteren. We hebben bijvoorbeeld een reeks spelrecords en deze moeten worden georganiseerd in aflopende volgorde van spelersrang. Helaas heeft de standaardmethode sort() een aantal verrassende beperkingen: deze werkt goed met gewone Engelse woorden, maar valt onmiddellijk uiteen als er cijfers, unieke tekens of woorden in hoofdletters worden aangetroffen.

Alfabetisch sorteren

Het lijkt erop dat het alfabetisch sorteren van een array een eenvoudige taak zou moeten zijn:

Let fruit = ["pompoen", "abrikoos", "meloen"]; fruit.sort(); > "abrikoos", "pompoen", "meloen"]
We komen echter een probleem tegen zodra een van de elementen in hoofdletters staat:

Let fruit = ["pompoen", "abrikoos", "Cantalope"]; fruit.sort(); > "Cantaloupe", "abrikoos", "pompoen"]
Dit komt omdat de sorteerder standaard het eerste teken vergelijkt dat in Unicode wordt weergegeven. Unicode is een unieke code voor elk personage, ongeacht het platform, ongeacht het programma, ongeacht de taal. Als je bijvoorbeeld naar de codetabel kijkt, heeft het teken "a" de waarde U+0061 (in hexadecimaal 0x61), terwijl het teken "C" de code U+0043 (0x43) heeft, die eerder voorkomt in de Unicode-versie. tabel dan het teken "a".

Om een array te sorteren die mogelijk gemengde hoofdletters bevat, moeten we alle elementen tijdelijk naar kleine letters converteren, of onze sorteervolgorde definiëren met behulp van de localeCompare() methode met enkele argumenten. In een dergelijk geval is het in de regel beter om onmiddellijk een functie te creëren voor herhaald gebruik:

Functie alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("gevoeligheid": "basis")); )); ) let fruit = ["pompoen ", "abrikoos", "meloen"]; alphaSort(fruit) >
Als u de array in omgekeerde alfabetische volgorde wilt sorteren, verwisselt u eenvoudigweg de posities van a en b in de functie:

Numeriek sorteren

Dit alles is niet van toepassing op het voorbeeld waar we het hierboven over hadden over de reeks spelrecords. Bij sommige numerieke arrays werkt sorteren prima, maar op een gegeven moment kan het resultaat onvoorspelbaar zijn:

Laat highScores = ; highScores.sort(function(a,b) ( retourneert a - b; )); >
Nogmaals, om getallen in omgekeerde volgorde te sorteren, verwisselt u de posities van a en b in de functie.

Sorteren van een JSON-achtige structuur

En tot slot, als we een JSON-achtige datastructuur hebben die wordt weergegeven als een reeks gamerecords:

Laat scores = [ ( "naam": "Daniel", "score": 21768 ), ( "naam": "Michael", "score": 33579 ), ( "naam": "Alison", "score": 38395 ];
In ES6+ kunt u pijlfuncties gebruiken:

Scores.sort((a, b) => b.score - a.score));
Voor oudere browsers die deze ondersteuning niet hebben:

Werken met machtsfuncties

Machtsverheffen is een bewerking die oorspronkelijk werd gedefinieerd als het resultaat van het herhaaldelijk vermenigvuldigen van een natuurlijk getal met zichzelf; de vierkantswortel van a is het getal dat a geeft als het wordt gekwadrateerd. We zouden deze functies in het dagelijks leven voortdurend kunnen gebruiken in wiskundelessen, ook bij het berekenen van gebieden, volumes of zelfs bij fysieke modellering.

In JavaScript wordt de machtsfunctie weergegeven als Math.pow(), en in de nieuwe ES7-standaard is een nieuwe machtsverheffingsoperator geïntroduceerd - " * * ".

Machtsverheffing

Om een getal tot de macht nde te verheffen, gebruik je de functie Math.pow(), waarbij het eerste argument het getal is dat tot de macht wordt verheven, het tweede argument de exponent:

Wiskunde.pow(3,2) > 9
Deze notatievorm betekent 3 kwadraat, oftewel 3×3, wat leidt tot het resultaat 9. Er kan uiteraard nog een ander voorbeeld worden gegeven:

Wiskunde.pow(5,3); > 125
Dat wil zeggen, 5 in blokjes, of 5 × 5 × 5, is gelijk aan 125.

ECMAScript 7 is de volgende JavaScript-versie In principe kunnen we de nieuwe voorgestelde machtsverheffingsoperator gebruiken - * *, deze vorm van notatie kan beschrijvender zijn:

3 ** 2 > 9
Op dit moment is de ondersteuning voor deze operator vrij beperkt, dus het wordt niet aanbevolen om deze te gebruiken.

De power-functie kan in verschillende situaties nuttig zijn. Een eenvoudig voorbeeld, het berekenen van het aantal seconden in een uur: Math.pow (60,2).

Vierkant- en kubuswortels

Math.sqrt() en Math.cbrt() zijn het tegenovergestelde van Math.pow(). Zoals we ons herinneren, is de vierkantswortel van a het getal dat a geeft in het kwadraat.

Wiskunde.sqrt(9) > 3
Tegelijkertijd is de derdemachtswortel van a een getal dat a geeft als het wordt verheven tot een kubus.

Math.cbrt(125) > 5
Math.cbrt() is pas onlangs geïntroduceerd in de JavaScript-specificatie en wordt daarom alleen ondersteund in moderne browsers: Chrome 38+, Firefox en Opera 25+ en Safari 7.1+. U zult merken dat Internet Explorer niet op deze lijst staat, maar u zult een polyfill op MDN vinden.

Voorbeelden

Natuurlijk kunnen we niet-gehele waarden gebruiken in een van deze functies:

Wiskunde.pow(1.25, 2); > 1,5625 Math.cbrt(56,57) > 3,8387991760286138
Houd er rekening mee dat dit ook redelijk goed werkt bij het gebruik van negatieve argumentwaarden:

Wiskunde.pow(-5,2) > 25 Wiskunde.pow(10,-2) > 0,01
Dit werkt echter niet voor vierkantswortel:

Wiskunde.sqrt(-9) > NaN
Uit wiskundige analyse weten we dat een denkbeeldig getal verwijst naar de vierkantswortels van negatieve getallen. En dit kan ons leiden naar een andere techniek voor het werken met complexe getallen, maar dat is een ander verhaal.

Je kunt breuken in Math.pow() gebruiken om de vierkants- en derdemachtswortels van getallen te vinden. Vierkantswortel gebruikt een exponent van 0,5:

Wiskunde.pow(5, 0,5); // = Math.sqrt(5) = 5 ** (1/2) > 2,23606797749979
Vanwege de grillen van drijvende komma kun je het juiste resultaat echter niet precies raden:

Wiskunde.pow(2,23606797749979,2) > 5,000000000000001
In dergelijke situaties zult u uw toevlucht moeten nemen tot het afsnijden van tekens van het getal of het afronden naar een bepaalde waarde.

Sommige mensen verwarren om onbekende redenen in JavaScript de functie Math.pow() met Math.exp() , wat de exponentiële functie is voor getallen in het algemeen. Opmerking: in het Engels wordt "exponent" vertaald als "exponent", dus dit is waarschijnlijker van toepassing op Engelssprekenden, hoewel er alternatieve namen voor exponent zijn, zoals index, macht.