- Math . floor ( ) , Math . round ( ) , Math . ceil ( ) и Math . trunc ( )
- Как пишется
- На практике
- Николай Лопин советует
- Округление числа в JS
- Math.ceil() — округление в большую сторону
- Math.floor() — округление в меньшую сторону
- Math.round() — округление до целого числа
- toFixed() JS — округление до заданного количества чисел после запятой
- Ваши вопросы и комментарии:
- Свежие записи
- Числа
- Способы записи числа
- Шестнадцатеричные, двоичные и восьмеричные числа
- toString(base)
- Округление
- Неточные вычисления
Math . floor ( ) , Math . round ( ) , Math . ceil ( ) и Math . trunc ( )
Объект Math содержит набор методов, который используется для округления чисел:
- round ( ) — округление по обычным правилам;
- floor ( ) — округление вниз;
- ceil ( ) — округление вверх;
- trunc ( ) — отбрасывание дробной части, не обращая внимания на знак аргумента.
Как пишется
Скопировать ссылку «Как пишется» Скопировано
Для обычного округления используйте Math . round ( ) :
console.log(Math.round(15.52))// 16 console.log(Math.round(15.3))// 15
console.log(Math.round(15.52)) // 16 console.log(Math.round(15.3)) // 15
Округление до ближайшего целого в большую сторону — Math . ceil ( ) :
console.log(Math.ceil(15.52))// 16 console.log(Math.ceil(15.3))// 16
console.log(Math.ceil(15.52)) // 16 console.log(Math.ceil(15.3)) // 16
Округление до ближайшего целого в меньшую сторону — Math . floor ( ) :
console.log(Math.floor(15.52))// 15 console.log(Math.floor(15.3))// 15
console.log(Math.floor(15.52)) // 15 console.log(Math.floor(15.3)) // 15
🛠 Используйте осторожно при работе с отрицательными числами:
console.log(Math.floor(-15.3))// -16
console.log(Math.floor(-15.3)) // -16
Так происходит потому что -16 меньше, чем -15, а округление происходит в меньшую сторону.
Отбрасывание дробной части — Math . trunc ( )
console.log(Math.trunc(15.52))// 15 console.log(Math.trunc(-15.3))// -15 console.log(Math.trunc(0.123))// 0 console.log(Math.trunc(-0.123))// -0
console.log(Math.trunc(15.52)) // 15 console.log(Math.trunc(-15.3)) // -15 console.log(Math.trunc(0.123)) // 0 console.log(Math.trunc(-0.123)) // -0
На практике
Скопировать ссылку «На практике» Скопировано
Николай Лопин советует
Скопировать ссылку «Николай Лопин советует» Скопировано
🛠 Разные виды округления нужны в разных ситуациях:
- когда нужно разбить данные на страницы и посчитать общее количество страниц, используйте округление вверх: const total Pages = Math . ceil ( total Items / items Per Page ) .
- когда нужно выбрать случайный элемент массива, используйте округление вниз: Math . floor ( Math . random ( ) * array . length ) .
Округление числа в JS
Округление чисел в JavaScript часто требуется при проведении математических операций: в калькуляторах, при просчете высоты/ширины блока и т.д.
В этом посте мы рассмотрим как округлить число в JS до целого и отбросить дробную часть, а также до 2 знаков после запятой.
Math.ceil() — округление в большую сторону
С помощью метода ceil() объекта Math мы можем округлить число в большую сторону. Останется только целая часть, без десятичной. Нам нужно передать только один параметр — число, которое мы хотим округлить:
console.log(Math.ceil(74.5)); // 75 console.log(Math.ceil(4.1)); // 5 console.log(Math.ceil(55.321)); // 56 console.log(Math.ceil(-55.321)); // -55 console.log(Math.ceil(-0.3)); // -0 console.log(Math.ceil(-7.3)); // -7
Обратите внимание на округление отрицательных чисел — -7.3 округляется до -7 , т.к. -7 больше чем -7.3 .
Math.floor() — округление в меньшую сторону
Для округления в меньшую сторону есть отдельный метод floor(). Он также округляет до целого числа. Рассмотрим на тех же примерах:
console.log(Math.floor(74.5)); // 74 console.log(Math.floor(4.1)); // 4 console.log(Math.floor(55.321)); // 55 console.log(Math.floor(-55.321)); // -56 console.log(Math.floor(-0.3)); // -1 console.log(Math.floor(-7.3)); // -8
Math.round() — округление до целого числа
Данный метод округляет число до ближайшего целого (отбрасывает дробную часть) по правилам математики. То есть, если десятичная часть числа >= .5 (больше или равно), тогда округление срабатывает в большую сторону. Если меньше — тогда в меньшую сторону
console.log(Math.round(64.5)); // 65 console.log(Math.round(64.4)); // 64 console.log(Math.round(14.21)); // 14 console.log(Math.round(34.49)); // 34 console.log(Math.round(34.51)); // 35 console.log(Math.round(-3.6)); // -4 console.log(Math.round(-3.4)); // -3
toFixed() JS — округление до заданного количества чисел после запятой
Этот метод уже работает отдельно от объекта Math и он позволяет нам указать сколько чисел нужно оставить после запятой (до десятых, сотых, тысячных и т.д.). По умолчанию, если не передать никакие параметры, округление будет до целого числа. Округление также будет происходить по математическим правилам.
Давайте рассмотрим примеры с округлением до 2 знаков после запятой, как наиболее часто используемый в финансовых расчетах:
const num1 = 64; const num2 = 64.4568; const num3 = 13.894; const num4 = -13.41568; console.log(num1.toFixed(2)); // 64.00 console.log(num2.toFixed(2)); // 64.46 console.log(num3.toFixed(2)); // 13.89 console.log(num4.toFixed(2)); // -13.42 const num5 = 55.5; const num6 = 55.4; console.log(num5.toFixed()); // 56 console.log(num6.toFixed()); // 55
Обратите внимание на такой момент. Если вы захотите присвоить значение после выполнения метода toFixed() другой переменной, это будет строка, а не число:
const num1 = 64.4568; const num2 = num1.toFixed(2); console.log(typeof num2, num2); // string "64.46"
Для того, чтобы получить число можно использовать такие варианты:
const num1 = 64.4568; const num2 = +num1.toFixed(2); console.log(typeof num2, num2); // number 64.46 const num3 = parseFloat(num1.toFixed(2)); console.log(typeof num3, num3); // number 64.46 const num4 = Number(num1.toFixed(2)); console.log(typeof num4, num4); // number 64.46
Ваши вопросы и комментарии:
Свежие записи
Копирование материалов разрешено только с ссылкой на источник Web-Dev.guru
2023 © Все права защищены.
Числа
В данной главе мы рассмотрим только первый тип чисел: числа типа number . Давайте глубже изучим, как с ними работать в JavaScript.
Способы записи числа
Представьте, что нам надо записать число 1 миллиард. Самый очевидный путь:
Но в реальной жизни мы обычно опускаем запись множества нулей, так как можно легко ошибиться. Укороченная запись может выглядеть как «1млрд» или «7.3млрд» для 7 миллиардов 300 миллионов. Такой принцип работает для всех больших чисел.
В JavaScript можно использовать букву «e» , чтобы укоротить запись числа. Она добавляется к числу и заменяет указанное количество нулей:
let billion = 1e9; // 1 миллиард, буквально: 1 и 9 нулей alert( 7.3e9 ); // 7.3 миллиардов (7,300,000,000)
Другими словами, «e» производит операцию умножения числа на 1 с указанным количеством нулей.
1e3 = 1 * 1000 1.23e6 = 1.23 * 1000000
Сейчас давайте запишем что-нибудь очень маленькое. К примеру, 1 микросекунду (одна миллионная секунды):
Записать микросекунду в укороченном виде нам поможет «e» .
let ms = 1e-6; // шесть нулей, слева от 1
Если мы подсчитаем количество нулей 0.000001 , их будет 6. Естественно, верная запись 1e-6 .
Другими словами, отрицательное число после «e» подразумевает деление на 1 с указанным количеством нулей:
// 1 делится на 1 с 3 нулями 1e-3 = 1 / 1000 (=0.001) // 1.23 делится на 1 с 6 нулями 1.23e-6 = 1.23 / 1000000 (=0.00000123)
Шестнадцатеричные, двоичные и восьмеричные числа
Шестнадцатеричные числа широко используются в JavaScript для представления цветов, кодировки символов и многого другого. Естественно, есть короткий стиль записи: 0x , после которого указывается число.
alert( 0xff ); // 255 alert( 0xFF ); // 255 (то же самое, регистр не имеет значения)
Не так часто используются двоичные и восьмеричные числа, но они также поддерживаются 0b для двоичных и 0o для восьмеричных:
let a = 0b11111111; // бинарная форма записи числа 255 let b = 0o377; // восьмеричная форма записи числа 255 alert( a == b ); // true, с двух сторон число 255
Есть только 3 системы счисления с такой поддержкой. Для других систем счисления мы рекомендуем использовать функцию parseInt (рассмотрим позже в этой главе).
toString(base)
Метод num.toString(base) возвращает строковое представление числа num в системе счисления base .
let num = 255; alert( num.toString(16) ); // ff alert( num.toString(2) ); // 11111111
base может варьироваться от 2 до 36 (по умолчанию 10 ).
- base=16 — для шестнадцатеричного представления цвета, кодировки символов и т.д., цифры могут быть 0..9 или A..F .
- base=2 — обычно используется для отладки побитовых операций, цифры 0 или 1 .
- base=36 — максимальное основание, цифры могут быть 0..9 или A..Z . То есть, используется весь латинский алфавит для представления числа. Забавно, но можно использовать 36 -разрядную систему счисления для получения короткого представления большого числового идентификатора. К примеру, для создания короткой ссылки. Для этого просто преобразуем его в 36 -разрядную систему счисления:
alert( 123456..toString(36) ); // 2n9c
Внимание! Две точки в 123456..toString(36) это не опечатка. Если нам надо вызвать метод непосредственно на числе, как toString в примере выше, то нам надо поставить две точки .. после числа.
Если мы поставим одну точку: 123456.toString(36) , тогда это будет ошибкой, поскольку синтаксис JavaScript предполагает, что после первой точки начинается десятичная часть. А если поставить две точки, то JavaScript понимает, что десятичная часть отсутствует, и начинается метод.
Также можно записать как (123456).toString(36) .
Округление
Одна из часто используемых операций при работе с числами – это округление.
В JavaScript есть несколько встроенных функций для работы с округлением:
Math.floor Округление в меньшую сторону: 3.1 становится 3 , а -1.1 — -2 . Math.ceil Округление в большую сторону: 3.1 становится 4 , а -1.1 — -1 . Math.round Округление до ближайшего целого: 3.1 становится 3 , 3.6 — 4 , а -1.1 — -1 . Math.trunc (не поддерживается в Internet Explorer) Производит удаление дробной части без округления: 3.1 становится 3 , а -1.1 — -1 .
Ниже представлена таблица с различиями между функциями округления:
Math.floor | Math.ceil | Math.round | Math.trunc | |
---|---|---|---|---|
3.1 | 3 | 4 | 3 | 3 |
3.6 | 3 | 4 | 4 | 3 |
-1.1 | -2 | -1 | -1 | -1 |
-1.6 | -2 | -1 | -2 | -1 |
Эти функции охватывают все возможные способы обработки десятичной части. Что если нам надо округлить число до n-ого количества цифр в дробной части?
Например, у нас есть 1.2345 и мы хотим округлить число до 2-х знаков после запятой, оставить только 1.23 .
- Умножить и разделить. Например, чтобы округлить число до второго знака после запятой, мы можем умножить число на 100 , вызвать функцию округления и разделить обратно.
let num = 1.23456; alert( Math.floor(num * 100) / 100 ); // 1.23456 -> 123.456 -> 123 -> 1.23
let num = 12.34; alert( num.toFixed(1) ); // "12.3"
Округляет значение до ближайшего числа, как в большую, так и в меньшую сторону, аналогично методу Math.round :
let num = 12.36; alert( num.toFixed(1) ); // "12.4"
Обратите внимание, что результатом toFixed является строка. Если десятичная часть короче, чем необходима, будут добавлены нули в конец строки:
let num = 12.34; alert( num.toFixed(5) ); // "12.34000", добавлены нули, чтобы получить 5 знаков после запятой
Неточные вычисления
Внутри JavaScript число представлено в виде 64-битного формата IEEE-754. Для хранения числа используется 64 бита: 52 из них используется для хранения цифр, 11 для хранения положения десятичной точки и один бит отведён на хранение знака.
Если число слишком большое, оно переполнит 64-битное хранилище, JavaScript вернёт бесконечность:
Наиболее часто встречающаяся ошибка при работе с числами в JavaScript – это потеря точности.
Посмотрите на это (неверное!) сравнение:
Да-да, сумма 0.1 и 0.2 не равна 0.3 .
Странно! Что тогда, если не 0.3 ?
alert( 0.1 + 0.2 ); // 0.30000000000000004
Ой! Здесь гораздо больше последствий, чем просто некорректное сравнение. Представьте, вы делаете интернет-магазин и посетители формируют заказ из 2-х позиций за $0.10 и $0.20 . Итоговый заказ будет $0.30000000000000004 . Это будет сюрпризом для всех.
Число хранится в памяти в бинарной форме, как последовательность бит – единиц и нулей. Но дроби, такие как 0.1 , 0.2 , которые выглядят довольно просто в десятичной системе счисления, на самом деле являются бесконечной дробью в двоичной форме.
Другими словами, что такое 0.1 ? Это единица делённая на десять — 1/10 , одна десятая. В десятичной системе счисления такие числа легко представимы, по сравнению с одной третьей: 1/3 , которая становится бесконечной дробью 0.33333(3) .
Деление на 10 гарантированно хорошо работает в десятичной системе, но деление на 3 – нет. По той же причине и в двоичной системе счисления, деление на 2 обязательно сработает, а 1/10 становится бесконечной дробью.
В JavaScript нет возможности для хранения точных значений 0.1 или 0.2, используя двоичную систему, точно также, как нет возможности хранить одну третью в десятичной системе счисления.
Числовой формат IEEE-754 решает эту проблему путём округления до ближайшего возможного числа. Правила округления обычно не позволяют нам увидеть эту «крошечную потерю точности», но она существует.
alert( 0.1.toFixed(20) ); // 0.10000000000000000555