Як позначається ціле число js. Remove - Цілочисленний поділ із залишком у JavaScript? Робота зі статечними функціями

Часто обчислення дають результати, які відповідають межам потрібних діапазонів. В результаті потрібно здійснювати JavaScript округленнядо певного значення.

Навіщо округляти числа?

JavaScript не зберігає цілі числа, оскільки їх значення представлені у вигляді цифр з плаваючою точкою. Багато дробів не можуть бути представлені числом з певною кінцевою кількістю знаків після коми, тому JavaScript може генерувати результати на кшталт наведеного нижче:

0.1 * 0.2; > 0.020000000000000004

На практиці це не матиме жодного значення, оскільки йдеться про похибку у 2 квінтиліонні. Але це може вплинути на результат при роботі з числами, які представляють значення валют, відсотків або розмір файлу. Тому потрібно зробити або до певного знаку після коми.

Округлення десяткових чисел

Щоб "обрізати" десяткове число, використовуються методи toFixed() або toPrecision(). Вони обидва приймають один аргумент, який визначає кількість значущих і знаків після коми, які мають бути включені до результату:

• якщо для toFixed() аргумент не визначено, значення за умовчанням дорівнює 0, тобто без знаків після коми; максимальне значенняаргументу дорівнює 20;
• якщо для toPrecision() аргумент не заданий, число не змінюється.

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"

Примітка

І toFixed() , і toPrecision повертають округлене рядкове уявлення результату, а чи не число. Це означає, що додаток rounded до randNum в результаті дасть конкатенацію рядків, а не одне число:

console.log(randNum + rounded); > "6.256"

Якщо потрібно отримати в результаті JavaScript округлення до сотих число, використовуйте parseFloat() :

var randNum = 6.25; var rounded = parseFloat(randNum.toFixed(1)); console.log(rounded); > 6.3

toFixed() і toPrecision() також є корисними методами для усічення великої кількості знаків після коми. Це зручно при роботі з числами, що становлять грошові одиниці:

var wholeNum = 1 var dollarsCents = wholeNum.toFixed(2); console.log(dollarsCents); > "1.00"

Зверніть увагу, що якщо в числі більше знаків, ніж вказано параметром точності, топерерахунок буде видавати результат у науковому форматі:

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

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

У деяких випадках доFixed і toPrecision здійснюють JavaScript округлення 5 у менший бік, а не до більшого:

var numTest = 1.005; numTest.toFixed(2); > 1;

Результатом наведеного вище прикладу має бути 1.01, а не 1. Якщо потрібно уникнути цієї помилки, я рекомендую використати експоненційні числа:

function round(value, decimals) ( return Number(Math.round(value+"e"+decimals)+"e-"+decimals); )

Застосування:

round(1.005,2); > 1.01

Якщо потрібно ще надійніше рішення, ніж округлення, воно доступне на MDN.

Округлення за допомогою епсілону

Альтернативний метод JavaScript округлення до десятихбув введений в ES6 ( також відомому, як JavaScript 2015). « Машинний епсілон» забезпечує розумну межу похибки при порівнянні двох чисел з плаваючою комою. Без округлення, порівняння можуть дати результати, подібні до таких:

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. Але якщо необхідно забезпечити підтримку в старих браузерах, потрібно використовувати поліфіли.

Усічення десяткових чисел

Усі методи, представлені раніше, виконують JavaScript округлення до десятих. Щоб усікти позитивне число до двох знаків після коми, помножити його на 100 , усікти знову, а потім отриманий результат розділити на 100 , потрібно:

function truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3.1416) > 3.14

Якщо потрібно щось гнучкіше, можна скористатися побітовим оператором:

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

Використання:

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

Округлення до найближчого числа

Щоб здійснити JavaScript округлення до цілого, використовується Math.round() :

Math.round(4.3) > 4 Math.round(4.5) > 5

Зверніть увагу, що " половинні значення«, такі як .5, округляються вгору.

Округлення вниз до найближчого цілого числа

Якщо ви хочете округляти у менший бік, використовуйте метод Math.floor() :

Math.floor(42.23); > 42 Math.floor(36.93); > 36

Округлення "вниз" має один напрямок для всіх чисел, у тому числі і для негативних. Це можна уявити, як хмарочос з нескінченною кількістю поверхів, у тому числі і нижче за рівень фундаменту ( які представляють негативні числа). Якщо ви знаходитесь в ліфті між підвальними поверхами 2 та 3 ( що відповідає значенню -2.5), Math.floor доставить вас на поверх -3 :

Math.floor(-2.5); > -3

Якщо потрібно уникнути цього, використовуйте JavaScript Math округлення за допомогою Math.trunc() , який підтримується у всіх сучасних браузерах (крім IE / Edge):

Math.trunc(-41.43); > -41

MDN також надає поліфіл з трьох рядків для забезпечення підтримки Math.trunc у старих браузерах та IE / Edge.

Округлення вгору до найближчого цілого числа

Якщо ви хочете заокруглити десяткові числа вгору, використовуйте Math.ceil . Дія цього методу також можна уявити, як нескінченний ліфт: Math.ceil завжди везе вас "вгору", незалежно від того, чи є число негативним або позитивним:

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

Округлення до найближчого кратного числа

Якщо потрібно округлити значення до найближчого числа, кратного 5 , створіть функцію, яка ділить число на 5 округляє його, а потім множить результат на те ж значення:

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

Використання:

roundTo5(11); > 10

Якщо потрібно виконати JavaScript округлення до двох знаків, можна передавати функції як початкове число, так і кратність:

function roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )

Щоб використовувати функцію, увімкніть у її виклик округлене число та кратність:

var initialNumber = 11; var multiple = 10; roundToMultiple(initialNumber, multiple); > 10;

Щоб заокруглити значення тільки у більшу або меншу сторону, замініть у функції round на ceil або floor.

Прив'язка до діапазону

Іноді потрібно отримати значення х, яке має знаходитись у межах певного діапазону. Наприклад, потрібно значення від 1 до 100, але ми отримуємо значення 123. Щоб виправити це, можна використовувати min() ( повертає найменше із чисел) та max ( повертає максимально допустиме число).

Використання:

var lowBound = 1; var highBound = 100; var numInput = 123; var clamped = Math.max(lowBound, Math.min(numInput, highBound)); console.log(clamped); > 100;

Можна створити функцію або розширення класу Number.

Це дозволяє виправити відповідь @ MarkElliot, щоб він працював і для негативних чисел:

Var div = Math.trunc(y/x); var rem = y % x;

Зверніть увагу, що методи Mathмають перевагу перед побітовими операторами, що вони працюють з числами понад 231 .

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

FLOOR визначається як "найбільше ціле число, менше, ніж параметр", таким чином:

• позитивні числа: FLOOR(X) = ціла частина X;
• негативні числа: FLOOR (X) = ціла частина X мінус 1 (бо вона повинна бути SMALLER, ніж параметр, тобто більш негативний!)

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

JavaScript обчислює все так, як очікувалося, тому програміст повинен бути обережним, щоб ставити правильні питання (і люди повинні бути обережні, щоб відповісти на те, що задано!) Перше питання Ярина був НЕ «що таке цілісний поділ X на Y», замість цього: «Ціле число разів, коли це ціле число ЙДЕ В інше». Для позитивних чиселвідповідь один і той ж для обох, але не для негативних чисел, тому що цілий поділ (дивіденд на дільник) буде -1 менше, ніж число (ділитель) «переходить в інше» (дивіденд). Іншими словами, FLOOR поверне правильну відповідь для цілого поділу негативного числа, але Ярин не запитав про це!

gammax правильно відповів, цей код працює за завданням Ярина. З іншого боку, Самуїл помиляється, він не робив математики, я думаю, або він бачив би, що це дійсно працює (також він не сказав, що було дільником його прикладу, але я сподіваюся, що це було 3):

Залишок = X% Y = -100% 3 = -1

GoesInto = (X - Remainder) / Y = (-100 - -1) / 3 = -99 / 3 = -33

До речі, я тестував код на Firefox 27.0.1, він працював, як очікувалося, з позитивними та негативними числами, а також з нецілими значеннями як для дивідендів, так і для дільників. Приклад:

100.34/3.57: GoesInto = -28, Remainder = -0.3800000000000079

Так, я помітив, що там є проблема з високою точністю, але я не встиг її перевірити (я не знаю, чи є проблема з Firefox, Windows 7 або FPU мого процесора). Однак для питання Ярина, яке включає лише цілі числа, код гаммакса працює відмінно.

Ви можете використовувати функцію parseInt для отримання усіченого результату.

ParseInt(a/b)

Щоб отримати залишок, використовуйте оператор mod:

parseInt мають деякі підводні камені з рядками, щоб уникнути використання параметра radix з базою 10

ParseInt("09", 10)

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

ParseInt(100000000000000000000000000000000, 10) // 1e+32

Цей виклик дасть результат 1.

Обчислення кількості сторінок може бути виконано за один крок: Math.ceil (x/y)

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

Export function divideBy2(num) ( return ; ) export function divideBy4(num) ( return ; ) export function divideBy8(num) ( return ; )

(Перше – це приватне, друге – інше)

Це завжди буде усікати до нуля. Не впевнений, що вже надто пізно, але тут говориться:

Function intdiv(dividend, divisor) ( divisor = divisor - divisor % 1; if (divisor == 0) throw new Error("division by zero"); dividend = dividend - dividend % 1; var rem = dividend % divisor; return ( remainder: rem, quotient: (dividend - rem) / divisor );

Я не експерт у побітових операторах, але ще один спосіб отримати ціле число:

Var num = ~~(a/b);

Це буде нормально працювати і для негативних чисел, а Math.floor() буде обертатися в неправильному напрямку.

Це також здається правильним:

Var num = (a/b) >> 0;

Math.floor(operation) повертає округлене значення операції.

Приклад 1-го питання:

Var x = 5; var y = 10.4; var z = Math.floor(x + y); console.log(z);

Префікс:

Приклад 2-го питання:

Var x = 14; var y = 5; var z = Math.floor (x% y); console.log(x);

Префікс:

Для деякого числа y та деякого дивізора x обчислити фактор (quotient) та залишок (remainder) як:

Var quotient = Math.floor(y/x); var remainder = y%x;

Навіщо потрібне округлення?

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

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

Округлення десяткових чисел

1. Якщо аргумент не визначений для toFixed(), то за умовчанням він дорівнюватиме нулю, що означає 0 знаків після коми, аргумент має максимальне значення, що дорівнює 20.
2. Якщо аргумент не заданий дляперегляду, число залишається незайманим

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 у функції.

Сортування JSON-подібної структури

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.

Математичні константи

Math.abs, parseInt, parseFloat

Math.abs()

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

Math.abs(0); > -0

parseInt()

Синтаксис: 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()

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

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

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

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

Функція 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