Округление числа js в большую сторону. Объект Math в javascript - Методы round, ceil и floor - Округление дробных чисел. Отсечение дробной части
0.1 * 0.2;
> 0.020000000000000004
0.3 - 0.1
> 0.19999999999999998
Для практических целей эта неточность не имеет никакого значения, в нашем случае мы говорим об ошибке в квинтиллионных долях, однако, кого-то это может разочаровать. Мы можем получить несколько странный результат и при работе с числами, которые представляют собой значения валют, процентов или размеров файла. Для того, чтобы исправить эти неточности, нам как раз и необходимо уметь округлять результаты, при этом достаточно установить десятичную точность.
Округление чисел имеет практическое применение, мы можем манипулировать числом в некотором диапазоне, например, хотим округлить значение до ближайшего целого числа, а не работать только с десятичной частью.
Округление десятичных чисел Для того, чтобы отсечь десятичное число, используйте toFixed или метод toPrecision . Оба они принимают единственный аргумент, который определяет, соответственно, сколько значащих цифр (т.е. общее количество цифр, используемых в числе) или знаков после запятой (количество после десятичной точки) должен включать в себя результат:Оба метода toFixed() и toPrecision() возвращают строковое представление результата, а не число. Это означает, что при суммировании округленного значения с randNum будет произведена конкатенация строк, а не сумма чисел:
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"
Стоить обратите внимание, что toPrecision будет давать результат в экспоненциальной записи, если число целых чисел больше, чем сам сама точность:
Let num = 123.435 num.toPrecision(2); > "1.2e+2"
Как избежать ошибок округления с десятичными числами В некоторых случаях, toFixed и toPrecision округляет значение 5 в меньшую сторону, а в большую:Let numTest = 1.005;
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():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
Округление до большего/меньшего необходимого числа Если мы хотим, чтобы округлить до ближайшего числа, кратного 5, самый простой способ создать функцию, которая делит число на 5, округляет его, а затем умножает его на ту же сумму: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;
Фиксирование числа в диапазоне Есть много случаев, когда мы хотим получить значение х, лежащее в пределах диапазона. Например, нам может понадобиться значение от 1 до 100, но при этом мы получили значение 123. Для того, чтобы исправить это, мы можем использовать минимальное (возвращает наименьшее из набора чисел) и максимальное (возвращает наибольшее из любого множества чисел). В нашем примере, диапазон от 1 до 100: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;
Гауссово округление Гауссово округление, также известное как банковское округлением, заключается в том, что округление для этого случая происходит к ближайшему чётному. Этот метод округления работает без статистической погрешности. Лучшее решение было предложено Tim Down :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() c некоторыми аргументами. Как правило, для такого случая, лучше сразу создать функцию для многократного использования:
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 был представлен новый оператор возведения в степень - " * * ".
Возведение в степень Для того, чтобы возвести число в n-ую степень, используйте функцию Math.pow(), где первый аргумент это число, которое будет возведено в степень, второй аргумент это показатель степени: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() и Math.cbrt() противоположны функции Math.pow(). Как мы помним, квадратный корень из числа a - число, дающее a при возведении в квадрат.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.
Математические константы Работа с математикой в JavaScript облегчается за счет ряда встроенных констант. Эти константы являются свойствами объекта Math. Стоит обратить внимание, что константы пишутся в верхнем регистре, а не CamelCase нотации. Math.abs, parseInt, parseFloat Работа с числами в JavaScript может быть куда более сложной, чем кажется. Полученные значения не всегда попадают внутрь ожидаемых диапазонов, иногда результат может оказаться вовсе не тем, что мы ожидали. Math.abs() Метод Math.abs() возвращает абсолютное значение числа, что напоминает нам аналогичную математическую функцию модуля числа a .Let newVal = -57.64;
Math.abs(newVal);
> 57.64
Math.abs(0) всегда возвращает нуль, но если поставить знак минус перед функцией -Math.abs(NUM) мы всегда будем отрицательное значение.
Math.abs(0); > -0
parseInt() Мы знаем, что JavaScript понимает, что «15» это строка, а не число и, например, при разборе CSS-свойств средствами JavaScript, или получив какое-либо значение из неподготовленного массива, наши результаты могут получиться непредсказуемыми. Мы могли получить на вход строку представленную как «17px», и для нас это не является редкостью. Вопрос заключается в том, как преобразовать эту строку в фактическое значение и использовать его в дальнейших расчетах.Синтаксис: 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() являются чрезвычайно полезными функциями, важно учитывать, что и тут не обойтись без ошибок, поэтому необходимо проверять диапазон ожидаемых значений и в конечном счете анализировать результат, чтобы гарантировать, что полученные значения верны.
Отправить анонимно
Теперь рассмотрим метод 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 , которые округляют дробные числа.
Часто результатом расчётов бывает число с большим количеством знаков после запятой. Если это число будет использовано для дальнейших расчётов, то его можно оставить в таком виде. Но иногда требуется округление числа, например для вывода на страницу. В JavaScript округление чисел осуществляется несколькими методами.
Метод Math.round() округляет значение до целого числа.
Math.round (число)
Округление числа производится по математическим правилам. То есть, если после запятой идёт цифра от 0 до 4, то дробная часть просто отбрасывается. А если после запятой идёт цифра от 5 до 9, то дробрая часть отбрасывается, а к целой части прибавляется единица. пример:
JavaScript:
Есть ещё два метода, которые округляют число до целого значения. Метод Math.floor() округляет в меньшую сторону. Он отбрасывает дробную часть числа. А метод Math.ceil() округляет в большую сторону. Он отбрасывает дробную часть, а к целой части прибавляет единицу. Пример:
Конечно, 5 - (-2) это 5+2. Не завбывайте, что число 5 Вы в этой формуле не получите. Максимальное будет 4.999999999. Полученные значения можно округлить до нужной точности.
Если нужны только целые числа, то полученные значения можно округлять до целого в меньшую сторону. К максимуму нужно прибавить единицу, чтобы этот максимум тоже был возможен. Формула получается такая:
целое число = Math.floor (минимум + Math.random() * (максимум + 1 - минимум)
Выведем числа от 10 до 15:
20 |
for (i=1; 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 | 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 The Math.round() function returns the value of a number rounded to the nearest integer. The source for this interactive example is stored in a GitHub repository. If you"d like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request. Syntax Math.round(x) Parameters x A number. Return valueThe value of the given number rounded to the nearest integer. DescriptionIf the fractional portion of the argument is greater than 0.5, the argument is rounded to the integer with the next higher absolute value. If it is less than 0.5, the argument is rounded to the integer with the lower absolute value. If the fractional portion is exactly 0.5, the argument is rounded to the next integer in the direction of +∞. Note that this differs from many languages" round() functions, which often round this case to the next integer away from zero , instead giving a different result in the case of negative numbers with a fractional part of exactly 0.5. Because round() is a static method of Math , you always use it as Math.round() , rather than as a method of a Math object you created (Math has no constructor). Examples Math.round(20.49); // 20 Math.round(20.5); // 21 Math.round(42); // 42 Math.round(-20.5); // -20 Math.round(-20.51); // -21 Demonstrative ImplementationBelow is a snippet of code that is functionally equivelent to math.round except that the snippet of code below is slower than Math.round. The purpose of the snippet of code below is to demonstrate 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) } The modulus operator above gets the decimal part of x. Further, the above 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 Specifications
The compatibility table in this page is generated from structured data. If you"d like to contribute to the data, please check out https://github.com/mdn/browser-compat-data and send us a pull request. Update compatibility data on GitHub
|