Js część całkowita po podzieleniu. Metody zaokrąglania liczb w JavaScript

W tym artykule szczegółowo przyjrzymy się liczbom, operatorom matematycznym, sposobom konwersji liczby na ciąg znaków i odwrotnie, a także wielu innym ważnym punktom.

funkcja isFinite

Funkcja isFinite pozwala sprawdzić, czy argument jest liczbą skończoną.

Jako odpowiedź tę funkcję zwraca wartość false, jeśli argumentem jest Infinity, -Infinity, NaN lub zostanie rzucony na jeden z tych specjalnych wartości liczbowe. W W przeciwnym razie ta funkcja zwróci wartość true.

JestSkończony(73); // true isFinite(-1/0); // false isFinite(Infinity); // fałsz isFinite(NaN); // false isFinite("Tekst"); // FAŁSZ

Z wyjątkiem funkcja globalna isFinite JavaScript ma również metodę o nazwie Number.isFinite. W przeciwieństwie do isFinite nie wymusza konwersji argumentu na liczbę.

JestSkończony("73"); // prawda Liczba.isFinite("73"); // FAŁSZ

funkcja isNaN

Funkcja isNaN ma na celu określenie, czy argument jest liczbą lub czy można go przekonwertować na jeden. Jeśli tak, to funkcja isNaN zwraca wartość false. W przeciwnym razie zwraca wartość true.

IsNaN(NaN); //true isNaN("25px"); //prawda, ponieważ 20px nie jest liczbą isNaN(25,5); //fałsz isNaN("25,5"); //fałsz isNaN(" "); //nieprawda, ponieważ spacja lub kilka spacji jest konwertowanych na 0 isNaN(null); //nieprawda, ponieważ wartość null jest konwertowana na 0 isNaN(true); //nieprawda, ponieważ prawda jest konwertowana na 1 isNaN(fałsz); //nieprawda, ponieważ wartość fałszywa przeliczone na 0

Jeśli tę akcję trzeba wykonać bez rzutowania typu, użyj metody Number.isNaN. Metoda ta została wprowadzona do języka począwszy od ECMAScript 6.

Jak jawnie przekonwertować ciąg na liczbę?

Możesz jawnie przekonwertować ciąg na liczbę, korzystając z następujących metod:

1. Użyj operator jednoargumentowy +, który należy umieścić przed wartością.

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

Ta metoda ignoruje spacje na początku i na końcu linii, a także \n (przesunięcie wiersza).

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

Używanie tę metodę Należy pamiętać, że pusty ciąg znaków lub ciąg składający się ze spacji i \n jest konwertowany na liczbę 0. Dodatkowo konwertuje również typ danych null i wartości logiczne na liczbę.

Nieważny; //0 + prawda; //1 + fałsz; //0 +" "; //0

2. Funkcja ParseInt. Ta funkcja jest przeznaczona do konwersji argument na liczbę całkowitą. W przeciwieństwie do używania operator jednoargumentowy +, tę metodę pozwala na konwersję ciągu znaków na liczbę, w której nie wszystkie znaki są numeryczne. Rozpoczyna konwersję ciągu, zaczynając od pierwszego znaku. Gdy tylko napotka znak inny niż numeryczny, funkcja ta przestaje działać i zwraca wynikową liczbę.

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

Z tą funkcją można współpracować różne systemy Liczby (binarne, ósemkowe, dziesiętne, szesnastkowe). Podstawę systemu liczbowego określa się za pomocą 2 argumentów.

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

Oprócz funkcji parseInt JavaScript posiada metodę Number.parseInt. Metoda ta nie różni się od funkcji parseInt i została wprowadzona do JavaScriptu wraz ze specyfikacją ECMASCRIPT 2015 (6).

3. Funkcja parseFloat. Funkcja parseFloat jest podobna do parseInt z tą różnicą, że umożliwia konwersję argumentu na liczbę ułamkową.

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

Dodatkowo funkcja parseFloat w odróżnieniu od parseInt nie posiada 2 argumentów, dlatego zawsze stara się traktować ciąg znaków jako liczbę w systemie zapisu dziesiętnego.

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

Oprócz funkcji parseFloat JavaScript posiada metodę Number.parseFloat. Metoda ta nie różni się od funkcji parseFloat i została wprowadzona do JavaScriptu wraz ze specyfikacją ECMASCRIPT 2015 (6).

Konwersja liczby na ciąg

Liczbę można przekształcić w ciąg znaków za pomocą metody toString.

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

Metoda toString pozwala również na określenie podstawy systemu liczbowego, biorąc pod uwagę, że należy jawnie przekonwertować liczbę na ciąg znaków:

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

Jak sprawdzić, czy zmienna jest liczbą

Możesz określić, czy wartość zmiennej jest liczbą, korzystając z jednej z następujących metod:

1. Korzystanie z funkcji isNaN i isFinite:

// myVar jest zmienną if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar jest liczbą lub można na nią rzutować);

Jako funkcja:

// funkcja funkcja isNumeric(wartość) ( ​return !isNaN(parseFloat(wartość)) && isFinite(parseFloat(wartość)); ) // użyj var myVar = "12px"; konsola.log(isNumeric(myVar)); //PRAWDA

Ta metoda pozwala określić, czy podana wartość jest liczbą, czy też można ją przekonwertować na jedną. Ta opcja nie zlicza pustego ciągu, ciągu spacji, null, Infinity, -Infinity, true i false jako liczby.

2. Wykorzystując operator typeof i isFinite, funkcje isNaN:

// funkcja sprawdzająca, czy dana wartość jest liczbą funkcja isNumber(wartość) ( ​​zwraca typ wartości === "liczba" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Funkcja ta określa, czy podana wartość jest typu Number, a także czy należy do jednego z specjalne znaczenia Nieskończoność, -Nieskończoność i NaN. Jeśli tak, to funkcja zwraca wartość true.

3. Użycie metody ECMAScript 6 Number.isInteger(value). Ta metoda pozwala określić, czy podana wartość jest liczbą całkowitą.

Liczba.isInteger("20"); //nieprawda, ponieważ ta metoda nie konwertuje ciągu znaków na liczbę Number.isInteger(20); //prawda, ponieważ ta wartość jest liczbą

Liczby parzyste i nieparzyste

Możesz sprawdzić, czy liczba jest parzysta czy nieparzysta, korzystając z następujących funkcji:

// Funkcja sprawdzająca liczbę pod kątem funkcji parzystości isEven(n) ( return n % 2 == 0; ) // Funkcja sprawdzająca liczbę pod kątem funkcji parzystości isOdd(n) ( return Math.abs(n % 2) == 1;

Ale przed przeprowadzeniem takiej kontroli wskazane jest upewnienie się, że określona wartość jest liczbą:

Wartość = 20; if (Number.isInteger(wartość)) ( if (isEven(wartość)) ( console.log("Number " + wartość.toString() + " - parzysty"); ) )

Liczby pierwsze w JavaScript

Spójrzmy na przykład, w którym będziemy wyświetlać liczby pierwsze od 2 do 100 za pomocą JavaScript.

// Funkcja sprawdzająca, czy liczba jest liczbą pierwszą funkcja isPrime(wartość) ( ​​if (isNaN(wartość) || !isFinite(wartość) || wartość%1 || wartość< 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);

Zaokrąglanie liczby w JavaScript

Istnieją różne sposoby zaokrąglania ułamka do liczby całkowitej w JavaScript.

1. Wykorzystanie specjalnie do tego przeznaczonych metod Math.floor, Math.ceil i Math.round. Metoda Math.floor zaokrągla ułamek w dół do najbliższej liczby całkowitej, tj. po prostu odrzuca część ułamkową. Funkcja Math.ceil zaokrągla ułamek w górę do najbliższej liczby całkowitej. Math.round zaokrągla liczbę w górę lub w dół w zależności od wartości części ułamkowej. Jeśli część ułamkowa jest większa lub równa 0,5, to w górę, w przeciwnym razie skręt jest w dół.

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

2. Korzystanie z metody toFixed(precyzja). Ta metoda zaokrągla część ułamkową liczby z określoną precyzją. Wynik zaokrąglenia jest zwracany w postaci ciągu znaków.

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

Jeśli nie ma wystarczającej liczby miejsc po przecinku, aby utworzyć określoną precyzję liczby, wówczas jest ona dopełniana zerami.

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

3. Stosowanie metody toPrecision(accuracy). Ta metoda reprezentuje liczbę z określoną precyzją. Jednocześnie może zaokrąglić nie tylko ułamek, ale także całą część liczby. W zależności od wyniku metoda ta może przedstawić wynikową liczbę w punkcie stałym lub w postaci wykładniczej.

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. Stosowanie operatorów logicznych NOT lub OR.

//poprzez podwójną negację logiczną console.log(~~7.9); //7 // używając logicznego OR z zerem: console.log(7.9^0); //7

Liczba całkowita i część ułamkowa liczby

Część całkowitą liczby można uzyskać za pomocą metod Math.floor() i parseInt():

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

Część ułamkową liczby można uzyskać za pomocą operatora procentowego (%). Operator ten zwraca resztę, która zostanie uzyskana z dzielenia pierwszej liczby przez drugą. W takim przypadku musisz użyć 1 jako drugiej liczby.

Konsola.log(7,21%1); // 0.20999999999999996 // z dokładnością do 2 miejsc po przecinku console.log((7.21%1).toFixed(2)); // „0,21”

Ponadto część ułamkową można również uzyskać za pomocą obliczeń:

Liczba zmiennych = 7,21; var frakcjaNumber = liczba - Math.floor(Math.abs(liczba)); konsola.log(numer frakcji); // 0,20999999999999996

Czy liczba jest podzielna przez liczbę całkowitą?

Możesz określić, czy liczba jest podzielna przez liczbę całkowitą, używając operatora procentowego:

Liczba zmiennych = 9; // jeśli reszta liczby podzielona przez 3 wynosi 0, to tak, w przeciwnym razie nie if (number%3==0) ( console.log („Liczba „ + liczba + ” jest podzielna przez 3”); ) else ( console. log("Liczba " + liczba + " nie jest podzielna przez 3" );

Formatowanie liczb

W JavaScript metoda toLocaleString() umożliwia formatowanie wyniku liczby zgodnie ze standardami regionalnymi (ustawieniami językowymi systemu operacyjnego).

Przykładowo sformatujmy liczbę zgodnie z regionalnymi standardami, które są domyślnie instalowane w systemie:

Liczba zmiennych = 345,46; konsola.log(numer.toLocaleString()); //"345,46"

Na przykład sformatujmy liczbę zgodnie z regionalnymi standardami Rosji (ru):

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

Tej metody można również użyć do sformatowania liczby jako waluty:

Console.log((2540.125).toLocaleString("ru-RU",(styl:"waluta", waluta:"RUB"))); //"2,540,13 ₽" console.log((89.3).toLocaleString("ru-RU",(styl:"waluta", waluta:"USD"))); //"89,30 $" console.log((2301.99).toLocaleString("ru-RU",(styl:"waluta", waluta:"EUR"))); //"2301,99 EUR"

Reprezentowanie liczby w procentach:

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

Podziel liczbę na cyfry (właściwość useGrouping):

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

Wydrukuj liczbę zawierającą określoną liczbę cyfr (2) po przecinku:

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

Porównanie liczb

Do porównywania liczb w JavaScript używane są następujące operatory: == (równe), != (nie równe), > (większe niż),< (меньше), >= (większy lub równy),<= (меньше или равно).

Porównajmy na przykład dwie liczby:

Konsola.log(2>3); //fałsz console.log(5>=3); //PRAWDA

Porównując liczby z częścią ułamkową, należy wziąć pod uwagę błędy, które mogą pojawić się podczas tych obliczeń.

Na przykład w JavaScript suma liczb (0,2 + 0,4) nie jest równa 0,6:

Konsola.log((0,2+0,4)==0,6); //FAŁSZ

Błędy powstają, ponieważ komputer lub inne urządzenie elektroniczne wykonuje wszystkie obliczenia w systemie drugiej liczby. Te. Przed wykonaniem jakichkolwiek czynności komputer musi najpierw przekonwertować liczby przedstawione w wyrażeniu na drugi system liczbowy. Ale nie każdą ułamkową liczbę dziesiętną można przedstawić dokładnie w drugim systemie liczbowym.

Na przykład liczba 0,25 10 jest dokładnie konwertowana na postać binarną.

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

Na przykład liczbę 0,2 10 można przeliczyć na system 2 tylko z pewną dokładnością:

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

W rezultacie błędy te będą miały wpływ na obliczenie sumy dwóch liczb i wyniki porównania. Te. Okazuje się, że JavaScript faktycznie zobaczy ten wpis w następujący sposób:

0.6000000000000001==0.6

Obliczając lub wyświetlając liczby zawierające części ułamkowe, należy zawsze wskazać dokładność, z jaką chcesz to zrobić.

Na przykład porównaj liczby z dokładnością do 2 miejsc po przecinku za pomocą metod toFixed() i toPrecision():

//metoda toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //metoda toPrecision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //PRAWDA

Podstawowe operacje matematyczne

W JavaScript istnieją następujące operatory matematyczne: + (dodawanie), - (odejmowanie), * (mnożenie), / (dzielenie), % (modulo), ++ (zwiększanie wartości o 1), -- (zmniejszanie wartości o 1 ).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, tj. 6:3=2 => 6-3*2 => reszta(0) 5%2 //1, tj. 5:2=2(.5) => 5-2*2 => reszta(1) 7,3%2 //1,3, tj. 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //znak wyniku operacji % jest równy znakowi pierwszej wartości -9%2,5 //-1,5 , tj. 9:2,5=3(.6) => 9-2,5*3 => reszta(1,5) -9%-2,5 //-1,5, tj. 9:2,5=3(.6) => 9-2,5*3 => reszta(1,5) -2%5 //-2, tj. 2:5=0(.4) => 2-5*0 => reszta(2) x = 3; konsola.log(x++); //wypisuje 3, następnie ustawia 4 console.log(x); //4 x = 3; konsola.log(++x); //ustawia 4 i wyprowadza x = 5; konsola.log(x--); //wypisuje 5, następnie ustawia 4 console.log(x); //4 x = 5; konsola.log(--x); //zestawia 4 i wyprowadza Dodatkowo JavaScript zawiera operatory kombinacji: 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; konsola.log(x); //9 x = 3; y = 6; x-=y; konsola.log(x); //-3 x = 3; y = 6; x*=y; konsola.log(x); //18 x = 3; y = 6; x/=y; konsola.log(x); //0,5 x = 3; y = 6; x%=y; konsola.log(x); //3 Często obliczenia dają wyniki wykraczające poza pożądane zakresy. W rezultacie konieczne jest wdrożenie Zaokrąglanie JavaScriptu

do pewnej wartości.

Dlaczego zaokrąglone liczby?

0.1 * 0.2; > 0.020000000000000004

JavaScript nie przechowuje liczb całkowitych, ponieważ ich wartości są reprezentowane jako liczby zmiennoprzecinkowe. Wielu ułamków nie można przedstawić w postaci liczby z określoną skończoną liczbą miejsc po przecinku, dlatego JavaScript może generować wyniki takie jak poniższe:

W praktyce nie zrobi to żadnej różnicy, ponieważ mówimy o błędzie 2 kwintylionowych. Może to jednak mieć wpływ na wyniki pracy z liczbami reprezentującymi wartości walut, wartości procentowe lub rozmiar pliku. Dlatego musisz zrobić lub z określonym miejscem po przecinku.

Aby „wyciąć” liczbę dziesiętną, użyj metod toFixed() lub toPrecision(). Obydwa przyjmują jeden argument, który określa liczbę miejsc znaczących i dziesiętnych, które mają być uwzględnione w wyniku:

• jeśli funkcja toFixed() nie ma określonego argumentu, wartością domyślną jest 0, czyli bez miejsc dziesiętnych; maksymalna wartość argumentu to 20;
• jeśli do toPrecision() nie zostanie podany żaden argument, liczba nie zostanie zmieniona.

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

Notatka

Zarówno toFixed(), jak i toPrecision zwracają zaokrąglony ciąg reprezentujący wynik, a nie liczbę. Oznacza to, że dodanie zaokrąglenia do RandNum spowoduje konkatenację ciągów znaków, a nie pojedynczą liczbę:

konsola.log(liczba_randów + zaokrąglona); > „6,256”

Jeśli chcesz, aby JavaScript zaokrąglił liczbę do setnych, użyj parseFloat() :

var randNum = 6,25; var zaokrąglony = parseFloat(randNum.toFixed(1)); konsola.log(zaokrąglona); > 6.3

toFixed() i toPrecision() to także przydatne metody przycinania duża ilość miejsca dziesiętne. Jest to przydatne podczas pracy z liczbami reprezentującymi jednostki pieniężne:

var całościNum = 1 var dolarówCents = całyNum.toFixed(2); konsola.log(dolarsCents); > „1,00”

Należy pamiętać, że jeśli liczba ma więcej cyfr niż określona precyzja, toPrecision wyświetli wynik w formacie naukowym:

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

Jak uniknąć błędów przy zaokrąglaniu ułamków dziesiętnych

W niektórych przypadkach implementacja toFixed i toPrecision JavaScript zaokrągla 5 w dół i nie więcej:

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

Wynikiem powyższego przykładu powinno być 1,01, a nie 1. Jeśli chcesz uniknąć tego błędu, polecam używać liczb wykładniczych:

funkcja round(wartość, miejsca dziesiętne) ( return Number(Math.round(wartość+"e"+liczby dziesiętne)+"e-"+liczby dziesiętne); )

Aplikacja:

okrągłe (1,005,2); > 1.01

Jeśli potrzebujesz jeszcze solidniejszego rozwiązania niż zaokrąglanie, jest ono dostępne pod adresem MDN.

Zaokrąglanie za pomocą epsilon

Metoda alternatywna Zaokrąglanie JavaScriptu do części dziesiątych został wprowadzony w ES6 ( znany również jako JavaScript 2015). « Epsilon maszynowy" zapewnia rozsądny margines błędu przy porównywaniu dwóch liczb zmiennoprzecinkowych. Bez zaokrągleń porównania mogą dawać wyniki podobne do następujących:

0,1 + 0,2 === 0,3 > fałsz

Math.EPSILON można użyć w funkcji, aby uzyskać prawidłowe porównanie:

funkcja epsEqu(x, y) (zwróć Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

Funkcja przyjmuje dwa argumenty: jeden zawiera obliczenia, drugi oczekiwany (zaokrąglony) wynik. Zwraca porównanie tych dwóch parametrów:

epsEqu(0,1 + 0,2; 0,3) > prawda

Wszystkie nowoczesne przeglądarki obsługują funkcje matematyczne ES6. Ale jeśli chcesz zapewnić obsługę w starszych przeglądarkach, musisz użyć wypełniaczy.

Obcięcie liczb dziesiętnych

Wszystkie przedstawione wcześniej metody działają Zaokrąglanie JavaScriptu do części dziesiątych. Aby obciąć liczbę dodatnią do dwóch miejsc po przecinku, pomnóż ją przez 100, skróć ponownie, a następnie podziel wynik przez 100:

funkcja obcięta(liczba) (zwróć Math.trunc(liczba * 100) / 100; ) obcięta(3.1416) > 3.14

Jeśli potrzebujesz czegoś bardziej elastycznego, możesz użyć operatora bitowego:

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

Stosowanie:

var randInt = 35,874993; obcięty(randInt,3); > 35,874

Zaokrąglij do najbliższej liczby

Do wdrożenia Zaokrąglanie JavaScriptu do najbliższej liczby całkowitej, używana jest funkcja Math.round():

Runda matematyczna(4.3) > 4 Runda matematyczna(4.5) > 5

Zauważ, że „ wartości pół", np. 0,5, są zaokrąglane w górę.

Zaokrąglij w dół do najbliższej liczby całkowitej

Jeśli chcesz zaokrąglić w dół, użyj metody Math.floor():

Podłoga matematyczna (42,23); > 42 Podłoga matematyczna (36,93); > 36

Zaokrąglanie w dół ma jeden kierunek dla wszystkich liczb, także ujemnych. Można to sobie wyobrazić jako drapacz chmur o nieskończonej liczbie pięter, w tym poniżej poziomu fundamentów ( reprezentujące liczby ujemne). Jeśli znajdujesz się w windzie pomiędzy 2. a 3. poziomem piwnicy ( co odpowiada wartości -2,5), Math.floor przeniesie Cię na piętro -3:

Podłoga matematyczna(-2,5); > -3

Jeśli chcesz tego uniknąć, użyj zaokrąglania JavaScript Math za pomocą Math.trunc() , obsługiwanego we wszystkich nowoczesne przeglądarki(z wyjątkiem IE/krawędź):

Matematyka.trunc(-41,43); > -41

MDN również zapewnia trzyliniowe wypełnienie zapewniające obsługę Math.trunc w starszych przeglądarkach i IE/Edge.

Zaokrąglij w górę do najbliższej liczby całkowitej

Jeśli chcesz zaokrąglić liczby dziesiętne w górę, użyj Math.ceil . Metodę tę można również traktować jako nieskończoną windę: Math.ceil zawsze zabiera Cię „w górę”, niezależnie od tego, czy liczba jest ujemna, czy dodatnia:

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

Zaokrąglij do najbliższej wielokrotności

Jeśli chcesz zaokrąglić wartość do najbliższej wielokrotności 5, utwórz funkcję, która dzieli liczbę przez 5, zaokrągla ją, a następnie mnoży wynik przez tę samą wartość:

funkcja roundTo5(num) ( return Math.round(num/5)*5; )

Stosowanie:

roundTo5(11); > 10

Jeśli potrzebujesz JavaScript do zaokrąglenia do dwóch cyfr, możesz przekazać do funkcji zarówno źródło, jak i wielokrotność:

funkcja roundToMultiple(liczba, wielokrotność) ( return Math.round(liczba/wielokrotność)*wielokrotność; )

Aby skorzystać z tej funkcji, należy w jej wywołaniu uwzględnić liczbę, która ma zostać zaokrąglona, ​​oraz wielokrotność:

var numer początkowy = 11; var wielokrotność = 10; roundToMultiple(numer początkowy, wielokrotność); > 10;

Aby zaokrąglić wartości tylko w górę lub w dół, zamień round na ceil lub Floor w funkcji.

Wiązanie zakresu

Czasami trzeba uzyskać wartość x, która musi mieścić się w pewnym zakresie. Na przykład potrzebujemy wartości od 1 do 100, ale otrzymujemy wartość 123. Aby to naprawić, możesz użyć min() ( zwraca najmniejszą liczbę) i maks. ( zwraca maksymalną dozwoloną liczbę).

Stosowanie:

var dolna granica = 1; var wysoka granica = 100; zmienna liczbawejściowa = 123; var zaciśnięte = Math.max(lowBound, Math.min(numInput, highBound)); konsola.log(zaciśnięty); > 100;

Można utworzyć funkcję lub rozszerzenie klasy Number.

Dlaczego zaokrąglanie jest konieczne?

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Z praktycznego punktu widzenia ta niedokładność nie ma znaczenia, w naszym przypadku mówimy o błędzie w częściach kwintylionowych, jednak niektórych może to rozczarować. Nieco dziwne wyniki możemy również uzyskać pracując z liczbami reprezentującymi waluty, wartości procentowe lub rozmiary plików. Aby skorygować te niedokładności wystarczy, że potrafimy zaokrąglić wyniki, a wystarczy ustawić dokładność dziesiętną.

Zaokrąglanie liczb ma praktyczne zastosowanie, możemy manipulować liczbą w określonym zakresie, np. chcemy zaokrąglić wartość do najbliższej liczby całkowitej, a nie pracować tylko z częścią dziesiętną.

Zaokrąglanie liczb dziesiętnych

1. Jeśli argument nie jest zdefiniowany dla toFixed(), jego domyślna wartość wynosi zero, co oznacza 0 miejsc po przecinku, a maksymalna wartość argumentu wynosi 20.
2. Jeśli do Precision nie zostanie podany żaden argument, liczba pozostanie niezmieniona

Niech RandNum = 6,25; niech zaokrąglone = RandNum.toFixed(); // "6" console.log(randNum + zaokrąglone); > „6,256”
Jeśli chcesz, aby wynik był typem danych numerycznych, musisz użyć parseFloat:

Niech RandNum = 6,25; niech zaokrąglone = parseFloat(randNum.toFixed(1)); konsola.log(zaokrąglona); > 6.3
Należy pamiętać, że wartości 5 są zaokrąglane, z wyjątkiem rzadkich przypadków.

Metody toFixed() i toPrecision() są przydatne, ponieważ pozwalają nie tylko odciąć część ułamkową, ale także dodać miejsca dziesiętne, co jest wygodne podczas pracy z walutą:

Niech całeNum = 1 niech dolaryCents = całeNum.toFixed(2); konsola.log(dolarsCents); > „1,00”
Zauważ, że toPrecision zwróci wynik w notacji naukowej, jeśli liczba liczb całkowitych jest większa niż sama precyzja:

Niech num = 123,435 num.toPrecision(2); > „1.2e+2”

Jak uniknąć błędów zaokrąglania ułamków dziesiętnych

Niech numTest = 1,005; numTest.toFixed(2); > „1,00”
Wynik powyższych obliczeń powinien wynosić 1,01, a nie 1. Jeśli chcemy uniknąć podobnego błędu, możemy skorzystać z rozwiązania zaproponowanego przez Jacka L. Moore'a, który do obliczeń wykorzystuje liczby wykładnicze:

Funkcja round(wartość, miejsca dziesiętne) ( return Number(Math.round(wartość+"e"+liczby dziesiętne)+"e-"+liczby dziesiętne); )
Teraz:

Okrągłe (1,005,2); > 1.01
Jeśli chcesz bardziej niezawodnego rozwiązania niż to pokazane powyżej, możesz udać się do MDN.

Zaokrąglanie maszynowe epsilon

0,1 + 0,2 === 0,3 > fałsz
W naszej funkcji używamy Math.EPSILON, aby uzyskać prawidłowe porównanie:

Funkcja epsEqu(x, y) ( return Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Funkcja przyjmuje dwa argumenty: pierwszy to bieżące obliczenie, drugi to oczekiwany wynik. Zwraca porównanie dwóch:

EpsEqu(0,1 + 0,2; 0,3) > prawda
Wszystkie nowoczesne przeglądarki obsługują już funkcje matematyczne ES6, ale jeśli chcesz obsługiwać je w przeglądarkach takich jak IE 11, użyj wypełniaczy.

Przycinanie części ułamkowej

Funkcja obcięta(liczba) ( return Math.trunc(liczba * 100) / 100; ) obcięta(3.1416) > 3.14
Jeśli chcesz dostosować metodę do dowolnej liczby miejsc po przecinku, możesz użyć podwójnej negacji bitowej:

Funkcja obcięta(num, decimalPlaces) ( niech numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Teraz:

Niech randInt = 35,874993; obcięty(randInt,3); > 35,874

Zaokrąglij do najbliższej liczby

Runda matematyczna(4.3) > 4 Runda matematyczna(4.5) > 5
Należy pamiętać, że „połowa wartości”, 0,5, jest zaokrąglana w górę zgodnie z zasadami matematyki.

Zaokrąglij w dół do najbliższej liczby całkowitej

Podłoga matematyczna (42,23); > 42 Podłoga matematyczna (36,93); > 36
Należy pamiętać, że zaokrąglanie w dół działa w przypadku wszystkich liczb, także liczb ujemnych. Wyobraź sobie drapacz chmur z nieskończoną liczbą pięter, włączając piętra na dolnym poziomie (reprezentujące liczby ujemne). Jeśli znajdujesz się w windzie na najniższym poziomie pomiędzy 2 a 3 (co odpowiada wartości -2,5), Math.floor zabierze Cię do -3:

Podłoga matematyczna(-2,5); > -3
Jeśli jednak chcesz uniknąć tej sytuacji, użyj Math.trunc, obsługiwanego we wszystkich nowoczesnych przeglądarkach (z wyjątkiem IE/Edge):

Matematyka.trunc(-41,43); > -41
Na MDN znajdziesz polifill, który zapewni obsługę Math.trunc w przeglądarkach i IE/Edge.

Zaokrąglij w górę do najbliższej liczby całkowitej

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

Zaokrąglanie w górę/w dół do wymaganej liczby

Funkcja roundTo5(num) ( return Math.round(num/5)*5; )
Teraz:

ZaokrąglijDo5(11); > 10
Jeśli chcesz zaokrąglić do wielokrotności swojej wartości, używamy bardziej ogólnej funkcji, przekazując jej wartość początkową i wielokrotność:

Funkcja roundToMultiple(liczba, wielokrotność) ( return Math.round(liczba/wielokrotność)*wielokrotność; )
Teraz:

Niech numer początkowy = 11; niech wielokrotność = 10; roundToMultiple(numer początkowy, wielokrotność); > 10;

Naprawianie liczby w zakresie

Niech lowBound = 1; niech highBound = 100; niech liczbaWejście = 123; niech zaciśnięte = Math.max(lowBound, Math.min(numInput, highBound)); konsola.log(zaciśnięty); > 100;
Ponownie możemy ponownie wykorzystać operację i zawinąć całość w funkcję, korzystając z rozwiązania zaproponowanego przez Daniela X. Moore'a:

Number.prototype.clamp = funkcja(min, max) ( return Math.min(Math.max(this, min), max); );
Teraz:

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

Zaokrąglanie Gaussa

Funkcja gaussRound(num, decimalPlaces) ( niech 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; }
Teraz:

GaussRound(2,5) > 2 gaussRound(3,5) > 4 gaussRound(2,57,1) > 2,6
Dziesiętne w CSS:

Ponieważ JavaScript jest często używany do tworzenia mapowań pozycyjnych dla elementów HTML, możesz zastanawiać się, co by się stało, gdybyśmy wygenerowali wartości dziesiętne dla naszych elementów:

#box (szerokość: 63,667731993px;)
Dobra wiadomość jest taka, że ​​nowoczesne przeglądarki będą respektować wartości dziesiętne w modelu blokowym, w tym jednostki procentowe lub piksele.

Sortowanie

Sortowanie alfabetyczne

Niech owoc = ["dynia piżmowa", "morela", "kantalupa"]; sortowanie owoców(); > "morela", "dynia piżmowa", "kantalupa"]
Jednak gdy tylko jeden z elementów zostanie zapisany wielkimi literami, pojawia się problem:

Niech owoc = ["dynia piżmowa", "morela", "Kantalop"]; sortowanie owoców(); > „Kantalupa”, „morela”, „dynia piżmowa”]
Dzieje się tak, ponieważ domyślnie sorter porównuje pierwszy znak reprezentowany w Unicode. Unikod jest unikalny kod dla dowolnego symbolu, niezależnie od platformy, niezależnie od programu, niezależnie od języka. Na przykład, jeśli spojrzysz na tabelę kodów, znak „a” ma wartość U+0061 (w formacie szesnastkowym 0x61), podczas gdy znak „C” ma kod U+0043 (0x43), który występuje wcześniej w standardzie Unicode tabeli niż znak „a”.

Aby posortować tablicę, która może zawierać pierwsze litery o różnej wielkości liter, musimy tymczasowo przekonwertować wszystkie elementy na małe litery lub zdefiniuj własny porządek sortowania za pomocą metody localeCompare() z pewnymi argumentami. Z reguły w takim przypadku lepiej od razu utworzyć funkcję do wielokrotnego użycia:

Funkcja alphaSort(arr) ( arr.sort(funkcja (a, b) ( return a.localeCompare(b, "en", ("czułość": "baza")); )); ) niech owoc = ["dynia piżmowa „, „morela”, „Kantalupa”]; alfaSort(owoce) >
Jeśli chcesz, aby tablica była posortowana w odwrotnej kolejności alfabetycznej, po prostu zamień pozycje a i b w funkcji:

Funkcja alphaSort(arr) ( arr.sort(funkcja (a, b) ( return b.localeCompare(a, "en", („czułość": "baza")); )); ) niech owoc = ["dynia piżmowa „, „morela”, „Kantalupa”]; alphaSort(fruit) > ["Kantalupa", "dynia piżmowa", "morela"]
Tutaj warto zaznaczyć, że localeCompare używa się z argumentami, trzeba też pamiętać, że jest obsługiwane przez IE11+, w przypadku starszych wersji IE możemy go używać bez argumentów i małymi literami:

Funkcja caseSort(arr) ( arr.sort(funkcja (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) let Fruit = ["dynia piżmowa", "morela", "Kantalupa"]; caseSort(fruit) > ["morela", "dynia piżmowa", "Kantalupa"]

Sortowanie numeryczne

Niech wysokie wyniki =; wysokieWyniki.sort(); >
Rzecz w tym, że metoda sort() dokonuje porównania leksykograficznego: co oznacza, że ​​liczby zostaną zamienione na ciąg znaków i porównania zostaną ponownie wykonane poprzez dopasowanie pierwszego znaku tego ciągu w kolejności znaków w tabeli Unicode . Dlatego musimy ponownie zdefiniować naszą kolejność sortowania:

Niech wysokie wyniki =; highScores.sort(funkcja(a,b) (zwróć a - b; )); >
Ponownie, aby posortować liczby w odwrotnej kolejności, zamień pozycje a i b w funkcji.

Sortowanie struktury podobnej do JSON

Niech wyniki = [ ( "imię": "Daniel", "wynik": 21768 ), ( "imię": "Michael", "wynik": 33579 ), ( "imię": "Alison", "wynik": 38395 )];
W ES6+ możesz używać funkcji strzałek:

Scores.sort((a, b) => b.score - a.score));
W przypadku starszych przeglądarek, które nie obsługują tej obsługi:

Scores.sort(function(a, b) ( return a.score - b.score ));
Jak widać, sortowanie w JavaScript to dość niejasna sprawa, mam nadzieję, że te przykłady w jakiś sposób ułatwią życie.

Praca z funkcjami mocy

W JavaScript funkcja potęgująca jest reprezentowana jako Math.pow(), a w nowym standardzie ES7 wprowadzono nowy operator potęgowania - „ * * ”.

Potęgowanie

Matematykapow(3,2) > 9
Ta forma zapisu oznacza 3 do kwadratu, czyli 3 × 3, co prowadzi do wyniku 9. Można oczywiście podać inny przykład:

Matematyka.pow(5,3); > 125
Oznacza to, że 5 do sześcianu, czyli 5 × 5 × 5, równa się 125.

ECMAScript 7 to kolejna wersja JavaScriptu, w zasadzie możemy zastosować nowy zaproponowany operator potęgowania - * *, ta forma zapisu może być bardziej opisowa:

3 ** 2 > 9
NA w tej chwili Obsługa tego operatora jest dość ograniczona, dlatego nie zaleca się jego używania.

Funkcja zasilania może być przydatna w większości różne sytuacje. Prosty przykład obliczenia liczby sekund w godzinie: Math.pow (60,2).

Pierwiastki kwadratowe i sześcienne

Matematyka.sqrt(9) > 3
Jednocześnie pierwiastek sześcienny a jest liczbą, która po podniesieniu do sześcianu daje a.

Matematyka.cbrt(125) > 5
Funkcja Math.cbrt() została wprowadzona do specyfikacji JavaScript dopiero niedawno i dlatego jest obsługiwana tylko w nowoczesnych przeglądarkach: Chrome 38+, Firefox i Opera 25+ oraz Safari 7.1+. Zauważysz to Internet Explorera nie ma go na tej liście, ale znajdziesz polifill na MDN.

Przykłady

Matematyka.pow(1,25, 2); > 1,5625 Matematyka.cbrt(56,57) > 3,8387991760286138
Pamiętaj, że działa to również całkiem dobrze, gdy używasz ujemnych wartości argumentów:

Matematykapow(-5,2) > 25 Matematykapow(10,-2) > 0,01
Jednak to nie zadziała w przypadku pierwiastka kwadratowego:

Matematyka.sqrt(-9) > NaN
Z analizy matematycznej wiemy, że liczba urojona odnosi się do pierwiastków kwadratowych liczb ujemnych. Może to prowadzić nas do innej techniki pracy z liczbami zespolonymi, ale to inna historia.

W funkcji Math.pow() możesz używać ułamków zwykłych, aby znaleźć pierwiastki kwadratowe i sześcienne liczb. Pierwiastek kwadratowy wykorzystuje wykładnik 0,5:

Matematyka.pow(5, 0,5); // = Math.sqrt(5) = 5 ** (1/2) > 2,23606797749979
Jednak ze względu na kaprysy zmiennoprzecinkowe nie można dokładnie odgadnąć prawidłowego wyniku:

Matematykapow(2,23606797749979,2) > 5,000000000000001
W takich sytuacjach będziesz musiał uciekać się do obcięcia znaków z liczby lub zaokrąglenia do jakiejś wartości.

Niektórzy ludzie z nieznanych powodów mylą w JavaScript funkcję Math.pow() z Math.exp() , która jest ogólnie funkcją wykładniczą dla liczb. Uwaga: w angielski„wykładnik” jest tłumaczony jako „wykładnik”, więc jest to bardziej prawdopodobne w przypadku osób mówiących po angielsku, chociaż istnieją alternatywne nazwy wykładnika, takie jak indeks, potęga.

Stałe matematyczne

Math.abs, parseInt, parseFloat

Matematykaabs()

Niech nowaWart = -57,64; Math.abs(nowaWartość); > 57,64
Math.abs(0) zawsze zwraca zero, ale jeśli umieścimy znak minus przed funkcją -Math.abs(NUM), zawsze otrzymamy wartość ujemną.

Matematyka.abs(0); > -0

parseInt()

Składnia: parseInt(string, radix);

Funkcja parseInt konwertuje pierwszy przekazany jej argument na typ łańcuchowy, interpretuje go i zwraca liczbę całkowitą lub wartość NaN. Wynik (jeśli nie NaN) jest liczbą całkowitą i jest pierwszym argumentem (stringiem), traktowanym jako liczba o określonej podstawie. Na przykład podstawa 10 oznacza konwersję z systemu dziesiętnego, 8 z systemu ósemkowego, 16 z systemu szesnastkowego i tak dalej. Jeśli podstawa jest większa niż 10, wówczas litery są używane do reprezentowania liczb większych niż 9. Na przykład w przypadku liczb szesnastkowych (podstawa 16) używane są litery od A do F.

Spójrzmy na przykład pracy z właściwościami CSS, gdzie relatywnie rzecz biorąc możemy uzyskać następującą wartość:

Niech elem = dokument.treść; niech centerPoint = window.getComputedStyle(elem).transformOrigin; > „454px 2087,19px”
Wartości możemy podzielić spacjami:

Niech centra = centerPoint.split(" "); > ["454px", "2087,19px"]
Jednak każdy element jest nadal ciągiem znaków, możemy się tego pozbyć, korzystając z naszej funkcji:

Niech centerX = parseInt(centra, 10); > 454 niech centerY = parseInt(centra, 10); >2087
Jak widać drugim argumentem wskazujemy system liczbowy, na jaki zostanie przeliczona liczba; parametr ten jest opcjonalny, jednak zaleca się jego użycie, jeśli nie wiadomo, który ciąg znaków zostanie odebrany jako wejście.

parseFloat()

Składnia: parseFloat(string)

Niech FP = „33,33333%”; konsola.log(parseFloat(FP)); > 33,33333
Należy zauważyć, że w składni parseFloat nie ma drugiego argumentu.

Rozumiemy, że parseInt() i parseFloat() są niezwykle przydatne funkcje, należy pamiętać, że nadal występują pewne błędy, dlatego konieczne jest sprawdzenie zakresu oczekiwanych wartości i ostatecznie przeanalizowanie wyniku, aby upewnić się, że uzyskane wartości są prawidłowe.
Wyślij anonimowo

W tym artykule szczegółowo przyjrzymy się liczbom, operatorom matematycznym, sposobom konwersji liczby na ciąg znaków i odwrotnie, a także wielu innym ważnym punktom.

funkcja isFinite

Funkcja isFinite pozwala sprawdzić, czy argument jest liczbą skończoną.

W odpowiedzi ta funkcja zwraca wartość false, jeśli argumentem jest Infinity, -Infinity, NaN lub zostanie rzutowany na jedną z tych specjalnych wartości liczbowych. W przeciwnym razie ta funkcja zwróci wartość true.

JestSkończony(73); // true isFinite(-1/0); // false isFinite(Infinity); // fałsz isFinite(NaN); // false isFinite("Tekst"); // FAŁSZ

Oprócz globalnej funkcji isFinite JavaScript posiada także metodę Number.isFinite. W przeciwieństwie do isFinite nie wymusza konwersji argumentu na liczbę.

JestSkończony("73"); // prawda Liczba.isFinite("73"); // FAŁSZ

funkcja isNaN

Funkcja isNaN ma na celu określenie, czy argument jest liczbą lub czy można go przekonwertować na jeden. Jeśli tak, to funkcja isNaN zwraca wartość false. W przeciwnym razie zwraca wartość true.

IsNaN(NaN); //true isNaN("25px"); //prawda, ponieważ 20px nie jest liczbą isNaN(25,5); //fałsz isNaN("25,5"); //fałsz isNaN(" "); //nieprawda, ponieważ spacja lub kilka spacji jest konwertowanych na 0 isNaN(null); //nieprawda, ponieważ wartość null jest konwertowana na 0 isNaN(true); //nieprawda, ponieważ prawda jest konwertowana na 1 isNaN(fałsz); //nieprawda, ponieważ fałsz jest konwertowany na 0

Jeśli tę akcję trzeba wykonać bez rzutowania typu, użyj metody Number.isNaN. Metoda ta została wprowadzona do języka począwszy od ECMAScript 6.

Jak jawnie przekonwertować ciąg na liczbę?

Możesz jawnie przekonwertować ciąg na liczbę, korzystając z następujących metod:

1. Użyj operator jednoargumentowy +, który należy umieścić przed wartością.

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

Ta metoda ignoruje spacje na początku i na końcu linii, a także \n (przesunięcie wiersza).

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

Stosując tę ​​metodę należy zwrócić uwagę na fakt, że pusty ciąg znaków lub ciąg składający się ze spacji i \n jest konwertowany na liczbę 0. Dodatkowo konwertuje również typ danych null i wartości logiczne na liczbę .

Nieważny; //0 + prawda; //1 + fałsz; //0 +" "; //0

2. Funkcja ParseInt. Ta funkcja jest przeznaczona do konwersji argument na liczbę całkowitą. W przeciwieństwie do używania operator jednoargumentowy +, ta metoda umożliwia konwersję ciągu znaków na liczbę, w której nie wszystkie znaki są numeryczne. Rozpoczyna konwersję ciągu, zaczynając od pierwszego znaku. Gdy tylko napotka znak inny niż numeryczny, funkcja ta przestaje działać i zwraca wynikową liczbę.

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

Funkcja ta może współpracować z różnymi systemami liczbowymi (binarny, ósemkowy, dziesiętny, szesnastkowy). Podstawę systemu liczbowego określa się za pomocą 2 argumentów.

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

Oprócz funkcji parseInt JavaScript posiada metodę Number.parseInt. Metoda ta nie różni się od funkcji parseInt i została wprowadzona do JavaScriptu wraz ze specyfikacją ECMASCRIPT 2015 (6).

3. Funkcja parseFloat. Funkcja parseFloat jest podobna do parseInt z tą różnicą, że umożliwia konwersję argumentu na liczbę ułamkową.

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

Dodatkowo funkcja parseFloat w odróżnieniu od parseInt nie posiada 2 argumentów, dlatego zawsze stara się traktować ciąg znaków jako liczbę w systemie zapisu dziesiętnego.

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

Oprócz funkcji parseFloat JavaScript posiada metodę Number.parseFloat. Metoda ta nie różni się od funkcji parseFloat i została wprowadzona do JavaScriptu wraz ze specyfikacją ECMASCRIPT 2015 (6).

Konwersja liczby na ciąg

Liczbę można przekształcić w ciąg znaków za pomocą metody toString.

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

Metoda toString pozwala również na określenie podstawy systemu liczbowego, biorąc pod uwagę, że należy jawnie przekonwertować liczbę na ciąg znaków:

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

Jak sprawdzić, czy zmienna jest liczbą

Możesz określić, czy wartość zmiennej jest liczbą, korzystając z jednej z następujących metod:

1. Korzystanie z funkcji isNaN i isFinite:

// myVar jest zmienną if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar jest liczbą lub można na nią rzutować);

Jako funkcja:

// funkcja funkcja isNumeric(wartość) ( ​return !isNaN(parseFloat(wartość)) && isFinite(parseFloat(wartość)); ) // użyj var myVar = "12px"; konsola.log(isNumeric(myVar)); //PRAWDA

Ta metoda pozwala określić, czy podana wartość jest liczbą, czy też można ją przekonwertować na jedną. Ta opcja nie zlicza pustego ciągu, ciągu spacji, null, Infinity, -Infinity, true i false jako liczby.

2. Wykorzystując operator typeof i isFinite, funkcje isNaN:

// funkcja sprawdzająca, czy dana wartość jest liczbą funkcja isNumber(wartość) ( ​​zwraca typ wartości === "liczba" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Funkcja ta określa, czy podana wartość jest typu Number i czy jest to jedna z wartości specjalnych Infinity, -Infinity i NaN. Jeśli tak, to funkcja zwraca wartość true.

3. Użycie metody ECMAScript 6 Number.isInteger(value). Ta metoda pozwala określić, czy podana wartość jest liczbą całkowitą.

Liczba.isInteger("20"); //nieprawda, ponieważ ta metoda nie konwertuje ciągu znaków na liczbę Number.isInteger(20); //prawda, ponieważ ta wartość jest liczbą

Liczby parzyste i nieparzyste

Możesz sprawdzić, czy liczba jest parzysta czy nieparzysta, korzystając z następujących funkcji:

// Funkcja sprawdzająca liczbę pod kątem funkcji parzystości isEven(n) ( return n % 2 == 0; ) // Funkcja sprawdzająca liczbę pod kątem funkcji parzystości isOdd(n) ( return Math.abs(n % 2) == 1;

Ale przed przeprowadzeniem takiej kontroli wskazane jest upewnienie się, że określona wartość jest liczbą:

Wartość = 20; if (Number.isInteger(wartość)) ( if (isEven(wartość)) ( console.log("Number " + wartość.toString() + " - parzysty"); ) )

Liczby pierwsze w JavaScript

Spójrzmy na przykład, w którym będziemy wyświetlać liczby pierwsze od 2 do 100 za pomocą JavaScript.

// Funkcja sprawdzająca, czy liczba jest liczbą pierwszą funkcja isPrime(wartość) ( ​​if (isNaN(wartość) || !isFinite(wartość) || wartość%1 || wartość< 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);

Zaokrąglanie liczby w JavaScript

Istnieją różne sposoby zaokrąglania ułamka do liczby całkowitej w JavaScript.

1. Wykorzystanie specjalnie do tego przeznaczonych metod Math.floor, Math.ceil i Math.round. Metoda Math.floor zaokrągla ułamek w dół do najbliższej liczby całkowitej, tj. po prostu odrzuca część ułamkową. Funkcja Math.ceil zaokrągla ułamek w górę do najbliższej liczby całkowitej. Math.round zaokrągla liczbę w górę lub w dół w zależności od wartości części ułamkowej. Jeśli część ułamkowa jest większa lub równa 0,5, to w górę, w przeciwnym razie skręt jest w dół.

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

2. Korzystanie z metody toFixed(precyzja). Ta metoda zaokrągla część ułamkową liczby z określoną precyzją. Wynik zaokrąglenia jest zwracany w postaci ciągu znaków.

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

Jeśli nie ma wystarczającej liczby miejsc po przecinku, aby utworzyć określoną precyzję liczby, wówczas jest ona dopełniana zerami.

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

3. Stosowanie metody toPrecision(accuracy). Ta metoda reprezentuje liczbę z określoną precyzją. Jednocześnie może zaokrąglić nie tylko ułamek, ale także całą część liczby. W zależności od wyniku metoda ta może przedstawić wynikową liczbę w punkcie stałym lub w postaci wykładniczej.

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. Stosowanie operatorów logicznych NOT lub OR.

//poprzez podwójną negację logiczną console.log(~~7.9); //7 // używając logicznego OR z zerem: console.log(7.9^0); //7

Liczba całkowita i część ułamkowa liczby

Część całkowitą liczby można uzyskać za pomocą metod Math.floor() i parseInt():

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

Część ułamkową liczby można uzyskać za pomocą operatora procentowego (%). Operator ten zwraca resztę, która zostanie uzyskana z dzielenia pierwszej liczby przez drugą. W takim przypadku musisz użyć 1 jako drugiej liczby.

Konsola.log(7,21%1); // 0.20999999999999996 // z dokładnością do 2 miejsc po przecinku console.log((7.21%1).toFixed(2)); // „0,21”

Ponadto część ułamkową można również uzyskać za pomocą obliczeń:

Liczba zmiennych = 7,21; var frakcjaNumber = liczba - Math.floor(Math.abs(liczba)); konsola.log(numer frakcji); // 0,20999999999999996

Czy liczba jest podzielna przez liczbę całkowitą?

Możesz określić, czy liczba jest podzielna przez liczbę całkowitą, używając operatora procentowego:

Liczba zmiennych = 9; // jeśli reszta liczby podzielona przez 3 wynosi 0, to tak, w przeciwnym razie nie if (number%3==0) ( console.log („Liczba „ + liczba + ” jest podzielna przez 3”); ) else ( console. log("Liczba " + liczba + " nie jest podzielna przez 3" );

Formatowanie liczb

W JavaScript metoda toLocaleString() umożliwia formatowanie wyniku liczby zgodnie ze standardami regionalnymi (ustawieniami językowymi systemu operacyjnego).

Przykładowo sformatujmy liczbę zgodnie z regionalnymi standardami, które są domyślnie instalowane w systemie:

Liczba zmiennych = 345,46; konsola.log(numer.toLocaleString()); //"345,46"

Na przykład sformatujmy liczbę zgodnie z regionalnymi standardami Rosji (ru):

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

Tej metody można również użyć do sformatowania liczby jako waluty:

Console.log((2540.125).toLocaleString("ru-RU",(styl:"waluta", waluta:"RUB"))); //"2,540,13 ₽" console.log((89.3).toLocaleString("ru-RU",(styl:"waluta", waluta:"USD"))); //"89,30 $" console.log((2301.99).toLocaleString("ru-RU",(styl:"waluta", waluta:"EUR"))); //"2301,99 EUR"

Reprezentowanie liczby w procentach:

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

Podziel liczbę na cyfry (właściwość useGrouping):

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

Wydrukuj liczbę zawierającą określoną liczbę cyfr (2) po przecinku:

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

Porównanie liczb

Do porównywania liczb w JavaScript używane są następujące operatory: == (równe), != (nie równe), > (większe niż),< (меньше), >= (większy lub równy),<= (меньше или равно).

Porównajmy na przykład dwie liczby:

Konsola.log(2>3); //fałsz console.log(5>=3); //PRAWDA

Porównując liczby z częścią ułamkową, należy wziąć pod uwagę błędy, które mogą pojawić się podczas tych obliczeń.

Na przykład w JavaScript suma liczb (0,2 + 0,4) nie jest równa 0,6:

Konsola.log((0,2+0,4)==0,6); //FAŁSZ

Błędy powstają, ponieważ komputer lub inne urządzenie elektroniczne wykonuje wszystkie obliczenia w systemie drugiej liczby. Te. Przed wykonaniem jakichkolwiek czynności komputer musi najpierw przekonwertować liczby przedstawione w wyrażeniu na drugi system liczbowy. Ale nie każdą ułamkową liczbę dziesiętną można przedstawić dokładnie w drugim systemie liczbowym.

Na przykład liczba 0,25 10 jest dokładnie konwertowana na postać binarną.

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

Na przykład liczbę 0,2 10 można przeliczyć na system 2 tylko z pewną dokładnością:

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

W rezultacie błędy te będą miały wpływ na obliczenie sumy dwóch liczb i wyniki porównania. Te. Okazuje się, że JavaScript faktycznie zobaczy ten wpis w następujący sposób:

0.6000000000000001==0.6

Obliczając lub wyświetlając liczby zawierające części ułamkowe, należy zawsze wskazać dokładność, z jaką chcesz to zrobić.

Na przykład porównaj liczby z dokładnością do 2 miejsc po przecinku za pomocą metod toFixed() i toPrecision():

//metoda toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //metoda toPrecision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //PRAWDA

Podstawowe operacje matematyczne

W JavaScript istnieją następujące operatory matematyczne: + (dodawanie), - (odejmowanie), * (mnożenie), / (dzielenie), % (modulo), ++ (zwiększanie wartości o 1), -- (zmniejszanie wartości o 1 ).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, tj. 6:3=2 => 6-3*2 => reszta(0) 5%2 //1, tj. 5:2=2(.5) => 5-2*2 => reszta(1) 7,3%2 //1,3, tj. 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //znak wyniku operacji % jest równy znakowi pierwszej wartości -9%2,5 //-1,5 , tj. 9:2,5=3(.6) => 9-2,5*3 => reszta(1,5) -9%-2,5 //-1,5, tj. 9:2,5=3(.6) => 9-2,5*3 => reszta(1,5) -2%5 //-2, tj. 2:5=0(.4) => 2-5*0 => reszta(2) x = 3; konsola.log(x++); //wypisuje 3, następnie ustawia 4 console.log(x); //4 x = 3; konsola.log(++x); //ustawia 4 i wyprowadza x = 5; konsola.log(x--); //wypisuje 5, następnie ustawia 4 console.log(x); //4 x = 5; konsola.log(--x); //zestawia 4 i wyprowadza Dodatkowo JavaScript zawiera operatory kombinacji: 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).