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 retourneert deze functie false als het argument Infinity, -Infinity, NaN is, of wordt omgezet naar een van deze speciale numerieke waarden. Anders retourneert deze functie true.

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

Naast de globale isFinite-functie beschikt JavaScript ook over de Number.isFinite-methode. 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 null wordt geconverteerd naar 0 isNaN(true); //vals, omdat true wordt omgezet naar 1 isNaN(false); //vals, omdat false wordt 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

Bij deze methode moet je er op letten dat een lege string of een string bestaande uit spaties en \n wordt geconverteerd naar het getal 0. Daarnaast converteert het ook het nuldatatype en Booleaanse waarden naar een getal .

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 + Met deze methode kunt u een tekenreeks converteren naar een getal 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 met verschillende getalsystemen werken (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 naar een breukgetal kunt converteren.

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

Bovendien heeft de parseFloat-functie, in tegenstelling tot parseInt, geen 2 argumenten en probeert daarom de tekenreeks altijd te behandelen als een getal in het decimale notatiesysteem.

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 de opgegeven waarde een getal is of naar één kan worden geconverteerd. Deze optie telt de lege string, string met spaties, null, Infinity, -Infinity, true en false niet als een getal.

2. Met behulp van het type operator en de isFinite, isNaN-functies:

// 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 tekenreeks niet naar een getal Number.isInteger(20); //waar, omdat deze waarde is een getal

Even en oneven getallen

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

// 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 waarin we priemgetallen van 2 tot 100 weergeven met behulp van Javascript.

// 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 <= 100; i++) { if(isPrime(i)) primaryNumber.push(i); } // вывести в консоль простые числа от 2 до 100 console.log(primaryNumber);

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 van de logische operatoren NOT of OR.

//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 operator retourneert de rest die wordt verkregen door het eerste getal door het tweede te delen. In dit geval moet u 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 kunt u met de methode toLocaleString() de uitvoer van een getal opmaken in overeenstemming met regionale standaarden (taalinstellingen van het besturingssysteem).

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 een computer of ander elektronisch apparaat alle berekeningen in het 2e getalsysteem uitvoert. 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 wordt bijvoorbeeld exact omgezet in binair getal.

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).