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

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

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

Это руководство расскажет об арифметических операторах, операторах присваивания и порядке операций с числовыми данными JavaScript.

Арифметические операторы

Арифметические операторы – это символы, которые определяют математические операции и возвращают результат. К примеру, в 3 + 7 = 10 символ + определяет синтаксис операции сложения.

Многие операторы JavaScript знакомы вам из базовой математики, но есть также и несколько дополнительных операторов.

Все арифметические операторы JavaScript представлены в следующей таблице.

Оператор	Синтаксис	Пример	Определение
Сложение	+	x + y	Сумма x и y
Вычитание	—	x — y	Разница между x и y
Умножение	*	x * y	Производное x и y
Деление	/	x / y	Частное x и y
Модуль	%	x % y	Остаток x / y
Возведение в степень	**	x ** y	x в степени y
Инкремент	++	x++	x плюс один
Декремент	—	x—	x минус один

Сложение и вычитание

Операторы сложения и вычитания доступны в JavaScript и могут использоваться для нахождения суммы и разности числовых значений. JavaScript имеет встроенный калькулятор, а математические операции могут выполняться непосредственно в консоли.

Знак плюса позволяет складывать числа, например:

Помимо операций с простыми числами JavaScript позволяет присваивать числа переменным и выполнять с ними вычисления. Для примера можно присвоить числовые значения переменным x и y, а результат поместить в z.

// Assign values to x and y
let x = 10;
let y = 20;
// Add x and y and assign the sum to z
let z = x + y;
console.log(z);
30

// Assign values to x and y
let x = 10;
let y = 20;
// Subtract x from y and assign the difference to z
let z = y - x;
console.log(z);
10

// Assign values to x and y
let x = -5.2;
let y = 2.5;
// Subtract y from x and assign the difference to z
let z = x - y;
console.log(z);
-7.7

В JavaScript есть одна интересная особенность, которую следует учитывать и знать, — это результат сложения числа и строки. Мы знаем, что 1 + 1 должно равняться 2, но это уравнение выдаст неожиданный результат.

let x = 1 + "1";
console.log(x);
typeof x;
11
"string"

Вместо сложения чисел JavaScript преобразует все выражение в строки и объединяет их. Важно быть осторожным с динамической типизацией JavaScript, поскольку она может иметь нежелательные результаты.

Сложение и вычитание в JavaScript часто используются для прокрутки панели навигации.

function scrollToId() {
const navHeight = 60;
window.scrollTo(0, window.pageYOffset - navHeight);
}
window.addEventListener("hashchange", scrollToId);

В этом случае панель будет прокручиваться на 60 пикселей от id.

Умножение и деление

Операторы умножения и деления JavaScript используются для поиска производного и частного числовых значений.

Звездочка является оператором умножения.

// Assign values to x and y
let x = 20;
let y = 5;
// Multiply x by y to get the product
let z = x * y;
console.log(z);
100

Умножение можно использовать для расчета цены товара после введения налога с продаж.

const price = 26.5; // Price of item before tax
const taxRate = 0.082; // 8.2% tax rate
// Calculate total after tax to two decimal places
let totalPrice = price + (price * taxRate);
totalPrice.toFixed(2);
console.log("Total:", totalPrice);
Total: 28.67

Слеш – оператор деления.

// Assign values to x and y
let x = 20;
let y = 5;
// Divide y into x to get the quotient
let z = x / y;
console.log(z);
4

Деление особенно полезно при расчете времени, например, при вычислении количества часов или процента правильных ответов в тесте.

Модуль числа

Модуль – еще один арифметический оператор, менее популярный, чем предыдущие. Представлен символом %. Он возвращает остаток при делении первого числа на второе.

К примеру, мы знаем, что 9 делится на 3 без остатка:

Модуль числа позволяет определить четное или нечетное число, например:

// Initialize function to test if a number is even
const isEven = x => {
// If the remainder after dividing by two is 0, return true
if (x % 2 === 0) {
return true;
}
// If the number is odd, return false
return false;
}
// Test the number
isEven(12);
true

В этом примере 12 делится на 2, следовательно, это четное число.

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

Возведение в степень

Возведение в степень – один из самых новых операторов JavaScript. Синтаксис возведения в степень – две звездочки подряд (**).

К примеру, 10 в пятой степени (10^5) записывается так:

10 ** 5;
100000

Операция 10 ** 5 имеет тот же результат, что 10 * 10, повторенная 5 раз.

10 * 10 * 10 * 10 * 10;

Также эту операцию можно записать с помощью метода Math.pow().

Math.pow(10, 5);
100000

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

Инкремент и декремент

Операторы инкремента и декремента увеличивают или уменьшают числовое значение переменной на единицу. Они представлены двумя плюсами (++) или двумя минусами (—) и часто используются в циклах.

Обратите внимание: операторы инкремента и декремента могут использоваться только с переменными. Попытка использовать их с простыми числами приведет к ошибке.

7++
Uncaught ReferenceError: Invalid left-hand side expression in postfix operation

Операторы инкремента и декремента можно классифицировать как префиксные и постфиксные операции, в зависимости от того, где по отношению к переменной размещен оператор.

Префиксный инкремент записывается как ++х.

// Set a variable
let x = 7;

let prefix = ++x;
console.log(prefix);
8

Значение х увеличилось на 1. Постфиксный инкремент пишется как у++.

// Set a variable
let y = 7;
// Use the prefix increment operation
let postfix = y++;
console.log(postfix);
7

Постфиксная операция не увеличила значение. Это значение не будет увеличиваться до тех пор, пока выражение не будет оценено. Для этого нужно запустить операцию дважды:

let y = 7;
y++;
y++;
console.log(y);
8

Чаще всего эти операторы встречаются в циклах. В данном цикле for оператор запускается 10 раз, начиная с 0.

// Run a loop ten times
for (let i = 0; i < 10; i++) {
console.log(i);
}
0
1
2
3
4
5
6
7
8
9

В этом примере итерация цикла выполняется с помощью оператора инкремента.

Проще говоря, х++ можно воспринимать как сокращение от х = х + 1, а х-как сокращение от х = х – 1.

Операторы присваивания

Одним из наиболее часто используемых операторов является оператор присваивания, который уже встречался в этом мануале. Он представлен знаком равенства (=). Символ = используется для присвоения значения справа переменной слева.

// Assign 27 to age variable
let age = 27;

Помимо стандартного оператора присваивания JavaScript имеет составные операторы присваивания, которые комбинируют арифметический оператор с оператором =.

К примеру, оператор добавления начнет с исходного значения и добавит к нему новое значение.

// Assign 27 to age variable
let age = 27;
age += 3;
console.log(age);
30

По сути, age += 3 – то же самое, что и age = age + 3.

Все арифметические операторы можно объединять с оператором присваивания. Ниже приведена справочная таблица операторов присваивания в JavaScript.

Составные операторы присваивания часто используются в циклах, как инкременты и декременты.

Приоритет операторов

Операторы выполняются в порядке приоритетности, как и в обычной математике.

К примеру, умножение имеет более высокий приоритет, чем сложение.

// First multiply 3 by 5, then add 10
10 + 3 * 5;
25

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

// First add 10 and 3, then multiply by 5
(10 + 3) * 5;
65

Ниже вы найдете таблицу приоритета арифметических операторов в JavaScript. Для инкремента и декремента постфикс имеет более высокий приоритет, чем префикс.

Инкремент/декремент, умножение/деление и сложение/вычитание имеют одинаковый уровень приоритета.

Приоритет имеют не только арифметические операторы, но и операторы присваивания, логические операторы, условные операторы и т. д. Полный список можно посмотреть .

Tags:

Выражения в JavaScript представляют собой комбинации операндов и операторов .

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

Рис. 1. Структура выражения в JavaScript

Операнды — это данные, обрабатываемые сценарием JavaScript. В качестве операндов могут быть как простые типы данных, так и сложные, а также другие выражения.

Операторы — это символы языка, выполняющие различные операции с данными. Операторы могут записываться с помощью символов пунктуации или ключевых слов.

В зависимости от количества операндов различают следующие типы операторов:
унарный — в операции участвует один операнд;
бинарный — в операции участвуют два операнда;
тернарный — комбинирует три операнда.

Простейшая форма выражения — литерал — нечто, вычисляемое само в себя, например, число 100 , строка "Hellow world" . Переменная тоже может быть выражением, так как она вычисляется в присвоенное ей значение.

Выражения и операторы в JavaScript 1. Арифметические операторы

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

Если один из операндов является строкой, интерпретатор JavaScript попытается преобразовать его в числовой тип, а после выполнить соответствующую операцию. Если преобразование типов окажется невозможным, будет получен результат NaN (не число).

Таблица 1. Арифметические операторы Оператор/Операция Описание Приоритет

+ Сложение	Складывает числовые операнды. Если один из операндов — строка, то результатом выражения будет строка.	12
- Вычитание	Выполняет вычитание второго операнда из первого.	12
- Унарный минус	Преобразует положительное число в отрицательное, и наоборот.	14
* Умножение	Умножает два операнда.	13
/ Деление	Делит первый операнд на второй. Результатом деления может являться как целое, так и число с плавающей точкой.	13
% Деление по модулю (остаток от деления)	Вычисляет остаток, получаемый при целочисленном делении первого операнда на второй. Применяется как к целым числам, так и числам с плавающей точкой.	13

var x = 5, y = 8, z; z = x + y; // вернет 13 z = x - y; // вернет -3 z = - y; // вернет -8 z = x * y; // вернет 40 z = x / y; // вернет 0.625 z = y % x; // вернет 3 2. Операторы присваивания

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

var a = 5; // присваиваем переменной a числовое значение 5 var b = "hellow"; // сохраняем в переменной b строку hellow var m = n = z = 10; // присваиваем переменным m, n, z числовое значение 10 x += 10; // равнозначно x = x + 10; x -= 10; // равнозначно x = x - 10; x *= 10; // равнозначно x = x * 10; x /= 10; // равнозначно x = x / 10; x %= 10; // равнозначно x = x % 10; 3. Операторы инкремента и декремента

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

var x = y = m = n = 5, z, s, k, l; z = ++x * 2; /* в результате вычислений вернет значение z = 12, x = 6, т.е. значение x сначала увеличивается на 1, а после выполняется операция умножения */ s = y++ * 2; /* в результате вычислений вернет значение s = 10, y = 6, т.е. сначала выполняется операция умножения, а после в переменной y сохраняется увеличенное на 1 значение */ k = --m * 2; // вернет значение k = 8, m = 4 l = n-- * 2; // вернет значение l = 10, n = 4 4. Операторы сравнения

Операторы сравнения используются для сопоставления операндов, результатом выражения может быть одно из двух значений — true или false . Операндами могут быть не только числа, но и строки, логические значения и объекты. Однако сравнение может выполняться только для чисел и строк, поэтому операнды, не являющиеся числами или строками, преобразуются.

Если оба операнда не могут быть успешно преобразованы в числа или строки, операторы всегда возвращают false .

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

Если один операнд является строкой/преобразуется в строку, а другой является числом/преобразуется в число, то оператор попытается преобразовать строку в число и выполнить сравнение чисел. Если строка не является числом, она преобразуется в значение NaN и результатом сравнения будет false .

Чаще всего операции сравнения используются при организации ветвлений в программах.

Таблица 4. Операторы сравнения Оператор/Операция Описание Приоритет

== Равенство	Проверяет две величины на совпадение, допуская преобразование типов. Возвращает true , если операнды совпадают, и false , если они различны.	9
!= Неравенство	Возвращает true , если операнды не равны	9
=== Идентичность	Проверяет два операнда на «идентичность», руководствуясь строгим определением совпадения. Возвращает true , если операнды равны без преобразования типов.	9
!== Неидентичность	Выполняет проверку идентичности. Возвращает true , если операнды не равны без преобразования типов.	9
> Больше	Возвращает true , если первый операнд больше второго, в противном случае возвращает false .	10
>= Больше или равно	Возвращает true , если первый операнд не меньше второго, в противном случае возвращает false .	10
	Возвращает true , если первый операнд меньше второго, в противном случае возвращает false .	10
	Возвращает true , если первый операнд не больше второго, в противном случае возвращает false .	10

5 == "5"; // вернет true 5 != -5.0; // вернет true 5 === "5"; // вернет false false === false; // вернет true 1 !== true; // вернет true 1 != true; // вернет false, так как true преобразуется в 1 3 > -3; // вернет true 3 >= "4"; // вернет false 5. Логические операторы

Логические операторы позволяют комбинировать условия, возвращающие логические величины. Чаще всего используются в условном выражении if .

(2 < 3) && (3===3); // вернет true, так как выражения в обеих скобках дают true (x < 10 && x > 0); // вернет true, если значение x принадлежит промежутку от 0 до 10 !false; // вернет true 6. Побитовые операторы

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

Таблица 6. Побитовые операторы Оператор/Операция Описание Приоритет

& Побитовый И	Если оба бита равны 1 , то результирующий бит будет равен 1 . В противном случае результат равен 0 .	8
| Побитовый ИЛИ	Если один из операндов содержит в позиции 1 , результат тоже будет содержать 1 в этой позиции, в противном случае результат в этой позиции будет равен 0 .	6
^ Исключающее ИЛИ	Если одно, и только одно значение содержит 1 в какой-либо позиции, то и результат будет содержать 1 в этой позиции, в противном случае результат в этой позиции будет равен 0 .	7
~ Отрицание	Выполняется операция побитового отрицания над двоичным представлением значения выражения. Любая позиция, содержащая 1 в исходном выражении, заменяется на 0 . Любая позиция, содержащая 0 в исходном выражении, становится равной 0 . Положительные числа начинаются с 0 , отрицательные - с -1 , поэтому ~ n == -(n+1) .	14
	Оператор сдвигает биты первого операнда влево на число битовых позиций, установленных вторым операндом. Для заполнения позиций справа используются нули. Возвращают результат того же типа, что левый операнд.	11
>> Побитовый сдвиг вправо	Оператор сдвигает биты первого операнда вправо на число битовых позиций, установленных вторым операндом. Цифры, сдвинутые за пределы диапазона, удаляются. Самый старший бит (32й) не меняется, чтобы сохранить знак результата. Если первый операнд положителен, старшие биты результата заполняются нулями; если первый операнд отрицателен, старшие биты результата заполняются единицами. Сдвиг значения вправо на одну позицию эквивалентен делению на 2 (с отбрасыванием остатка), а сдвиг вправо на две позиции эквивалентен делению на 4 и т. д.	11
>>> Побитовый сдвиг вправо без учета знака	Оператор сдвигает биты первого операнда вправо на число битовых позиций, установленных вторым операндом. Слева добавляются нули независимо от знака первого операнда. Цифры, сдвинутые за пределы диапазона, удаляются.	11

var x = 9, y = 5, z = 2, s = -5, result; // 9 эквивалентно 1001, 5 эквивалентно 0101 result = x & y; // вернет 1 (эквивалентно 0001) result = x | y; // вернет 13 (эквивалентно 1101) result = x ^ y; // вернет 12 (эквивалентно 1100) result = ~ y; // вернет -6 (эквивалентно 1100) result = x > z; // вернет 2 (эквивалентно 10) result = s >>> z; // вернет 1073741822 (эквивалентно 111111111111111111111111111110) 7. Строковые операторы

Существует несколько операторов, которые работают со строками особым образом.

"1" + "10"; // вернет "110" "1" + 10; // вернет "110" 2 + 5 + " цветных карандашей"; // вернет "7 цветных карандашей" "Цветных карандашей " + 2 + 5; // вернет "Цветных карандашей 25" "1" > "10"; // вернет false "10" 10 ? x * 2: x / 2; // возвращает значение x * 2, если x > 10, в противном случае x / 2 9. Комментарии в JavaScript

Однострочный комментарий: перед текстом комментария нужно поставить символы // .

Последнее обновление: 1.11.2015

Математические операции

JavaScript поддерживает все базовые математические операции:

Сложение :

Var x = 10; var y = x + 50;

Вычитание :

Var x = 100; var y = x - 50;

Умножение :

Var x = 4; var y = 5; var z = x * y;

Деление :

Var x = 40; var y = 5; var z = x / y;

Деление по модулю (оператор %) возвращает остаток от деления:

Var x = 40; var y = 7; var z = x % y; console.log(z); // 5

Результатом будет 5, так как наибольшее целое число, которое меньше или равно 40 и при этом делится на 7 равно 35, а 40 - 35 = 5.

Инкремент :

Var x = 5; x++; // x = 6

Оператор инкремента ++ увеличивает переменную на единицу. Существует префиксный инкремент, который сначала увеличивает переменную на единицу, а затем возвращает ее значение. И есть постфиксный инкремент, который сначала возвращает значение переменной, а затем увеличивает его на единицу:

// префиксный инкремент var x = 5; var z = ++x; console.log(x); // 6 console.log(z); // 6 // постфиксный инкремент var a = 5; var b = a++; console.log(a); // 6 console.log(b); // 5

Постфиксный инкремент аналогичен операции:

A = a + 1; // a++

Декремент уменьшает значение переменной на единицу. Также есть префиксный и постфиксный декремент:

// префиксный декремент var x = 5; var z = --x; console.log(x); // 4 console.log(z); // 4 // постфиксный декремент var a = 5; var b = a--; console.log(a); // 4 console.log(b); // 5

Как и принято в математике, все операции выполняются слева направо и различаются по приоритетам: сначала операции инкремента и декремента, затем выполняются умножение и деление, а потом сложение и вычитание. Чтобы изменить стандартный ход выполнения операций, часть выражений можно поместить в скобки:

Var x = 10; var y = 5 + (6 - 2) * --x; console.log(y); //41

Операции присваивания

Приравнивает переменной определенное значение: var x = 5;

Сложение с последующим присвоением результата. Например:

Var a = 23; a += 5; // аналогично a = a + 5 console.log(a); // 28

Вычитание с последующим присвоением результата. Например:

Var a = 28; a -= 10; // аналогично a = a - 10 console.log(a); // 18

Умножение с последующим присвоением результата:

Var x = 20; x *= 2; // аналогично x = x * 2 console.log(x); // 40

Деление с последующим присвоением результата:

Var x = 40; x /= 4; // аналогично x = x / 4 console.log(x); // 10

Получение остатка от деления с последующим присвоением результата:

Var x = 10; x %= 3; // аналогично x = x % 3 console.log(x); // 1, так как 10 - 3*3 = 1

Операторы сравнения

Как правило, для проверки условия используются операторы сравнения. Операторы сравнения сравнивают два значения и возвращают значение true или false:

Оператор равенства сравнивает два значения, и если они равны, возвращает true, иначе возвращает false: x == 5

Оператор тождественности также сравнивает два значения и их тип, и если они равны, возвращает true, иначе возвращает false: x === 5

Сравнивает два значения, и если они не равны, возвращает true, иначе возвращает false: x != 5

Сравнивает два значения и их типы, и если они не равны, возвращает true, иначе возвращает false: x !== 5

Сравнивает два значения, и если первое больше второго, то возвращает true, иначе возвращает false: x > 5

Сравнивает два значения, и если первое меньше второго, то возвращает true, иначе возвращает false: x < 5

Сравнивает два значения, и если первое больше или равно второму, то возвращает true, иначе возвращает false: x >= 5

Сравнивает два значения, и если первое меньше или равно второму, то возвращает true, иначе возвращает false: x 50 && percent < 12; console.log(result); //true

Возвращает true, если хотя бы одна операция сравнения возвращают true, иначе возвращает false:

Var income = 100; var isDeposit = true; var result = income > 50 || isDeposit == true; console.log(result); //true

Возвращает true, если операция сравнения возвращает false:

Var income = 100; var result1 = !(income > 50); console.log(result1); // false, так как income > 50 возвращает true var isDeposit = false; var result2 = !isDeposit; console.log(result2); // true

Операции со строками

Строки могут использовать оператор + для объединения. Например:

Var name = "Том"; var surname = "Сойер" var fullname = name + " " + surname; console.log(fullname); //Том Сойер

Если одно из выражений представляет строку, а другое - число, то число преобразуется к строке и выполняется операция объединения строк:

Var name = "Том"; var fullname = name + 256; console.log(fullname); //Том256

В конце напишем небольшую программу, которая продемонстрирует работу с операциями над переменными. Для этого определим следующую веб-страницу index.html:

JavaScript var sum = 500; // сумма вклада var percent = 10; // процент по вкладу var income = sum * percent / 100; // доход по вкладу sum = sum + income; // определяем новую сумму console.log("Доход по вкладу: " + income); console.log("Сумма вклада после первого года: " + sum);

В скрипте объявляются три переменных: sum, percent и income. Переменная income вычисляется по остальным двум переменным с помощью операций умножения и деления. И в конце ее значение суммируется с значением переменной sum.

Вы знакомы с арифметикой? Умеете складывать и вычитать числа? JavaScript тоже умеет складывать и вычитать. В JavaScript есть такие операторы: сложения +, вычитание -, деление /, умножение *, деление с возвратом остатка %.

Var one = 121;
var two = 13;
alert(one + two);
alert(one - two);
alert(one * two);
alert(one / two);
alert(one % two);

Усложним пример 1

Var answer = ((121 - 12) * 103) + 200;
alert(answer);

Усложним пример 2

Var PI = 3.14;

alert(answer);

И третий пример усложним

Var PI = 3.14;
var answer = ((121 - 12) * 103) + PI;
var answerEnd = (2 * answer * PI) + (-100);
alert(answerEnd);

И даже так можно сделать

Var answer = 101 + (-(-100));
alert(answer);

Но это ерунда, по сравнению с тем, что еще умеет JavaScript. Для этого есть стандартный объект Math с множеством свойств (свойства и есть операции, в данном контексте).

Math.pow(2, 53) /* -> 2 в степени 53 */
Math.round(0.6) /* -> 1.0 - округление до ближайшего целого */
Math.ceil(0.6) /* -> 1.0 - округление вверх */
Math.floor(0.6) /* -> 0.0 - округление вниз */
Math.abs(-5) /* -> 5 - модуль, абсолютное значение */
Math.max(x, y, z) /* -> Возвращает наибольший аргумент */
Math.min(x, y, z) /* -> Возвращает наименьший аргумент */
Math.random(); /* -> Где число на выходи больше 0, но меньше 1 */
Math.PI /* -> Число Пи */
Math.E /* -> Основание натурального логарифма */
Math.sqrt(3) /* -> Корень квадратный из 3 */
Math.pow(3, 1/3) /* -> Корень кубический из 3 */
Math.sin(0) /* -> Тригонометрия: имеются так же Math.cos, Math.atan и другие */
Math.log(10) /* -> Натуральный логарифм 10 */
Math.log(100) / Math.LN10 /* -> Логарифм 100 по основанию 10 */
Math.log(512) / Math.LN2 /* -> Логарифм 512 по основанию 2 */
Math.exp(3) /* -> Math.E в кубе */

Как использовать объект Math?

/* Первый пример */
var twoInPow = Math.pow(2, 53);
alert(twoInPow);
/* Второй пример */
var valueRaund = 0.1312;
var answerRaunt = Math.round(valueRaund);
alert(answerRaunt);
/* Третий пример */
var valueRaund = 0.1312;
alert(Math.round(valueRaund));
/* Четвертый пример: поиск наибольшего из трех чисел */
var a = 12, b = 11, c = 10;
alert(Math.max(a, b, c));

В случае выхода из диапазона, потери значащих разрядов или деления на ноль, JavaScript не выдает ошибку. Если результат будет слишком большой и выйдет из диапазона, то будет возвращено специальное значение «бесконечность», выглядит оно так « Infinity ».

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

Глобальная переменная NaN означает «не число». Есть одна особенность у этой переменной, операция проверки на равенство (==) всегда возвращает отрицательный результат и даже если его сравнивать с самим собой.

/* Так писать нельзя */
if (x == NaN) { ... }

Чтобы определить, является ли значение переменной x значением NaN, нужно использовать конструкцию, которая ниже. Эта проверка будет иметь значение true только тогда, когда x будет равен NaN

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

Сложение (+)
Оператор «плюс» складывает числовые операнды или выполняет конкатенацию строк. Если одним из операндов является строка, другой операнд преобразуется в строку и выполняется конкатенация. Операнды объекты преобразуются в числа или строки, которые могут быть сложены или конкатенированы. Преобразование выполняется с помощью методов valueOf() и/или toString().

Вычитание (−)
Когда «минус» используется в качестве бинарного оператора, он выполняет вычитание второго операнда из первого. Если указаны нечисловые операнды, то он пытается преобразовать их в числа.

Умножение (*)
Оператор * умножает два своих операнда. Нечисловые операнды он пытается преобразовать в числа.

Деление (/)
Оператор / делит первый операнд на второй. Пытается преобразовать нечисловые операнды в числа. Те, кто привык к языкам программирования, различающим целые и вещественные числа, могут ожидать получения целочисленного результата при делении одного целого на другое.

Однако в JavaScript все числа вещественные, поэтому все деления дают результат с плавающей точкой. Операция 5/2 дает 2.5, а не 2. Деление на ноль дает в качестве результата плюс или минут бесконечность, а 0/0 дает NaN.

Деление по модулю (%)
Оператор % вычисляет остаток, получаемый при целочисленном делении первого операнда на второй. Если заданы нечисловые операнды, то оператор пытается преобразовать их в числа. Знак результата совпадает со знаком первого операнда. Например, 5 % 2 дает 1.
Оператор деления по модулю обычно применятся с целыми операндами, но работает и для вещественных значений. Например, -4.3 % 2.1 дает результат -0.1.

Унарный минус (−)
Когда минус используется в качестве унарного оператора перед одиночным операндом, он выполняет унарную операцию смены знака. Другими словами, он преобразует положительное значение в отрицательное и наоборот. Если операнд не является числом, этот оператор пытается преобразовать его в число.

Унарный плюс (+)
Для симметрии с оператором «унарный минус» в JavaScript также имеется оператор унарный плюс. При помощи этого оператора можно явно задавать знак числовых литералов, если вы считаете, что это сделает текст программы более понятным:
var profit = +1000000;

В таком коде оператор «плюс» ничего не делает; результатом его работы является значение его аргумента.

Однако нечисловые аргументы он преобразует в числа. Если аргумент не может быть преобразован, возвращается NaN.

Инкремент (++)
Этот оператор инкрементирует (то есть увеличивает на единицу) свой единственный операнд, который должен быть переменной, элементом массива или свойством объекта. Если значение этой переменной, элемента массива или свойства не является числом, оператор сначала пытается преобразовать его в число. Точное поведение этого оператора зависит от его положения по отношению к операнду. Если поставить его перед операндом (префиксный оператор инкремента), то к операнду прибавляется 1, а результатом является увеличенное значение операнда. Если же он размещен после операнда (постфиксный оператор инкремента), то к операнду прибавляется 1, однако результатом является первоначальное значение операнда. Если увеличиваемое значение не является числом, оно в процессе вычисления преобразуется в число.

Например, следующий код устанавливает переменные i и j равными 2:
i = 1;
j = ++i;
А этот устанавливает i в 2, а j в 1:
i = 1;
j = i++;

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

Заметьте, что нельзя вставлять перевод строки между префиксным или постфиксным оператором инкремента и предшествующим ему операндом, поскольку точки с запятой в JavaScript вставляются автоматически. Если это сделать, JavaScript будет рассматривать операнд как полноценную инструкцию и вставит после него точку с запятой.

Декремент (−−)
Этот оператор декрементирует (то есть уменьшает на 1) свой единственный числовой операнд, который может представлять собой переменную, элемент массива или свойство объекта. Если значение этой переменной, элемента или свойства не является числом, оператор сначала пытается преобразовать его в число. Как и для оператора ++, точное поведение оператора -зависит от его положения относительно операнда. Будучи поставленным перед операндом, он уменьшает операнд и возвращает уменьшенное значение. После операнда он уменьшает операнд, но возвращает первоначальное значение.