U ovom ćemo članku detaljno razmotriti brojeve, matematičke operatore, načine pretvaranja broja u niz i obrnuto, kao i mnoge druge važne točke.

jeKonačna funkcija

Funkcija isFinite omogućuje vam da provjerite je li argument konačan broj.

Kao odgovor, ova funkcija vraća false ako je argument Infinity, -Infinity, NaN ili će biti prebačen na jednu od ovih posebnih numeričkih vrijednosti. U suprotnom, ova funkcija će vratiti true.

JeKonačna(73); // true isFinite(-1/0); // false isFinite(Infinity); // false isFinite(NaN); // false isFinite("Tekst"); // lažno

Osim globalne funkcije isFinite, JavaScript također ima metodu Number.isFinite. Za razliku od isFinite, ne prisiljava argument da se pretvori u broj.

IsKonačno("73"); // pravi broj.isFinite("73"); // lažno

isNaN funkcija

Funkcija isNaN dizajnirana je za utvrđivanje je li argument broj ili se može pretvoriti u jedan. Ako je tako, tada funkcija isNaN vraća false. Inače vraća true.

IsNaN(NaN); //istina isNaN("25px"); //istina, jer 20px nije broj isNaN(25.5); //false isNaN("25.5"); //false isNaN(" "); //lažno, jer razmak ili nekoliko razmaka se pretvaraju u 0 isNaN(null); //lažno, jer null se pretvara u 0 isNaN(true); //lažno, jer true se pretvara u 1 isNaN(false); //lažno, jer false se pretvara u 0

Ako se ova radnja mora izvesti bez pretvaranja tipa, upotrijebite metodu Number.isNaN. Ova metoda je uvedena u jezik počevši od ECMAScripta 6.

Kako eksplicitno pretvoriti niz u broj?

Možete eksplicitno pretvoriti niz u broj pomoću sljedećih metoda:

1. Koristite unarni operator +, koji se mora staviti ispred vrijednosti.

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

Ova metoda zanemaruje razmake na početku i kraju retka, kao i \n (pokretanje retka).

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

Koristeći ovu metodu, trebate obratiti pozornost na činjenicu da se prazan niz ili niz koji se sastoji od razmaka i \n pretvara u broj 0. Osim toga, također pretvara null tip podataka i Boolean vrijednosti u broj .

Null; //0 +istina; //1 +false; //0 +" "; //0

2. Funkcija ParseInt. Ova funkcija je dizajnirana za pretvaranje argument na cijeli broj. Za razliku od korištenja unarni operator +, ova vam metoda omogućuje pretvaranje niza u broj u kojem nisu svi znakovi numerički. Počinje pretvarati niz, počevši od prvog znaka. I čim naiđe na nenumerički znak, ova funkcija zaustavlja svoj rad i vraća rezultirajući broj.

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

Ova funkcija može raditi s različitim sustavima brojeva (binarni, oktalni, decimalni, heksadecimalni). Baza brojevnog sustava određena je pomoću 2 argumenta.

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

Uz funkciju parseInt, JavaScript ima metodu Number.parseInt. Ova se metoda ne razlikuje od funkcije parseInt i uvedena je u JavaScript sa specifikacijom ECMASCRIPT 2015 (6).

3. funkcija parseFloat. Funkcija parseFloat slična je parseInt, osim što vam omogućuje pretvaranje argumenta u razlomački broj.

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

Osim toga, funkcija parseFloat, za razliku od parseInt, nema 2 argumenta, pa stoga uvijek pokušava niz tretirati kao broj u sustavu decimalnog zapisa.

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

Uz funkciju parseFloat, JavaScript ima metodu Number.parseFloat. Ova se metoda ne razlikuje od funkcije parseFloat i uvedena je u JavaScript sa specifikacijom ECMASCRIPT 2015 (6).

Pretvaranje broja u niz

Broj možete pretvoriti u niz pomoću metode toString.

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

Metoda toString također vam omogućuje da odredite bazu brojevnog sustava, uzimajući u obzir koju morate eksplicitno pretvoriti broj u niz:

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

Kako provjeriti je li varijabla broj

Možete odrediti je li vrijednost varijable broj pomoću jedne od sljedećih metoda:

1. Korištenje funkcija isNaN i isFinite:

// myVar je varijabla if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar je broj ili se može pretvoriti u njega);

Kao funkcija:

// funkcija funkcija isNumeric(value) ( ​​​​return !isNaN(parseFloat(value)) && isFinite(parseFloat(value)); ) // koristi var myVar = "12px"; console.log(isNumeric(myVar)); //pravi

Ova metoda vam omogućuje da odredite je li navedena vrijednost broj ili se može pretvoriti u jedan. Ova opcija ne broji prazan niz, niz razmaka, null, Infinity, -Infinity, true i false kao broj.

2. Korištenje operatora typeof i funkcija isFinite, isNaN:

// funkcija koja provjerava je li vrijednost broj 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 !}

Ova funkcija određuje je li navedena vrijednost tipa Number i je li jedna od posebnih vrijednosti Infinity, -Infinity i NaN. Ako je tako, tada ova funkcija vraća true.

3. Korištenje metode ECMAScript 6 Number.isInteger(value). Ova metoda vam omogućuje da odredite je li navedena vrijednost cijeli broj.

Number.isInteger("20"); //lažno, jer ova metoda ne pretvara niz u broj Number.isInteger(20); //istina, jer ova vrijednost je broj

Parni i neparni brojevi

Pomoću sljedećih funkcija možete provjeriti je li broj paran ili neparan:

// Funkcija za provjeru funkcije parnog pariteta u broju isEven(n) ( return n % 2 == 0; ) // Funkcija za provjeru funkcije parnog pariteta u broju isOdd(n) ( return Math.abs(n % 2) == 1; )

Ali prije provođenja takve provjere, preporučljivo je provjeriti je li navedena vrijednost broj:

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

Prosti brojevi u Javascriptu

Pogledajmo primjer u kojem ćemo prikazati proste brojeve od 2 do 100 koristeći Javascript.

// Funkcija koja provjerava je li broj prost function isPrime(value) ( ​​​​if (isNaN(value) || !isFinite(value) || value%1 || value< 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);

Zaokruživanje broja u Javascriptu

Postoje različiti načini zaokruživanja razlomka na cijeli broj u JavaScriptu.

1. Korištenje metoda Math.floor, Math.ceil i Math.round posebno dizajniranih za to. Metoda Math.floor zaokružuje razlomak na najbliži cijeli broj, tj. jednostavno odbacuje razlomački dio. Math.ceil zaokružuje razlomak na najbliži cijeli broj. Math.round zaokružuje broj prema gore ili dolje ovisno o vrijednosti razlomka. Ako je razlomački dio veći ili jednak 0,5, tada gore, inače je uvijanje prema dolje.

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

2. Korištenje metode toFixed(precision). Ova metoda zaokružuje razlomački dio broja na određenu preciznost. Rezultat zaokruživanja vraća se kao niz.

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

Ako nema dovoljno decimalnih mjesta da bi se oblikovala navedena preciznost broja, on se dopunjuje nulama.

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

3. Korištenje metode toPrecision(accuracy). Ova metoda predstavlja broj s određenom preciznošću. U isto vrijeme, on može zaokružiti ne samo razlomak, već i cijeli dio broja. Ovisno o rezultatu, ova metoda može prikazati rezultirajući broj s fiksnom točkom ili u eksponencijalnom obliku.

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. Korištenje logičkih operatora NOT ili OR.

//putem konzole dvostruke logičke negacije.log(~~7.9); //7 // korištenjem logičkog ILI s nulom: console.log(7.9^0); //7

Cijeli i razlomački dio broja

Cjelobrojni dio broja možete dobiti pomoću metoda Math.floor() i parseInt():

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

Možete dobiti razlomački dio broja pomoću operatora postotka (%). Ovaj operator vraća ostatak koji će se dobiti dijeljenjem prvog broja s drugim. U ovom slučaju morate koristiti 1 kao 2. broj.

Console.log(7,21%1); // 0.209999999999999996 // točno na 2 decimalna mjesta console.log((7.21%1).toFixed(2)); // "0,21"

Osim toga, frakcijski dio se također može dobiti pomoću izračuna:

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

Je li broj djeljiv cijelim brojem?

Možete odrediti je li broj djeljiv s cijelim brojem pomoću operatora postotka:

Var broj = 9; // ako je ostatak broja podijeljenog s 3 0, tada da, inače ne if (broj%3==0) ( console.log ("Broj " + broj + " je djeljiv s 3"); ) else ( console. log("Broj " + broj + " nije djeljiv sa 3");

Formatiranje brojeva

U JavaScriptu, metoda toLocaleString() omogućuje formatiranje izlaza broja u skladu s regionalnim standardima (jezične postavke operativnog sustava).

Na primjer, formatirajmo broj u skladu s regionalnim standardima koji su instalirani u sustavu prema zadanim postavkama:

Var broj = 345,46; console.log(number.toLocaleString()); //"345.46"

Na primjer, formatirajmo broj u skladu s regionalnim standardima Rusije (ru):

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

Ova se metoda također može koristiti za formatiranje broja kao valute:

Console.log((2540.125).toLocaleString("ru-RU",(style:"valuta", valuta:"RUB"))); //"2.540,13 ₽" console.log((89.3).toLocaleString("ru-RU",(style:"currency", currency:"USD"))); //"89,30 $" console.log((2301,99).toLocaleString("ru-RU",(style:"currency", currency:"EUR"))); //"2301,99 €"

Predstavljanje broja kao postotka:

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

Rastavite broj na znamenke (koristite svojstvo Grupiranja):

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

Ispišite broj s određenim brojem znamenki (2) iza decimalne točke:

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

Usporedba brojeva

Sljedeći operatori koriste se za usporedbu brojeva u JavaScriptu: == (jednako), != (nije jednako), > (veće od),< (меньше), >= (veće ili jednako),<= (меньше или равно).

Na primjer, usporedimo dva broja:

Console.log(2>3); //lažna konzola.log(5>=3); //pravi

Kada se brojevi uspoređuju s frakcijskim dijelom, potrebno je uzeti u obzir pogreške koje mogu nastati tijekom ovih izračuna.

Na primjer, u JavaScriptu zbroj brojeva (0,2 + 0,4) nije jednak 0,6:

Console.log((0,2+0,4)==0,6); //lažno

Pogreške se javljaju jer računalo ili drugi elektronički uređaj sve izračune izvodi u 2. brojevnom sustavu. one. Prije izvođenja bilo kakvih radnji, računalo prvo mora pretvoriti brojeve predstavljene u izrazu u drugi brojevni sustav. Ali ne može se svaki razlomački decimalni broj točno prikazati u drugom brojevnom sustavu.

Na primjer, broj 0,25 10 točno se pretvara u binarni.

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

Na primjer, broj 0,2 10 može se pretvoriti u sustav 2 samo s određenom točnošću:

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

Kao rezultat toga, ove će pogreške utjecati na izračun zbroja dvaju brojeva i rezultate usporedbe. one. Ispostavilo se da će JavaScript zapravo vidjeti ovaj unos na sljedeći način:

0.6000000000000001==0.6

Kada računate ili prikazujete brojeve s razlomcima, uvijek morate naznačiti preciznost s kojom to želite učiniti.

Na primjer, usporedite brojeve do 2 decimalna mjesta pomoću metoda toFixed() i toPrecision():

//metoda toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //točno //metoda toPrecision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //pravi

Osnovne matematičke operacije

U JavaScriptu postoje sljedeći matematički operatori: + (zbrajanje), - (oduzimanje), * (množenje), / (dijeljenje), % (modulo), ++ (povećanje vrijednosti za 1), -- (smanjenje vrijednosti za 1).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, tj. 6:3=2 => 6-3*2 => rest(0) 5%2 //1, tj. 5:2=2(.5) => 5-2*2 => ostalo(1) 7,3%2 //1,3, tj. 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //predznak rezultata operacije % jednak je predznaku prve vrijednosti -9%2.5 //-1.5 , tj. 9:2.5=3(.6) => 9-2.5*3 => ostatak(1.5) -9%-2.5 //-1.5, tj. 9:2.5=3(.6) => 9-2.5*3 => rest(1.5) -2%5 //-2, tj. 2:5=0(.4) => 2-5*0 => ostatak(2) x = 3; konzola.log(x++); //izvodi 3, zatim postavlja 4 console.log(x); //4 x = 3; konzola.log(++x); //postavlja 4 i izlazi x = 5; konzola.log(x--); //izvodi 5, zatim postavlja 4 console.log(x); //4 x = 5; konzola.log(--x); //postavlja 4 i daje izlaz Osim toga, JavaScript ima operatore kombinacija: 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).