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

Как округлять числа в Google Таблицах (используя функцию ОКРУГЛЕНИЯ)

Синтаксис функции ROUND (ОКРУГЛ) следующий:

ROUND(value, )

Здесь,

• value — это число, которое нужно округлить. Это может быть числовое значение или ссылка на ячейку, содержащую числовое значение.
• Places — это количество цифр или десятичных знаков, до которых вы хотите округлить значение. Этот параметр не является обязательным. Если он не указан, по умолчанию предполагается, что его значение равно 0.

Давайте рассмотрим несколько примеров и попытаемся округлить заданные значения столбца A до количества мест, указанного в столбце B, с помощью функции ROUND:

На изображении выше вы увидите, что:

• В строке 2 мы хотим округлить значение 213,146 до 1 десятичного знака. Согласно стандартным правилам округления цифра округления 1 остается прежней. Итак, округленное число теперь становится 213,1 . Мы фактически «округлили» значение 213,145 в меньшую сторону .
• В строке 3 мы хотим округлить значение 213,146 до 2 знаков после запятой. Согласно стандартным правилам округления цифра округления 4 увеличивается на 1. Округленное число теперь становится 213,15 . По сути, мы округлили значение 213,145 .
• В строке 5 в формуле отсутствует параметр мест, поэтому будет использоваться значение по умолчанию 0. Это означает, что мы хотим округлить значение 213,146 до 0 десятичных знаков, другими словами, до ближайшего целого числа. Согласно стандартным правилам округления, ближайшее целое число к 213,146 равно 213 . И снова мы округлили значение 213,146 в меньшую сторону .
• В строке 10 снова отсутствует параметр мест. Итак, нам снова нужно округлить значение до ближайшего целого числа. Ближайшее целое число к 213,642 — 214 . Здесь мы, по сути, «округлили» значение 213,642 .

Функцию ОКРУГЛ также можно использовать с отрицательными значениями параметра places. В таких случаях значение округляется слева от десятичной точки. Так,

• если разряды равно -1, функция ОКРУГЛ округляет значение до ближайших десятков.
• если количество мест равно -2, функция ОКРУГЛ округляет значение до ближайших сотен.
• если разряды равно -3, функция ОКРУГЛ округляет значение до ближайших тысяч.

и так далее.

Давайте рассмотрим еще несколько примеров, чтобы понять, как функция ROUND работает с отрицательными значениями параметра place:

На изображении выше вы увидите, что:

• В строке 2 мы округляем значение 213,146 до -1 разряда . Функция удаляет все цифры справа от десятичной точки. Затем он округляет значение слева от десятичной точки до ближайших десятков. Ближайшая к числу 13 десятка — 10 . Итак, функция округляет значение до 210 .
• В строке 3 округляем значение 213,146 до -2 разряда . Функция округляет целую часть значения до ближайших сотен. Ближайшая сотня к числу 213 — 200 . Итак, функция округляет значение до 200 .
• В строке 6 округляем значение 266,142 до -1 разряда . Функция округляет целую часть значения до ближайших десятков. Ближайшая к числу 66 десятка равна 70. Итак, функция округляет значение до 270 .
• В строке 9 округляем значение 656,142 до -3 разряда . Функция округляет целую часть значения до ближайших тысяч. Ближайшие тысячи к числу 656 — 1000 . Итак, функция округляет значение до 1000 .

Из приведенных выше примеров ясно, что функция ROUND либо округляет заданное значение в большую, либо в меньшую сторону, в зависимости от стандартных правил округления. Но что, если вы хотите, чтобы ваша ценность округлялась только в большую сторону, а не в меньшую?

В таких случаях вы можете использовать функцию ROUNDUP Google Таблицах.

Функция isFinite

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

В качестве ответа данная функция возвращает , если аргумент является , , или будет быть приведён к одному из этих специальных числовых значений. В противном случае данная функция вернёт значение .

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

Неточные вычисления

Внутри JavaScript число представлено в виде 64-битного формата IEEE-754. Для хранения числа используется 64 бита: 52 из них используется для хранения цифр, 11 из них для хранения положения десятичной точки (если число целое, то хранится 0), и один бит отведён на хранение знака.

Если число слишком большое, оно переполнит 64-битное хранилище, JavaScript вернёт бесконечность:

Наиболее часто встречающаяся ошибка при работе с числами в JavaScript – это потеря точности.

Посмотрите на это (неверное!) сравнение:

Да-да, сумма 0.1 и 0.2 не равна 0.3 .

Странно! Что тогда, если не 0.3 ?

Но почему это происходит?

Число хранится в памяти в бинарной форме, как последовательность бит – единиц и нулей. Но дроби, такие как 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 решает эту проблему путём округления до ближайшего возможного числа. Правила округления обычно не позволяют нам увидеть эту «крошечную потерю точности», но она существует.

От автора: довольно часто в JavaScript во время вычислений можно получить число не совсем в нужном нам диапазоне или числа, которые необходимо «почистить» перед дальнейшим использованием. Данные числа округляются в большую или меньшую степень, задаются в определенном диапазоне или «обрезаются» до нужного количества знаком после запятой – все зависит от того, что нужно вам.

Зачем округлять числа?

Один из интересных фактов о JS заключается в том, что данный язык на самом деле не хранит целые числа: числа представлены в двоичном виде с плавающей запятой. Это, в сочетании с тем фактом, что не все дроби можно представить в виде десятичного числа с конечным количеством цифр после запятой, означает, что в JS можно получить следующий результат (с помощью консоли):

В большинстве случаев с практической точки зрения эта погрешность не будет иметь значения (ошибка одна на 2 квинтиллиона), но все же это немного разочаровывает. Немного странный результат также можно получить при работе с валютами, процентными значениями или единицами измерения размера файла. Чтобы избежать этой неточности, необходимо округлить число или ввести определенное количество знаков после запятой.

JavaScript. Быстрый старт

Изучите основы JavaScript на практическом примере по созданию веб-приложения

Округление имеет много примеров практического применения: к примеру, если пользователь передвигает ползунок элемента range, чтобы не работать с десятичными числами, нам было бы удобнее округлять полученное значение до ближайшего целого.

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

Для урезания десятичных чисел можно использовать методы toFixed() и toPrecision. Оба метода принимают всего один аргумент, который соответственно задает количество «значащих цифр» (т.е. общее количество цифр в числе) или количество знаков после запятой:

Если в toFixed() не задан аргумент, то по умолчанию выставляется 0, т.е. без знаков после запятой, максимальное значение 20.

Если в toPrecision не задан аргумент, число не меняется.

Сравнение чисел

Для сравнения чисел в 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 | 1
0.6 × 2 = 1.2 | 1
0.2 × 2 = 0.4 | 0
0.4 × 2 = 0.8 | 0
0.8 × 2 = 1.6 | 1
0.6 × 2 = 1.2 | 1
0.2 × 2 = 0.4 | 0
0.4 × 2 = 0.8 | 0
0.8 × 2 = 1.6 | 1
0.6 × 2 = 1.2 | 1
…
0.2 10 = 0.001100110011… 2

В результате эти погрешности скажутся при вычисления суммы двух чисел и результатах сравнения. Т.е. получится что на самом деле 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

Здравствуйте, любители JavaScript-а. Вы уже заметили, что этот язык очень неординарен и в каждом разделе выделяется своими особенностями и необычными техническими решениями. Поэтому сегодняшняя публикация посвящается теме: «JavaScript округление».

После прочтения текущей статьи вы узнаете, для чего необходимо округлять числа, какие методы и свойства в js выполняют эту функцию, а также чем выделяется деление на 0. Не изменяя своим принципам, я прикреплю примеры к ключевым моментам материала и подробно распишу каждое действие. А теперь давайте приступать к обучению!

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

Иногда нужно получить значение х, которое должно находиться в пределах определенного диапазона. Например, нужно значение от 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:

Number.prototype.clamp = function(min, max) {
  return Math.min(Math.max(this, min), max);
};

Использование:

(numInput).clamp(lowBound, highBound);

Часто используемый метод прямого округления

parseInt(string)

Прямое округление означает отбрасывание десятичной части. Функция анализирует строковый параметр и возвращает целое число с указанным основанием (основание математической системы). Эта оценка является наиболее часто используемым методом прямого округления.

Параметр radix — это целое число от 2 до 36 (основа математической системы), которое представляет основу указанной выше строки. Например, параметр «10» означает использование десятичной системы счисления, которую мы обычно используем. Всегда указывайте этот параметр, чтобы избежать путаницы при чтении кода и обеспечить предсказуемые результаты преобразования. Если база не указана, разные реализации будут давать разные результаты, а значение по умолчанию обычно равно 10.

Math.trunc(value)

Удалите десятичную часть числа и оставьте только целую часть. Не как Остальные три метода:、、 ， Логика выполнения очень проста, простоУдалитьДесятичная часть и десятичная точка числа отбрасываются, независимо от того, положительный или отрицательный параметр.

Параметры, переданные в этот метод, будут неявно преобразованы в числовые типы.

Округлите значение до ближайшего целого числа. Если дробная часть аргумента больше 0,5, она будет округлена до следующего большего абсолютного значения. Если дробная часть аргумента меньше 0,5, она округляется до следующего целого числа с меньшим абсолютным значением

Если дробная часть параметра точно равна 0,5, она округляется до следующего целого числа в направлении положительной бесконечности (+ ∞).Обратите внимание, что в отличие от функции round () во многих других языках, Math.round () не всегда округляется в направлении от 0 (особенно если дробная часть отрицательного числа точно равна 0,5)

Math.ceil(value)

Округлите и верните наименьшее целое число, большее или равное данному числу.

Справка:

https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Mathhttps://juejin.im/post/5a98ea2f6fb9a028bb186f34https://juejin.im/entry/57317b2679df540060d5d6c2http://www.ruanyifeng.com/blog/2010/01/12_javascript_syntax_structures_you_should_not_use.htmlhttp://www.css88.com/archives/8488

Округление в меньшую сторону до ближайшего целого числа

Если вы хотите округлять в меньшую сторону, используйте метод 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.

Для чего округлять числа?

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»

Обратите внимание, что если в числе больше знаков, чем задано параметром точности, toPrecision
будет выдавать результат в научном формате:

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

Как избежать ошибок при округлении десятичных дробей

В некоторых случаях toFixed
и 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)

Способы записи числа

Представьте, что нам надо записать число 1 миллиард. Самый очевидный путь:

Но в реальной жизни мы обычно опускаем запись множества нулей, так как можно легко ошибиться. Укороченная запись может выглядеть как «1млрд» или «7.3млрд» для 7 миллиардов 300 миллионов. Такой принцип работает для всех больших чисел.

В JavaScript можно использовать букву «e» , чтобы укоротить запись числа. Она добавляется к числу и заменяет указанное количество нулей:

Другими словами, «e» производит операцию умножения числа на 1 с указанным количеством нулей.

Сейчас давайте запишем что-нибудь очень маленькое. К примеру, 1 микросекунду (одна миллионная секунды):

Записать микросекунду в укороченном виде нам поможет «e» .

Если мы подсчитаем количество нулей 0.000001 , их будет 6. Естественно, верная запись 1e-6 .

Другими словами, отрицательное число после «e» подразумевает деление на 1 с указанным количеством нулей:

Шестнадцатеричные, двоичные и восьмеричные числа

Шестнадцатеричные числа широко используются в JavaScript для представления цветов, кодировки символов и многого другого. Естественно, есть короткий стиль записи: 0x , после которого указывается число.

Не так часто используются двоичные и восьмеричные числа, но они также поддерживаются 0b для двоичных и 0o для восьмеричных:

Есть только 3 системы счисления с такой поддержкой. Для других систем счисления мы рекомендуем использовать функцию parseInt (рассмотрим позже в этой главе).

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

В 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″

Важные заметки о числах

Для начала запомните, что в js все виды чисел (дробные и целые) относятся к типу Number
. К тому же все они 64-битные, так как хранятся в формате «double precision», который также известен под стандартом IEEE-754.

Создаются численные переменные привычным способом:

Поддерживает и другие числовые представления. Так, еще можно создавать числа с плавающей точкой (их еще иногда называют «числа в научном формате»).

В появилась поддержка очень интересного метода toLocaleString ()
, который форматирует все числовые параметры по спецификациям, прописанным в ECMA 402. Благодаря этому большие числа, телефонные номера, валюты и даже проценты красиво выводятся в диалоговом окне.

Для работы с элементами типа Number был предусмотрен целый глобальный объект с кучей всевозможных математических функций, имя которого Math
.

Помимо этого, существуют и другие методы, которые выполняют округление числовых значений до целых чисел, до десятых, сотых и т.д. Рассмотрим их все подробнее.

Как явно преобразовать строку в число

Явно привести строку в число можно посредством следующих способов:

1. Использовать унарный оператор +, который необходимо поместить перед значением.

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

Этот способ пренебрегает пробелами в начале и конце строки, а также (переводом строки).

+' 7.35 ';    //7.35
+'7.35 \n ';  //7.35

Используя данный способ необходимо обратить внимание на то, что пустая строка или строка, состоящая из пробелов и , переводится в число 0. Кроме этого она также преобразует тип данных и логические значения к числу

+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).

Великий и могучий Math

Глобальный объект Math включает в себя огромное количество разнообразных математических и тригонометрических функций. Это очень нужный объект и часто выручает разработчиков при работе с цифровыми данными.

На других платформах существуют аналогии Math. Например, в таких популярных языках, как Java и C#, Math представляет собой класс, который поддерживает все те же стандартные функции. Так что как видите этот инструмент действительно великий и могучий.

Теперь я хочу пройтись по конкретным методам, отвечающим за округление, и подробно о них рассказать.

Math.floor ()

Начну с Math.
floor

Обратите внимание на наименование метода. Логически становится понятно, что раз речь идет об округлении, а дословный перевод слова «floor» означает «пол», то данный инструмент округлит обрабатываемые значения в меньшую строну

Также возможен вариант, когда обработанное число с помощью этой функции осталось прежним. Все потому, что округление осуществляется по нестрогому неравенству (

в ответе будет число 4.

Math.ceil ()

Опять-таки посмотрите на название (в такой способ материал быстрее усваивается). Если кто-то не знает, то «ceil» означает «потолок». Значит округление числовых данных будет осуществляться в большую сторону, используя нестрогое неравенство (>=).

Как вы уже догадались, в ответе будет число 5.

Math.round ()

Данный метод округляет дробное число до ближайшего целого. Так, если дробная часть находится в диапазоне от 0 и до 0.5 не включительно, то округление происходит к меньшему значению. А если дробная часть находится в диапазоне от включительно 0.5 и до следующего целого числа, то она округляется к большему целому.

Надеюсь, все подумали или сказали правильный ответ – 5.