Напоминаю, что это вводный курс по JavaScript для начинающих . Сегодня мы рассмотрим, какие операторы существуют в JavaScript . Пристегните ремни! Букаф будет много.
Когда у вас есть кучка данных, то с ними нужно что-то сделать. Делами-то как раз и заняты операторы. Они вечно что-то складывают, перемножают, делят, отнимают, сравнивают, присваивают и еще черти чем занимаются. Без операторов в программировании просто каши не сваришь.
В языке JavaScript используются следующие виды операторов:
- Арифметические операторы
- Операторы присваивания
- Операторы сравнения
- Логические операторы
- Строковые операторы
- Условные операторы
Это далеко не полный список, но для начала хватит и этого за глаза. Разберем каждый вид представленных операторов, зачем они нужны и с чем их едят. Поехали!
Арифметические операторы в JavaScriptС арифметическими операторами все вы знакомы еще со школы. Это обычные знаки сложения, вычитания, деления и умножения: + , - , / , * . Соответственно, выполняют они в программировании те же самые функции, что и в обычной математике. Сложностей с этим у вас не возникнет.
Данные, с которыми работают операторы, называются операндами .
2 + 3 // здесь числа 2 и 3 - операнды, а знак + - оператор сложения
Как и в математике у арифметических операторов есть свои приоритеты: умножение и деление имеют более высокий приоритет, чем сложение и вычитание.
2 + 3 * 4 // здесь сначала выполняется умножение, а уже потом сложение
И так же, как в математике, активно используются скобки, чтобы изменить приоритет:
(2 + 3) * 4 // здесь сначала выполняется сложение, а потом умножение
Кстати, знак = тоже оператор. Как мы уже выяснили в статье про , это оператор присваивания, а вовсе не знак равенства. Не забывайте об этом!
Оператор деления по модулюА теперь рассмотрим более интересные арифметические операторы. И первым станет значок процентов - % . В JavaScript это не проценты от слова совсем. Так в программировании обозначается деление по модулю. Результатом такой операции будет остаток от деления. Например:
100 % 22 // остаток будет равен 12
100 % 10 // остаток будет равен 0
При вычислениях этот оператор имеет тот же приоритет, что и умножение с делением, так что не забывайте ставить скобочки.
Совмещение операторовОператор = можно и нужно совмещать с другими операторами, чтобы сократить запись. Пример:
var n = 2; // присваиваем переменной n значение 2
n = n + 3; // присваиваем переменной n новое значение n + 2, получаем 5
То же самое можно записать так:
var n = 2;
n += 3; // равносильно записи n = n + 3
Среди арифметических операторов есть парочка весьма любопытных - инкремент и декремент . Обозначаются соответственно ++ и –– . Первый увеличивает переменную на единицу, а второй уменьшает. Эта фишка очень часто используется в программировании, так как предоставляет массу удобств. Чаще всего ее можно встретить в условных выражениях, но об этом позже.
У обоих операторов есть определенное местоположение в записи. Они могут быть как в префиксной форме (перед переменной) ++n , так и в постфиксной (после переменной) n++ . Разница огромна! Никогда не путайте эти формы и хорошенько запомните их. Если эти операторы стоят перед переменной, то в результате увеличивают ее значение на 1. Но! Если они стоят после переменной, то возвращают исходное значение. Пример:
var n = 2, m = 0;
m = ++n // увеличивает n на 1 (n = 3) и присваивает m тоже значение 3
var n = 2, m = 3;
m = n++ // увеличивает n на 1 (n = 3), но присваивает m предыдущее значение n = 2
С первым примером, уверен, вы легко разберетесь. А вот со вторым могут возникнуть проблемы. Чтобы легче было понять эту штуку и не запутаться, просто представьте, что вы сначала присвоили переменной m значение переменной n , а уже после этого увеличили значение n на единицу. В первом же примере вы сначала увеличили значение n на единицу, а потом уже присвоили это значение переменной m .
На этом с арифметическими операторами все. Разумеется, есть еще куча вариаций и тонкостей использования этих простых операторов, но для начала вам этого будет более чем достаточно.
Операторы сравненияИ снова вспоминаем математику. Знаки знакомы всем и каждому. В программировании они называются операторами сравнения . В JavaScript используются следующие операторы сравнения:
< меньше
> больше
= больше или равно
== равно
!= не равно
=== строго равно
!== строго не равно
Обратите внимание, что знак «больше или равно» пишется именно так >= , а не => . То есть, стрелка стоит перед знаком равно, а не после него.
Операторы сравнения позволяют сравнивать значения переменных и результатом этой операции всегда выступает булево значение true или false . Обычно их применяют в условных выражениях. От того, что дает результат сравнение зависит, какая часть кода будет выполняться дальше.
В JavaScript можно сравнивать разные типы данных одновременно, например, число и строку:
12345 == "12345" // true
Просто в этом случае строка автоматически преобразуется в число. Строгое же равенство === или неравенство!== используются только при сравнении переменных одинакового типа.
Логические операторыЛогические операции в JavaScript - это одна из довольно мудреных тем для начинающих. С ней стоит хорошенько разобраться, чтобы успешно идти дальше в освоении языка. Они чаще всего применяются вместе с операциями сравнения и выдают булево значение true или false .
Логических операторов три:
&& (И)
|| (ИЛИ)
! (НЕ)
Оператор && выполняет операцию «логическое И» над двумя значениями. При этом он возвращает true тогда и только тогда, когда оба операнда имеют значение true . Если же один или оба операнда имеют значение false , то оператор возвращает false . Примеры:
2 < 3 && 4 < 5 // true
2 < 3 && 5 < 4 // false
3 < 2 && 5 < 4 // false
У логических операторов приоритет меньше, чем у операторов сравнения, поэтому в приведенных примерах мы обходимся без скобок. Понятно, что сначала мы сравниваем числа между собой, а уже потом применяем логику.
Логический оператор || (ИЛИ)С логическим оператором || (ИЛИ) другая песня. Оператор || выполняет операцию «логическое ИЛИ» над двумя операндами. Если один или оба операнда имеют истинное значение, он возвращает истинное значение. Если оба операнда имеют ложные значения, он возвращает ложное значение. Примеры:
2 < 3 || 4 < 5 // true
2 < 3 || 5 < 4 // true
3 < 2 || 5 < 4 // false
У логических операторов есть одна хитрость. Они не любят лишней работы. Как, впрочем, и я. Свои вычисления они всегда начинают слева направо. И если первая часть выражения соответствует их условиям, то остальную часть выражения они даже не вычисляют.
К примеру, если оператор || находит истинное значение в самом начале, то сразу дает истинное значение, а остальное уже не проверяет. Также и оператор && , если находит в самом начале ложное выражение, то сразу дает ложный результат, а остальную часть не проверяет.
И еще одна фишка: приоритет у оператора И && больше, чем у ИЛИ || , поэтому он выполняется раньше:
2 < 3 || 4 < 5 && 5 < 6 // здесь сначала будет выполнено вычисление в правой части, а потом уже в левой
Логический оператор! (НЕ)Логический оператор! обозначает «логическое НЕ». Он используется только с одним операндом и меняет значение этого операнда на противоположное. Если значение n истинно, то значение!n будет ложным. Так как этот оператор можно прикрутить лишь к одному операнду, то чтобы инвертировать целое выражение, его надо взять в скобки!(n && m) .
Строковые операторыПро строковые операторы мы уже говорили ранее. Это тот самый плюс + что используется для соединения строковых переменных, или иначе - для конкатенации (сложения строк). Пример:
"Игорь " + "Квентор" == "Игорь Квентор"
Обратите внимание, что в первом слове добавлен пробел перед закрывающей кавычкой. Если его не добавить, то строки сольются в одно слово "ИгорьКвентор" .
У этого оператора есть одна особенность: если в выражении есть хоть одна строка, то он и все остальные аргументы приводит к строковому типу. Например:
Остальные арифметические операторы работают только с числами и всегда приводят аргументы к числу.
Условные операторыВ JavaScript есть два условных оператора if и?: Хотя, если быть точным, то if - это вообще-то управляющая инструкция и довольно обширная, с кучей плюшек и интересных особенностей. Поэтому о ней будет отдельная статья. Пока же рассмотрим более простой условный оператор?:
Обычно этот оператор записывается как?: Но в программах он выглядит иначе. Он имеет три операнда. Первый операнд предшествует символу? , второй стоит между символами? и: третий - после:
условие? значение 1: значение 2
Смысл его работы прост: если выполняется поставленное условие, то возвращается значение 1, если же нет - значение 2. Этот условный оператор часто служит более простой заменой инструкции if , когда в последней нет особой необходимости. При этом и сама запись сокращается и ее легче прочесть.
Пока на этом все!
Надеюсь, с операторам в JavaScript вы теперь немного разобрались. А чтобы мозг не закипел, вот вам короткий мульт для расслабления - Программист может все! :)
Математические операции являются одними из самых базовых и универсальных функций любого языка программирования. В 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:Отвечает за математические операции. В этой статье мы рассмотрим константы и методы этого класса, а также научимся их использовать в нелёгком процессе программирования.
Начнём с констант объекта Math . Рассмотрим константы E и PI (известные Вам из математики). Давайте сразу выведем их:
Document.write(Math.E);
document.write("
");
document.write(Math.PI);
Если Вы запустите этот скрипт, то увидите значения двух самых популярных констант математики.
Теперь займёмся методами объекта Math в JavaScript . Первый метод - это abs(x) , который принимает в качестве параметра число, и возвращает его модуль. Например, так:
Var x = -15.2;
document.write(Math.abs(x));
Результатом будет число "15.2 ".
Следующим методом будет random() . Очень популярный метод, который генерирует случайным образом число от 0 до 1 . Причём, 0 входит, а 1 уже не входит. Давайте с Вами получим число от 0 до 10 .
Document.write(Math.random() * 10);
Данная строка выведет число от 0 до 10 (причём дробное). Обратите внимание, что 0 быть может, а 10 быть не может.
Метод sqrt(x) считает квадратный корень из числа. Применение очевидное и очень простое:
Document.write(Math.sqrt(9));
В данном примере, после запуска скрипта мы увидим число "3 ".
Метод log(x) считает натуральный логарифм числа.
Document.write(Math.log(Math.E * Math.E));
Очевидно, что ответ будет "2 ".
Ещё один метод считает степень числа. Называется метод - pow(x, y) . Принимает два параметра, первый - это основание числа, а второй - это его степень. Сразу пример:
Document.write(Math.pow(2, 5));
Абсолютно логично, что будет 32 .
И, напоследок, рассмотрим группу методов, выполняющие тригономитреческие функции:
Var x = 0.1;
document.write(Math.sin(x) + "
"); //Синус числа
document.write(Math.cos(x) + "
"); //Косинус числа
document.write(Math.tan(x) + "
"); //Тангенс числа
document.write(Math.asin(x) + "
"); //Арксинус числа
document.write(Math.acos(x) + "
"); //Арккосинус числа
document.write(Math.atan(x) + "
"); //Арктангенс числа.
Чтобы результаты выполнения тригонометрических функций не сливались, после каждого выполнения происходит переход на новую строку (
).
Рассказав о приоритетах, ассоциативности и других второстепенных вопросах, мы можем начать обсуждение самих операторов. В этом разделе приведены описания арифметических операторов:
Сложение (+)
Оператор «плюс» складывает числовые операнды или выполняет конкатенацию строк. Если одним из операндов является строка, другой операнд преобразуется в строку и выполняется конкатенация. Операнды объекты преобразуются в числа или строки, которые могут быть сложены или конкатенированы. Преобразование выполняется с помощью методов 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) свой единственный числовой операнд, который может представлять собой переменную, элемент массива или свойство объекта. Если значение этой переменной, элемента или свойства не является числом, оператор сначала пытается преобразовать его в число. Как и для оператора ++, точное поведение оператора -зависит от его положения относительно операнда. Будучи поставленным перед операндом, он уменьшает операнд и возвращает уменьшенное значение. После операнда он уменьшает операнд, но возвращает первоначальное значение.
Последнее обновление: 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.