У цій статті докладно розглянемо числа, математичні оператори, способи перетворення числа в рядок і навпаки, а також багато інших важливих моментів.

Функція isFinite

Функція isFinite дозволяє перевірити, чи аргумент є кінцевим числом.

Як відповідь дана функція повертає false , якщо аргумент є Infinity , -Infinity , NaN або буде приведений до одного з цих спеціальних числових значень. В іншому випадку ця функція поверне значення true.

IsFinite(73); // true isFinite(-1/0); // false isFinite(Infinity); // false isFinite(NaN); // false isFinite("Текст"); // false

Крім глобальної функції isFinite у JavaScript є ще метод Number.isFinite. Він на відміну від isFinite не здійснює примусове приведення аргументу до числа.

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

Функція isNaN

Функція isNaN призначена визначення того, є аргумент числом чи може бути перетворений до нього. Якщо так, то функція isNaN повертає false. В іншому випадку вона повертає true.

IsNaN(NaN); //true isNaN("25px"); //True, т.к. 20px - це число isNaN(25.5); // False isNaN("25.5"); // False isNaN(" "); // False, т.к. пробіл або кілька прогалин перетворюється на 0 isNaN(null); // False, т.к. значення null перетворюється на 0 isNaN(true); // False, т.к. значення true перетворюється на 1 isNaN(false); // False, т.к. значення false перетворюється на 0

Якщо цю дію потрібно виконати без наведення типу, використовуйте метод Number.isNaN . Цей метод був введений у мову, починаючи з ECMAScript 6.

Як явно перетворити рядок на число?

Явно привести рядок у число можна за допомогою таких способів:

1. Використати унарний оператор +, який потрібно помістити перед значенням.

+"7.35"; // 7.35 + "текст"; // NaN

Цей спосіб нехтує пробілами на початку та в кінці рядка, а також \n (перекладом рядка).

+ "7.35"; //7.35 +"7.35 \n"; //7.35

Використовуючи даний спосіб необхідно звернути увагу на те, що порожній рядок або рядок, що складається з прогалин і \n, переводиться в число 0. Крім цього вона також перетворює тип даних null і логічні значення до числа.

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

2. Функція parseInt. Ця функція призначена для перетворення аргументу в ціле число. На відміну від використання унарного оператора +, даний метод дозволяє перетворити рядок на число, в якому не всі символи є цифровими. Починає вона перетворювати рядок, починаючи з першого символу. І як тільки вона зустрічає символ, що не є цифровим, ця функція зупиняє свою роботу та повертає отримане число.

ParseInt("18px"); //18 parseInt("33.3%"); //33

Ця функція може працювати з різними системами числення (двійковою, вісімковою, десятковою, шістнадцятковою). Вказівка ​​основу системи числення здійснюється за допомогою 2 аргументів.

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

Крім функції parseInt у JavaScript є метод Number.parseInt. Цей метод нічим не відрізняється від функції parseInt і був введений у JavaScript зі специфікацією ECMASCRIPT 2015 (6).

3. Функція parseFloat. Функція parseFloat аналогічна parseInt, за винятком того, що дозволяє виконати перетворення аргументу в дробове число.

ParseFloat("33.3%"); //33.3

Крім цього функція parseFloat на відміну від parseInt не має 2 аргументів, і отже вона завжди намагається розглянути рядок як число в десятковій системі числення.

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

Крім функції parseFloat у JavaScript є метод Number.parseFloat. Цей метод нічим не відрізняється від функції parseFloat і був введений у JavaScript зі специфікацією ECMASCRIPT 2015 (6).

Перетворення числа на рядок

Перетворити число на рядок можна за допомогою методу toString.

(12.8). toString (); //"12.8"

Метод toString дозволяє вказати основу системи числення з урахуванням якої необхідно явно привести число до рядка:

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

Як перевірити чи є змінна числом

Визначити чи є значення змінної числом можна за допомогою одного з наступних способів:

1. З використанням функцій isNaN та isFinite:

// myVar - змінна if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( // myVar - це число або може бути приведено до нього);

У вигляді функції:

// функція function isNumeric(value) ( ​​return !isNaN(parseFloat(value)) && isFinite(parseFloat(value)); ) // використання var myVar = "12px"; console.log(isNumeric(myVar)); //true

Цей спосіб дозволяє визначити чи вказане значення числом або може бути приведено до нього. Даний варіант не вважає числом порожній рядок, рядок із пробілів, значення null, Infinity, -Infinity, true і false.

2. З використанням оператора типів і функцій isFinite, isNaN:

// функція яка перевіряє чи є значення числом 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 !}

Ця функція визначає, чи має вказане значення тип Number, а також чи не належить воно до одного зі спеціальних значень Infinity, -Infinity та NaN. Якщо це так, то ця функція повертає значення true.

3. За допомогою методу ECMAScript 6 Number.isInteger(value). Цей метод дозволяє визначити, чи є вказане значення цілим числом.

Number.isInteger("20"); // False, т.к. даний метод не виконує переведення рядка до Number.isInteger(20); //True, т.к. дане значення є числом

Чітні та непарні числа

Перевірити чи є число парним чи непарним можна за допомогою таких функцій:

// Функція для перевірки числа на парність function isEven(n) ( return n % 2 == 0; ) // Функція для перевірки числа на парність function isOdd(n) ( return Math.abs(n % 2) == 1; )

Але перед тим як проводити таку перевірку бажано переконатися, що вказане значення є числом:

Value = 20; if (Number.isInteger(value)) ( if (isEven(value)) ( console.log("Число " + value.toString() + " - парне"); ) )

Прості числа у Javascript

Розглянемо приклад, у якому виведемо за допомогою Javascript прості числа від 2 до 100.

// Функція, яка перевіряє чи є число простим 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);

Округлення числа Javascript

Округлити дробове число до цілого значення JavaScript можна різними способами.

1. Використовуючи спеціально призначені для цього методи Math.floor, Math.ceil та Math.round. Метод Math.floor округляє дрібне число до найближчого цілого вниз, тобто. просто відкидає дробову частину. Math.ceil округляє дрібне число до найближчого цілого вгору. Math.round округляє число вгору чи вниз залежно від значення дробової частини. Якщо дробова частина більша або дорівнює 0.5, то вгору, інакше скручення здійснюється вниз.

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

2. За допомогою методу toFixed(точність) . Даний метод округляє дрібну частину числа до заданої точності. Результат округлення повертає у вигляді рядка.

Console.log(7.987.toFixed(2)); //"7.99"

Якщо знаків після коми на формування зазначеної точності числа бракує, воно доповнюється нулями.

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

3. За допомогою методу toPrecision(точність). Даний метод представляє число із зазначеною точністю. При цьому він може округлити не тільки дрібну, а й цілу частину числа. Отримане число цей метод може подати в залежності від результату з фіксованою комою або в експоненційній формі.

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. Використовуючи логічні оператори НЕ чи АБО.

//за допомогою подвійного логічного заперечення console.log(~~7.9); //7 // у вигляді використання логічного АБО з нулем: console.log(7.9^0); //7

Ціла та дробова частина числа

Отримати цілу частину числа можна за допомогою методу Math.floor() і parseInt() :

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

Отримати дробову частину числа можна оператором, що скористався відсоток (%). Цей оператор повертає залишок, який буде отримано від поділу першого числа на друге. В даному випадку як 2 числа необхідно використовувати 1.

Console.log(7.21%1); // 0.20999999999999999 // з точністю до 2 знаків після коми console.log((7.21%1).toFixed(2)); // "0.21"

Крім цього, дробову частину можна отримати також за допомогою обчислень:

Var number = 7.21; var fractionNumber = number - Math.floor(Math.abs(number)); console.log(fractionNumber); // 0.20999999999999996

Чи ділиться число націло

Визначити чи ділиться число націло можна за допомогою оператора відсотка:

Var number = 9; // якщо залишок від розподілу числа number на 3 дорівнює 0, то так, інакше немає if (number%3==0) ( console.log ( "Число " + number + " ділиться на 3 "); ) else (console. log ("Число" + number + "не ділиться на 3");

Форматування чисел

У JavaScript відформатувати виведення числа відповідно до регіональних стандартів (мовні налаштування операційної системи) дозволяє метод toLocaleString() .

Наприклад, виконаємо форматування числа відповідно до регіональних стандартів, які встановлені в системі за промовчанням:

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

Наприклад, виконаємо форматування числа відповідно до регіональних стандартів Росії (ru):

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

Даний метод також можна використовувати для форматування числа у вигляді валюти:

Console.log((2540.125).toLocaleString("ru-RU",(style:"currency", currency:"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"))); //"2 301,99 €"

Подання числа у вигляді відсотків:

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

Розбити число на розряди (властивість useGrouping):

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

Вивести з число з певною кількістю цифр (2) після коми:

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

Порівняння чисел

Для порівняння чисел у JavaScript використовуються наступні оператори: == (рівно), != (не рівно), > (більше),< (меньше), >= (Більше або одно),<= (меньше или равно).

Наприклад, порівняємо два числа:

Console.log(2>3); // False console.log (5> = 3); //true

При порівнянні чисел з дробовиною необхідно враховувати похибки, які можуть виникати під час цих обчислень.

Наприклад, у JavaScript сума чисел (0.2 + 0.4) не дорівнює 0.6:

Console.log((0.2+0.4)==0.6); //false

Похибки відбуваються тому що всі обчислення комп'ютера або іншого електронного пристрою виробляє в 2 системі числення. Тобто. перед тим як виконати якісь дії комп'ютер спочатку повинен перетворити представлені у виразі числа 2 систему числення. Але, не будь-яке дрібне десяткове число можна представити в 2 системі числення точно.

Наприклад, число 0.25 10 двійкову систему перетворюється точно.

0,125 × 2 = 0,25 | 0 0.25 × 2 = 0.5 | 0 0.5 × 2 = 1 | 1 0.125 10 = 0.001 2

Наприклад, число 0.2 10 можна перетворити на 2 систему тільки з певною точністю:

0.2×2 = 0.4 | 0 0.4 × 2 = 0.8 | 0 0.8 × 2 = 1.6 | 10.6 × 2 = 1.2 | 10.2 × 2 = 0.4 | 0 0.4 × 2 = 0.8 | 0 0.8 × 2 = 1.6 | 10.6 × 2 = 1.2 | 10.2 × 2 = 0.4 | 0 0.4 × 2 = 0.8 | 0 0.8 × 2 = 1.6 | 10.6 × 2 = 1.2 | 1 ... 0.2 10 = 0.001100110011 ... 2

В результаті ці похибки позначаться при обчисленні суми двох чисел та результати порівняння. Тобто. вийде що насправді JavaScript буде бачити цей запис наступним чином:

0.6000000000000001==0.6

При обчисленнях чи відображенні чисел із дробовою частиною необхідно завжди вказувати точність, з якою це необхідно робити.

Наприклад, порівняти числа до 2 знаків після коми використовуючи методи toFixed() і toPrecision() :

//метод toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //метод toPrecision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //true

Основні математичні операції

У JavaScript існують наступні математичні оператори: + (додавання), - (віднімання), * (множення), / (розподіл), % (залишок від поділу), ++ (збільшити значення на 1), - (зменшити значення на 1 ).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, тобто. 6: 3 = 2 => 6-3 * 2 => зуст (0) 5% 2 / / 1, тобто. 5:2=2(.5) => 5-2*2 => зуст(1) 7.3%2 //1.3, тобто. 7.3:2=3(.65) => 7.3-2*3 => ост(1.3) //знак результату операції % дорівнює знаку першого значення -9%2.5 //-1.5, тобто. 9:2.5=3(.6) => 9-2.5*3 => зуст(1.5) -9%-2.5 //-1.5, тобто. 9:2.5=3(.6) => 9-2.5*3 => зуст(1.5) -2%5 //-2, тобто. 2:5 = 0 (.4) => 2-5 * 0 => зуст (2) x = 3; console.log(x++); //виводить 3, вже потім встановлює 4 console.log(x); //4 x = 3; console.log(++x); //встановлює 4 та виводить x = 5; console.log(x--); //виводить 5, вже потім встановлює 4 console.log(x); //4 x = 5; console.log(--x); //встановлює 4 і виводить Крім цього JavaScript є комбіновані оператори: x+=y (x=x+y), x-=y (x=x-y), x*=y (x=x*y), x/= y (x = x / y), x % = y (x = x % y). x = 3; y = 6; x+=y; console.log(x); //9 x = 3; y = 6; x-=y; console.log(x); //-3 x = 3; y = 6; x * = y; console.log(x); //18 x = 3; y = 6; x/=y; console.log(x); //0.5 x = 3; y = 6; x%=y; console.log(x); //3