Методи округлення чисел у JavaScript. Об'єкт Math в javascript - Методи round, ceil та floor - Округлення дробових чисел Js округлення

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Для практичних цілей ця неточність не має жодного значення, у нашому випадку ми говоримо про помилку в квінтильйонних частках, проте когось це може розчарувати. Ми можемо отримати трохи дивний результат і при роботі з числами, які є значеннями валют, відсотків або розмірів файлу. Для того, щоб виправити ці неточності, нам якраз і необхідно вміти округляти результати, достатньо встановити десяткову точність.

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

Let randNum = 6.25; let rounded = randNum.toFixed(); // "6" console.log(randNum + rounded); > "6.256"
Якщо ви хочете, щоб результат мав числовий тип даних, вам необхідно буде застосувати parseFloat:

Let randNum = 6.25; let rounded = parseFloat(randNum.toFixed(1)); console.log(rounded); > 6.3
Зверніть увагу, що значення 5 округлені, за винятком поодиноких випадків.

Методи toFixed() і toPrecision() є корисними, бо вони можуть не тільки відсікати дробову частину, а й доповнювати знаки після коми, що зручно під час роботи з валютою:

Let wholeNum = 1 let dollarsCents = wholeNum.toFixed(2); console.log(dollarsCents); > "1.00"
Варто зауважити, що допереживання буде давати результат в експоненційному записі, якщо число цілих чисел більше, ніж сама сама точність:

Let num = 123.435 num.toPrecision(2); > "1.2e+2"

Let numTest = 1005; numTest.toFixed(2); > "1.00"
Результат розрахунку повинен був бути 1.01, а не 1. Якщо ви хочете уникнути подібну помилку, ми можемо використовувати рішення, запропоноване Jack L Moore , яке використовує експоненційні числа для розрахунку:

Function round(value, decimals) ( return Number(Math.round(value+"e"+decimals)+"e-"+decimals); )
Тепер:

Round (1.005,2); > 1.01
Якщо ви хочете більш надійне рішення, ніж рішення наведене вище, ви можете перейти на MDN .

0.1 + 0.2 === 0.3 > false
Ми використовуємо Math.EPSILON у нашій функції для отримання коректного порівняння:

Function epsEqu(x, y) ( return Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Функція приймає два аргументи: перший – поточний розрахунок, другий – очікуваний результат. Вона повертає порівняння двох:

EpsEqu(0.1 + 0.2, 0.3) > true
Всі сучасні браузери вже підтримують ES6 математичних функцій, але якщо ви хочете отримати підтримку в таких браузерах, як IE 11, використовуйте polyfills .

Function truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3.1416) > 3.14
Якщо ви хочете пристосувати метод під будь-яку кількість знаків після коми, ви можете скористатися подвійним побитовим запереченням:

Function truncated(num, decimalPlaces) ( let numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Тепер:

Let randInt = 35.874993; truncated(randInt,3); > 35.874

Math.round(4.3) > 4 Math.round(4.5) > 5
Зверніть увагу, що «половина значення», 0.5 округляється у велику сторону за правилами математики.

Math.floor(42.23); > 42 Math.floor(36.93); > 36
Зауважте, що округлення в меншу сторону працює для всіх чисел, у тому числі і для негативних. Уявіть хмарочос із нескінченною кількістю поверхів, у тому числі з поверхами нижнього рівня (що представляє негативні числа). Якщо ви знаходитесь в ліфті на нижньому рівні між 2 і 3 (що являє собою значення -2.5), Math.floor доставить вас до -3:

Math.floor(-2.5); > -3
Але якщо ви хочете уникнути подібної ситуації, використовуйте Math.trunc, який підтримується у всіх сучасних браузерах (крім IE/Edge):

Math.trunc(-41.43); > -41
На MDN ви знайдете polyfill, який забезпечить підтримку Math.trunc у браузерах та IE/Edge.

Math.ceil(42.23); > 43 Math.ceil(36.93); > 37 Math.ceil(-36.93); > -36

Function roundTo5(num) ( return Math.round(num/5)*5; )
Тепер:

RoundTo5(11); > 10
Якщо ви хочете округляти до кратних свого значення, ми використовуємо більш загальну функцію, передаючи в неї початкове значення і кратне:

Function roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )
Тепер:

Let initialNumber = 11; let multiple = 10; roundToMultiple(initialNumber, multiple); > 10;

Let lowBound = 1; let highBound = 100; let numInput = 123; let clamped = Math.max(lowBound, Math.min(numInput, highBound)); console.log(clamped); > 100;
Знову ж таки, ми можемо перевикористовувати операцію і обернути все це в функцію, скористаємося рішенням, запропонованим Daniel X. Moore :

Number.prototype.clamp = function(min, max) ( return Math.min(Math.max(this, min), max); );
Тепер:

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

Function 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; }
Тепер:

GaussRound(2.5) > 2 gaussRound(3.5) > 4 gaussRound(2.57,1) > 2.6
Десятковий знак у CSS:

Так як JavaScript часто використовується для створення позиційного перетворення HTML-елементів, ви можете поставити питання, що станеться, якщо ми cгенеруємо десяткові значення для наших елементів:

#box (width: 63.667731993px; )
Хороша новина полягає в тому, що сучасні браузери враховуватимуть десяткові значення у блочній моделі, у тому числі у процентних чи піксельних одиницях виміру.

Let fruit = ["butternut squash", "apricot", "cantaloupe"]; fruit.sort(); > "apricot", "butternut squash", "cantaloupe"]
Тим не менш, ми стикаємося з проблемою, як тільки один з елементів знаходиться у верхньому регістрі:

Let fruit = ["butternut squash", "apricot", "Cantalope"]; fruit.sort(); > "Cantaloupe", "apricot", "butternut squash"]
Це пов'язано з тим, що, за замовчуванням, сортувальник порівнює перший символ, представлений в Unicode . Unicode - це унікальний коддля будь-якого символу, незалежно від платформи, незалежно від програми, незалежно від мови. Наприклад, якщо по кодовій таблиці символ «a» має значення U+0061 (у шістнадцятковій системі 0x61), тоді як символ «C» має код U+0043 (0x43), який йде раніше в Unicode-таблиці, ніж символ "a".

Щоб відсортувати масив, який може містити змішані регістри перших букв, нам необхідно або перетворити всі елементи тимчасово в нижній регістр, або визначити порядок сортування за допомогою методу localeCompare() з деякими аргументами. Як правило, для такого випадку, краще відразу створити функцію для багаторазового використання:

Function alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("sensitivity": "base")); )); ) let fruit = ["butternut squash "Apricot", "Cantaloupe"]; alphaSort(fruit) >
Якщо ви хочете отримати масив відсортований у зворотному алфавітному порядку, просто поміняйте позиціями а та b у функції:

Function alphaSort(arr) ( arr.sort(function (a, b) ( return b.localeCompare(a, "en", ("sensitivity": "base")); )); ) let fruit = ["butternut squash "Apricot", "Cantaloupe"]; alphaSort(fruit) > ["Cantaloupe", "butternut squash", "apricot"]
Тут варто звернути увагу, що localeCompare використовується з аргументами, ще треба пам'ятати, що він підтримується IE11+, для більш старих версій IE ми можемо використовувати його без аргументів, і в нижньому регістрі:

Function caseSort(arr) ( arr.sort(function (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) let fruit = ["butternut squash", "apricot", "Cantaloupe"]; caseSort(fruit) > ["apricot", "butternut squash", "Cantaloupe"]

Let highScores = ; highScores.sort(); >
Справа в тому, що метод sort() здійснює лексикографічне порівняння: а це означає, що числа будуть перетворені в рядок і порівняння будуть знову проводитися шляхом зіставлення першого символу цього рядка в порядку символів Unicode-таблиці. Тому нам знову необхідно визначити свій порядок сортування:

Let highScores = ; highScores.sort(function(a,b) ( return a - b; )); >
Знову ж таки, для сортування чисел у зворотному порядку, поміняйте позиціями a та b у функції.

Let scores = [ ( "name": "Daniel", "score": 21768 ), ( "name": "Michael", "score": 33579 ), ( "name": "Alison", "score": 38395 )];
В ES6+, ви можете використовувати стрілочні функції:

Scores.sort((a, b) => b.score - a.score));
Для старих браузерів, які не мають такої підтримки:

Scores.sort(function(a, b) (return a.score - b.score));
Як бачите, сортування JavaScript це досить не очевидна річ, я сподіваюся, що ці приклади полегшать як-небудь життя.

У JavaScript статечнафункція представлена ​​як Math.pow(), в новому стандарті ES7 був представлений новий оператор зведення в ступінь - "* *".

Math.pow(3,2) > 9
Така форма запису означає 3 у квадраті, або 3 × 3, що призводить до результату 9. Можна навести ще приклад, звичайно:

Math.pow (5,3); > 125
Тобто, 5 у кубі, або 5×5×5, дорівнює 125.

ECMAScript 7 - це наступна версія JavaScript, в принципі, ми можемо використовувати новий запропонований оператор зведення в ступінь - * *, така форма запису може бути наочнішою:

3 ** 2 > 9
на Наразіпідтримка цього оператора досить обмежена, тому його не рекомендується використовувати.

Ступенева функція може стати в нагоді в різних ситуаціях. Простий приклад, обчислення кількості секунд за годину: Math.pow (60,2).

Math.sqrt(9) > 3
У той же час кубічний корінь із числа a - число, що дає a при зведенні куб.

Math.cbrt(125) > 5
Math.cbrt() був введений у специфікацію JavaScript зовсім недавно, і тому підтримується лише у сучасних браузерах: Chrome 38+, Firefox та Opera 25+ та Safari 7.1+. Ви помітите, що Internet Explorerвідсутній у цьому списку, однак на MDN ви знайдете поліфіл.

Math.pow (1.25, 2); > 1.5625 Math.cbrt(56.57) > 3.8387991760286138
Зверніть увагу, що це цілком працює і при використанні негативних значенняхаргументів:

Math.pow(-5,2) > 25 Math.pow(10,-2) > 0.01
Тим не менш, для квадратного кореня це не працюватиме:

Math.sqrt(-9) > NaN
З математичного аналізу ми знаємо, що під уявним числом розуміють квадратне коріння з негативних чисел. І це може призвести до ще однієї техніки роботи з комплексними числами, але це вже інша історія.

Ви можете використовувати дробові значення в Math.pow(), щоб знайти квадратні та кубічні корені чисел. Квадратний корінь використовує показник 0.5:

Math.pow (5, 0.5); // = Math.sqrt(5) = 5 ** (1/2) > 2.23606797749979
Однак, через примхи з плаваючою точкою, ви не можете точно припустити правильний результат:

Math.pow(2.23606797749979,2) > 5.000000000000001
У таких ситуаціях, вам доведеться вдаватися до відсікання знаків у числа або округлення до будь-якого значення.

Деякі з незрозумілих причин у JavaScript плутають функцію Math.pow() з Math.exp() , яка є експоненційною функцією для чисел, загалом. Примітка: англійською"показник ступеня" перекладається як "exponent", тому це швидше відноситься до англомовних, хоча існують і альтернативні назви показника ступеня, такі як index, power.

Let newVal = -57.64; Math.abs(newVal); > 57.64
Math.abs(0) завжди повертає нуль, але якщо поставити знак мінус перед функцією Math.abs(NUM) ми завжди будемо негативне значення.

Math.abs(0); > -0

Синтаксис: parseInt(string, radix);

Функція parseInt перетворює перший переданий їй аргумент на рядковий тип, інтерпретує його і повертає ціле число або значення NaN. Результат (якщо не NaN) є цілим числом і є першим аргументом (string), що розглядається як число у зазначеній системі числення (radix). Наприклад, підстава 10 вказує на перетворення з десяткового числа, 8 - вісімкового, 16 - шістнадцяткового і так далі. Якщо основа більша за 10, то для позначення цифр більше 9 використовуються літери. Наприклад, для шістнадцяткових чисел (основа 16) використовуються літери від A до F.

Розглянемо приклад роботи з CSS-властивостями, де, умовно кажучи, ми можемо отримати таке значення:

Let elem = document.body; let centerPoint = window.getComputedStyle(elem).transformOrigin; > "454px 2087.19px"
Ми можемо розділити значення пробілів:

Let centers = centerPoint.split(" "); > ["454px", "2087.19px"]
Однак, кожен елемент все ще є рядок, ми можемо позбавитися цього застосувавши нашу функцію:

Let centerX = parseInt(centers, 10); > 454 let centerY = parseInt(centers, 10); > 2087
Як бачите, другим аргументом ми вказуємо систему числення, в яку буде перетворено число, цей параметр необов'язковий, але його рекомендується використовувати, якщо ви не знаєте, який рядок надійде на вхід.

Синтаксис: parseFloat(string)

Let FP = "33.33333%"; console.log(parseFloat(FP)); > 33.33333
Зверніть увагу, що синтаксис parseFloat не має другого аргументу.

Ми розуміємо, що parseInt() і parseFloat() є надзвичайно корисними функціями, важливо враховувати, що й тут не обійтися без помилок, тому необхідно перевіряти діапазон очікуваних значень і, зрештою, аналізувати результат, щоб гарантувати, що отримані значення вірні.
Надіслати анонімно

Math.round() функція відхиляє значення номера, що походить до близької частини.

Source для цього interactive example is stored in GitHub repository. Якщо ви знайдете, щоб розширити проектні приклади, повторити clone https://github.com/mdn/interactive-examples і виконати додаткові запити.

Значення given number rounded to nearest integer.

Якщо fractional portion of argument є більшим, ніж 0.5, argument є рівним до integer with next higher absolute value. Якщо це не так, як 0.5, то це означає, що integer with lower absolute value. Якщо fractional portion is exactly 0.5, argument is rounded to the next integer in the direction of +∞. Note that this differs from many languages" round() функцій, які often round this case to the next integer away from zero, instead giving a different result in the case of negative numbers with fractional part of exactly 0.5.

Тому, що round() є статичним методом Math , ви можете використовувати його як Math.round() , тому що ти є методом Math object you created (Мати не маєш constructor).

Це означає, що код коду, що є функціонально еквівалентним матулі. Принцип сніппету коду нижче є демонструвати how Math.round works.

Function vanilla_round(x) ( var y = Math.abs(x) + 0.5; // so that less than 1/2 rounds down; greater rounds up return Math.floor(x+0.5) )

Modus operator над gets decimal part of x. Further, the code snippet could be modified to round to a certain precision on a number:

Function round_to_precision(x, precision) ( var y = +x + (precision === undefined ? 0.5: precision/2); return y - (y % (precision === undefined ? 1: +precision)); )

Round_to_precision(11, 2); // outputs 12 round_to_precision(11, 3); // outputs 12 round_to_precision(11, 4); // outputs 12 round_to_precision(11, 5); // outputs 10 round_to_precision(11, 6); // outputs 12 round_to_precision(11, 7); // outputs 14 round_to_precision(11, 8); // outputs 8 round_to_precision (3.7, 0.5); // outputs 3.5 round_to_precision (3.75, 0.5); // outputs 4 round_to_precision(3.8, 0.5); // outputs 4

Компактність таблиці в цій сторінці генерується з структурованих даних. Якщо ви знайдете, щоб дізнатися про ваші дані, клацніть на https://github.com/mdn/browser-compat-data і пишуть.

Update compatibility data on GitHub

Тепер розглянемо метод floor (У перекладі - стать), який працює протилежно до методу ceil , тобто. він округляє дрібне число в МЕНШУ бік.

var age = 35.97;

age = Math .floor (age); /* Округлюємо значення змінної age у менший бік */

document.write (age);

Як бачите, метод floor округлив число 35.97 до 35 , тобто меншу сторону. Незважаючи на те, що 0.97 більше за 0.5 (див.).

У цьому уроці були розглянуті методи об'єкта Math, що дозволяють округляти десяткові дрібні числа.

Тепер потрібно виконати домашнє завдання.

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

На виході функція повинна виводити цей масив, але при цьому все елементи масиву, повинні бути округлені за допомогою вказаного у другому параметрі методу Math об'єкта .

Вихідний масив:

var numberArray = ;

Спочатку вирішення цього завдання може здаватися практично ідентичним з рішеннями домашніх завдань. перших трьохуроків цієї теми. Але не все так просто...

Рішення №1 - Увага

За умовою завдання функція повинна приймати два параметри - вихідний масив і один із методів: "round", "ceil" або "floor". Виходячи з цього, я намагався зробити так ...

function decimal (anyArray ,method ) /* Створюємо функцію з двома параметрами */
{

for (i = 0; i< anyArray .length ; i ++ )

{
document.write (anyArray
" )

anyArray = Math .method (anyArray ); /* За допомогою одного з методів об'єкта Math округляємо поточний елемент масиву */

document.write (anyArray + "

" )
}

decimal (numberArray, round ) /* Викликаємо функцію та вказуємо для неї два параметри. Але НЕ МОЖНА вказувати ІМ'Я методу як параметр функції */

У цьому рішенні створюємо функцію з двома параметрами, а коли її викликаємо, то як параметри функції пробуємо вказати вихідний масив та ІМ'Я одного методів:
decimal (numberArray, round) - в даному випадку round.

Але результату ми не отримаємо, тому що НЕ МОЖНА вказувати ІМ'Я методу як параметр функції.

Зверніть увагу: адже не випадково за умови завдання імена методів "round", "ceil" і "floor" укладені в лапки.

decimal (numberArray, "round") - але такий запис теж не буде вірним!

Рішення №2 - Коригуємо попереднє рішення

Ви можете вирішити завдання, вказавши для функції один параметр.

var numberArray = ;

function decimal (anyArray ) /* Створюємо функцію з одним параметром */
{

for (i = 0; i< anyArray .length ; i ++ ) /* Перебираем элементы массива */

{
document.write (anyArray + " - вихідний елемент масиву
" ) /* Виводимо поточний елемент масиву */

/* За допомогою методу round об'єкта Math округляємо поточний елемент масиву */

document.write (anyArray + " - Округлений елемент

" ) /* Виводимо ОКРУЖЕНИЙ елемент масиву */
}

decimal (numberArray ) /* Викликаємо функцію та вказуємо один параметр - вихідний масив */

35 - Округлений елемент

13 - Округлений елемент

17 - Округлений елемент

79 - Округлений елемент

Тут вдалося досягти потрібного результату: метод round округлив усі числа по . Але виконано умова , оскільки функція приймає лише одне параметр.

Рішення №3 - Функція з двома параметрами

Тут завдання вирішено правильно. Для цього треба було згадати тему умов у javascriptта застосувати кілька умоводночасно.

var numberArray = ;

function decimal (anyArray ,method )
{
for (i = 0; i< anyArray .length ; i ++ )
{
document.write (anyArray + " - вихідний елемент масиву
" );

if (method
{
anyArray = Math .round (anyArray);
document.write (anyArray + " - стандартне округлення

" )
}

Else if(method
{

document.write (anyArray + " - округляємо в ВЕЛИКИЙ бік

" )
}

else if(method
{

document.write (anyArray + " - округляємо в МЕНШУ бік

" )
}

}
}
decimal (numberArray, "ceil" )/* Другим параметром функції - в лапках вказуємо ім'я одного з методів */

34.82 - вихідний елемент масиву
35 - округляємо у ВЕЛИКИЙ бік

12.9 – вихідний елемент масиву
13 - округляємо в ВЕЛИКИЙ бік

17.01 – вихідний елемент масиву
18 - округляємо в ВЕЛИКИЙ бік

78.51 - вихідний елемент масиву
79 - округляємо в ВЕЛИКИЙ бік

Це правильне рішенняДомашнє завдання. Тут для функції вказано два параметри відповідно до умови.

Спробуйте у останньому рядкуцього рішення:
decimal (numberArray, "ceil" ) як другий параметр функції вказати імена інших методів "round" і "floor" об'єкта Math .

Рішення №4 – Функція з двома параметрами + метод prompt

Я вирішив трохи оптимізувати попереднє рішення та додав метод prompt, який викликає модальне вікномістить поле для введення інформації.

Тепер завдяки цьому можна буде ввести назву одного з методів round, floor або ceil у полі для введення та отримати відповідний результат.

var numberArray = ;

function decimal (anyArray ,method )
{
for (i = 0; i< anyArray .length ; i ++ )
{
document.write (anyArray + " - вихідний елемент масиву
" );

if (method == "round") /* 1-а умова */
{
anyArray = Math .round (anyArray);
document.write (anyArray + "

" )
}

Else if(method == "ceil" ) /* 2-ге умова */
{
anyArray = Math .ceil (anyArray );
document.write (anyArray + "

" )
}

else if(method == "floor" ) /* 3-тя умова */
{
anyArray = Math .floor (anyArray);
document.write (anyArray + "

" )
}

/* Додаємо метод prompt */

var method = prompt ("Введіть один з методів: round, ceil або floor");

if (method == "floor") /* 1-а умова */
{
document.write ("Ви ввели метод" + method + ", який округляє числа в МЕНШУ бік

" )
}

else if (method == "round" ) /* 2-ге умова */
{
document.write ("Ви ввели метод" + method + ", який округляє числа за стандартними правилами

" )
}

else if (method == "ceil" ) /* 3-тя умова */
{
document.write ("Ви ввели метод" + method + ", який округляє числа в ВЕЛИКИЙ бік

" )
}

else /* Інакше... */
{
document.write ("Ви не ввели або помилково ввели метод

" )
}

decimal (numberArray, method ) /* Викликаємо функцію */

Ось так працюють методи round, floor або ceil об'єкта Math, які округляють дробові числа.

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

Функція 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 повертає 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найпростіші числа від 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 (больше), < (меньше), >= (Більше або одно), 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