Обычные арифметические операторы

Послание по JS № 2

Операторы

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

Несколько операторов мы знаем со школы – это обычные арифметические действия (+, -, *, /), но есть и ряд особенных операторов, с которыми мы тоже должны познакомиться.

Термины: «унарный оператор», «бинарный оператор» и «операнд»

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

Операнд – то, к чему применяется оператор. Например, 5 * 2 – оператор умножения с левым и правым операндами, то есть 5 или 2 в данном случае — это операнд.

Унарным оператором называется тот оператор, который применяется к одному операнду. Например, оператор унарный минус " - " меняет знак числа на противоположный:

var x = 1;

x = -x;

alert(x); // -1, применили унарный минус

Бинарным оператором называется оператор, который применяется к двум операндам. Тот же минус существует и в бинарной форме:

var x = 1, y = 3;

alert(y - x); // 2, бинарный минус

В данном пример минус относится и к левому и к правому операндам.

Приоритет

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

Из школы мы знаем, что умножение в выражении 2 + 2 * 2 выполнится раньше сложения, т.к. его приоритет выше, а скобки явно задают порядок выполнения. Но в JavaScript – гораздо больше операторов, поэтому существует целая таблица приоритетов. Она содержит как уже пройденные операторы, так и те, которые мы еще не проходили. В ней каждому оператору задан числовой приоритет. Тот, у кого число больше – выполнится раньше. Если приоритет одинаковый, то порядок выполнения – слева направо.

Отрывок из таблицы с основными операторами, которые нам сегодня понадобятся:

Приоритет	Тип оператора	Ассоциативность	Операторы
20	Группировка	не определено	(…)
17	Постфиксный инкремент	не определено	… ++
	Постфиксный декремент		… --
16	Унарный плюс	справа налево	+ …
	Унарный минус		- …
	Префиксный инкремент		++ …
	Префиксный декремент		-- …
	typeof		typeof …
14	Умножение	слева направо	… * …
	Деление		… / …
	Остаток		… % …
13	Сложение	слева направо	… + …
	Вычитание		… - …
3	Присваивание	справа налево	… = …
			… += …
			… -= …
			… **= …
			… *= …
			… %= …
1	Запятая / Последовательность	слева направо	…, …

Оператор запятая

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

leta = 1, b = 3, c = 40; // три операции в одной строке

Такие трюки используются JavaScript для укорачивания кода.

Обычные арифметические операторы

Обычные арифметические операторы (+,-,*,/), знакомы нам со школы и поэтому особого смысла их расписывать нет, единственный оператор, на который я хотел бы обратить внимание — это взятие остатка от деления (деление по модулю).

Взятие остатка %

Оператор взятия остатка % интересен тем, что, несмотря на обозначение, никакого отношения к процентам не имеет. Его результат a % b – это остаток от деления a на b.

Например:

alert(5 % 2); // 1, остаток от деления 5 на 2

alert(8 % 3); // 2, остаток от деления 8 на 3

alert(6 % 3); // 0, остаток от деления 6 на 3

Присваивание

Обратим внимание, в таблице приоритетов также есть оператор присваивания =.

У него – один из самых низких приоритетов: 3. Поэтому, когда переменную чему-либо присваивают, например, x = 2 + 2 * 2 сначала выполнится арифметика, а уже затем – произойдёт присваивание.

var x = 2 * 2 + 1;

alert(x); // 5

Оператор "=" возвращает значение

Метод Number()

Number () используется для преобразования переменных JavaScript в числа, например:

Number(true); // returns 1

Number(false); // returns 0

Number("10"); // returns 10

Number("10 20"); // returns NaN

Number("John"); // returns NaN

Если число не может быть преобразовано, возвращается значение NaN (не число).

Очень часто метод Number(), используется при работе с датами, например:

Number(new Date("2017-09-30")); // returns 1506729600000

Метод Number () возвращает число миллисекунд с момента 1.1.1970.

Метод parseInt()

parseInt() анализирует строку и возвращает целое число.

Пробелы разрешены. Возвращается только первое число, например:

parseInt("10"); // returns 10

parseInt("10.33"); // returns 10

parseInt("10 20 30"); // returns 10

parseInt("10 years"); // returns 10

parseInt("years 10"); // returns NaN

Если число не может быть преобразовано, возвращается значение NaN (не число).

Метод parseFloat()

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

parseFloat("10.33"); // returns 10.33

parseFloat("years 10.25"); // returnsNaN

Если число не может быть преобразовано, возвращается значение NaN (не число).

Числа

Так как мы уже кратко знакомились с числами, мы просто рассмотрим некоторые особенности при работе с ними

Деление на ноль, Infinity

Представьте, что вы собираетесь создать новый язык… Люди будут называть его «JavaScript» (или «LiveScript»… неважно).

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

Но создатель JavaScript решил пойти математически правильным путем. Ведь чем меньше делитель, тем больше результат. При делении на очень-очень маленькое число должно получиться очень большое. В математическом анализе это описывается через пределы, и если подразумевать предел, то в качестве результата деления на 0 мы получаем «бесконечность», которая обозначается символом ∞ (в JS - Infinity).

alert(1 / 0); // Infinity

alert(12345 / 0); // Infinity

Infinity – особенное значение, которое ведет себя в точности как математическая бесконечность ∞.

· Infinity больше любого числа.

· Добавление к бесконечности любого числа не меняет её.

alert(Infinity > 1234567890); // true

alert(Infinity + 5 == Infinity); // true

Бесконечность можно присвоить и в явном виде: var x = Infinity.

Бывает и минус бесконечность -Infinity:

alert(-1 / 0); // -Infinity

Бесконечность можно получить также, если сделать ну очень большое число, для которого количество разрядов в двоичном представлении не помещается в соответствующую часть стандартного 64-битного формата, например:

alert(1e500); // Infinity

NaN

Если математическая операция не может быть совершена, то возвращается специальное значение NaN (Not-A-Number).

Например, деление 0/0 в математическом смысле неправильно, поэтому его результат NaN:

alert(0 / 0); // NaN

Значение NaN используется для обозначения математической ошибки и обладает следующими свойствами:

· Значение NaN – единственное в своем роде, которое не равно ничему, включая себя.

· Значение NaN можно проверить специальной функцией isNaN(n), которая преобразует аргумент к числу и возвращает true, если получилось NaN, и false – для другого значения.

var n = 0 / 0;

alert(isNaN(n)); // true

alert(isNaN("12")); // false, строка преобразовалась к обычному числу 12

· Значение NaN «прилипчиво», т.е. любая операция с NaN возвращает NaN.

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

Запустите этот пример:

alert(0.1 + 0.2 == 0.3);

Запустили? Если нет – все же сделайте это.

Ок, вы запустили его. Он вывел false. Результат несколько странный, не так ли? Возможно, ошибка в браузере? Поменяйте браузер, запустите еще раз.

Хорошо, теперь мы можем быть уверены: 0.1 + 0.2 это не 0.3. Но тогда что же это?

alert(0.1 + 0.2); // 0.30000000000000004

Как видите, произошла вычислительная ошибка, результат 0.1 + 0.2 немного больше, чем 0.3.

alert(0.1 + 0.2 > 0.3); // true

Всё дело в том, что в стандарте IEEE 754 на число выделяется 8 байт (64 бита), не больше и не меньше.

Число 0.1 (одна десятая) записывается просто в десятичном формате. Но в двоичной системе счисления это бесконечная дробь, так как единица на десять в двоичной системе так просто не делится. Также бесконечной дробью является 0.2 (2/10).

Двоичное значение бесконечных дробей хранится только до определенного знака, поэтому возникает неточность. Её даже можно увидеть:

alert(0.1.toFixed(20)); // 0.10000000000000000555

Когда мы складываем 0.1 и 0.2, то две неточности складываются, получаем незначительную, но всё же ошибку в вычислениях. Конечно, это не означает, что точные вычисления для таких чисел невозможны. Они возможны. И даже необходимы. Например, есть два способа сложить 0.1 и 0.2:

1. Сделать их целыми, сложить, а потом поделить:

alert((0.1 * 10 + 0.2 * 10) / 10); // 0.3

Это работает, так как числа 0.1*10 = 1 и 0.2*10 = 2 могут быть точно представлены в двоичной системе.

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

var result = 0.1 + 0.2;

alert(+result.toFixed(10)); // 0.3

Забавный пример

Привет! Я – число, растущее само по себе!

alert(9999999999999999); // выведет 10000000000000000

Причина та же – потеря точности.

Из 64 бит, отведённых на число, сами цифры числа занимают до 52 бит, остальные 11 бит хранят позицию десятичной точки и один бит – знак. Так что если 52 бит не хватает на цифры, то при записи пропадут младшие разряды.

Интерпретатор не выдаст ошибку, но в результате получится «не совсем то число», что мы и видим в примере выше. Как говорится: «как смог, так записал».

Ради справедливости заметим, что ошибка в точности для чисел с плавающей точкой сохраняется в любом другом языке, где используется формат IEEE 754, включая Java, C, PHP, Ruby, Perl, Python.

IsFinite(n)

Итак, в JavaScript есть обычные числа и три специальных числовых значения: NaN, Infinity и -Infinity.

Обычно если мы хотим от посетителя получить какое-нибудь число, то значения в виде Infinity или NaN нам не подходят. Для того чтобы отличить «обычные» числа от таких специальных значений, существует функция isFinite(), она преобразует аргумент к числу и возвращает true, если это не NaN/Infinity/-Infinity:

alert(isFinite(1)); // true

alert(isFinite(Infinity)); // false

alert(isFinite(NaN)); // false

Оберткипростыхтипов

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

(1.23).toFixed(1); //"1.2"

"text".toUpperCase(); //"TEXT"

true.toString(); //"true"

При этом, конечно, значения примитивных типов объектами не являются.

Для организации доступа к «свойствам» значений примитивных типов JavaScript, при необходимости, создаёт объекты-обёртки, которые, после того, как они оказываются ненужными, уничтожаются. Процесс создания и уничтожения объектов-обёрток оптимизируется JS-движком.

Объектные обёртки есть у значений числового, строкового и логического типов. Объекты соответствующих типов представлены функциями-конструкторами Number, String, и Boolean.

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

Num. toFixed (precision)

Существует также специальный метод num.toFixed(precision), который округляет число num до точности precision и возвращает результат в виде строки:

var n = 12.34;

alert(n.toFixed(1)); // "12.3"

Округление идёт до ближайшего значения, аналогично Math.round:

var n = 12.36;

alert(n.toFixed(1)); // "12.4"

Итоговая строка, при необходимости, дополняется нулями до нужной точности:

var n = 12.34;

alert(n.toFixed(5)); // "12.34000", добавлены нули до 5 знаков после запятой

Если нам нужно именно число, то мы можем получить его, применив '+' к результату n.toFixed(..):

var n = 12.34;

alert(+n.toFixed(5)); // 12.34

Объект Math

Объект Math является встроенным объектом, хранящим в своих свойствах и методах различные математические константы и функции.

В отличие от других глобальных объектов, все свойства и методы объекта Math являются статическими. Вы ссылаетесь на константу π через Math.PI и вызываете функцию синуса через Math.sin(x), где x является аргументом метода.

Константы в JavaScript определены с полной точностью действительных чисел.

Свойства объекта Math

На самом деле свойств намного больше, тут я представил лишь наиболее востребованные:

· Math.E — число Эйлера или Непера, основание натуральных логарифмов, равное 2,718.

· Math.PI — отношение длины окружности круга к его диаметру, приблизительно равно 3,14159.

Методы объекта Math

Как и со свойствами объекта Math, методов намного больше, я представил наиболее востребованные:

Math.ceil(x) —возвращает наименьшее целое число, большее, либо равное указанному числу.

Math.floor(x) — возвращает наибольшее целое число, меньшее, либо равное указанному числу.

Math.max([x[, y[, …]]]) — возвращает наибольшее число из своих аргументов.

Math.min([x[, y[, …]]]) — возвращает наименьшее число из своих аргументов.

Math.pow(x, y) — основание в степени экспоненты, значение выражения основания экспонента.

Math.random() — возвращает псевдослучайное число в диапазоне от 0 до 1.

Math.round(x) — возвращает значение числа, округлённое до ближайшего целого.

Math.sqrt(x) — возвращает положительный квадратный корень числа.

Логическое преобразование

Преобразование к true/false происходит в логическом контексте, таком как if(…) или других подобных местах, и при применении логических операторов.

Все значения, которые интуитивно «пусты», становятся false. Их несколько: 0, пустая строка, null, undefined и NaN.

Остальное, в том числе и любые объекты – true.

Полная таблица преобразований:

Таблица логических преобразований
Значение	Преобразуется в
undefined, null	false
Числа	Все true, кроме 0, NaN -- false.
Строки	Все true, кроме пустой строки "" -- false
Объекты	Всегда true

Для преобразования используется двойное логическое отрицание!!value или вызов Boolean(value).

Обратите внимание: строка "0" становится true

Сравнение строк

Строки сравниваются побуквенно:

alert('Б'>'А'); // true

Осторожно, Unicode!

Аналогом «алфавита» во внутреннем представлении строк служит кодировка, у каждого символа – свой номер (код). JavaScript использует кодировку Unicode.

При этом сравниваются численные коды символов. В частности, код у символа Б больше, чем у А, поэтому и результат сравнения такой.

В кодировке Unicode обычно код у строчной буквы больше, чем у прописной.

Поэтому регистр имеет значение:

alert('а'>'Я'); // true, строчные буквы больше прописных

Для корректного сравнения символы должны быть в одинаковом регистре.

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

Например, если первая буква первой строки больше – значит первая строка больше, независимо от остальных символов:

alert('Банан'>'Анна');

Если одинаковы – сравнение идёт дальше. Здесь оно дойдёт до третьей буквы:

alert('Вася'>'Ваня'); // true, т.к. 'с'>'н'

При этом любая буква больше отсутствия буквы:

alert('Привет'>'Прив'); // true, так как 'е' больше чем "ничего".

Такое сравнение называется лексикографическим.

Важно!

Обычно мы получаем значения от посетителя в виде строк. Например, prompt возвращает строку, которую ввел посетитель. Числа, полученные таким образом, сравнивать нельзя, результат будет неверен.

alert("2">"14"); // true, неверно, ведь 2 не больше 14

В примере 2 оказалось больше 14, потому что строки сравниваются посимвольно, а символ '2' больше '1'. Правильно было бы преобразовать их к числу явным образом. Например, поставив перед ними +:

alert(+"2"> +"14"); // false, теперь правильно

Сравнение разных типов

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

alert('2'> 1); // true, сравнивается как 2 > 1

alert('01' == 1); // true, сравнивается как 1 == 1

alert(false == 0); // true, false становитсячислом 0

Строгое равенство

В обычном операторе == есть «проблема» – он не может отличить 0 от false:

alert(0 == false); // true

Та же ситуация с пустой строкой:

alert('' == false); // true

Это естественное следствие того, что операнды разных типов преобразовались к числу. Пустая строка, как и false, при преобразовании к числу дают 0.

Для проверки равенства без преобразования типов используются операторы строгого равенства === (тройное равно) и!==.

Если тип разный, то они всегда возвращают false:

alert(0 === false); // false, т.к. типыразличны

Строгое сравнение предпочтительно, если мы хотим быть уверены, что «сюрпризов» не будет.

Несравнимый undefined

Значение undefined вообще нельзя сравнивать:

alert(undefined > 0); // false

alert(undefined < 0); // false

alert(undefined == 0); // false

Сравнения дают false потому, что undefined при преобразовании к числу даёт NaN. А значение NaN по стандарту устроено так, что сравнения ==, <, >, <=, >= и даже === с ним возвращают false.

Вывод: любые сравнения с undefined/null, кроме точного ===, следует делать с осторожностью.

Желательно вообще не использовать сравнения (>=, >, <, <=) с ними, во избежание ошибок в коде.

Условные инструкции

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

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

Инструкция if (если)

Инструкция if – это базовая управляющая инструкция, позволяющая интерпретатору JavaScript принимать решения или, точнее, выполнять инструкции в зависимости от условий.

Инструкция имеет две формы:

1. if (вы­ра­же­ние) ин­ст­рук­ция; — В этой форме сначала вычисляется вы­ра­же­ние. Если результат является истинным, то ин­ст­рук­ция выполняется. Если вы­ра­же­ние возвращает ложное значение, то ин­ст­рук­ция не выполняется, и просто пропускается.

Например:

if (age>= 100) alert(“Вы долгожитель”);

// Ес­ли пе­ре­мен­ная age больше или рав­на 100 то мы выводим alert()

// Ес­ли пе­ре­мен­ная age равна другому значению, то alert() не выводится и просто пропускается

2. if (вы­ра­же­ние) ин­ст­рук­ция1; else ин­ст­рук­ция2; — Вторая форма инструкции if вводит конструкцию else, выполняемую в тех случаях, когда вы­ра­же­ние возвращает ложное значение.

Например:

if (age>= 18) alert(“Вы совершеннолетний человек”);

else alert(“Вам еще не исполнилось 18 лет”);

//Ес­ли пе­ре­мен­ная age меньше 18, то выводится второй alert()

При наличии вложенных инструкций if с блоками else требуется некоторая осторожность – необходимо гарантировать, что else относится к соответствующей ей инструкции if. Согласно правилам JavaScript (и большинства других языков программирования), конструкция else является частью ближайшей к ней инструкции if.

Важно!

· Скобки вокруг условного выражения являются обязательной частью синтаксиса инструкции if.

If (условное выражение приводящее значение к логическому типу) инструкция;

· Синтаксис языка JavaScript позволяет вставить только одну инструкцию после инструкции if и выражения в круглых скобках или else, однако одиночную инструкцию всегда можно заменить блоком инструкций. Поэтому инструкция if может выглядеть так:

if (address) {

message = "Спасибо! Скоро мы вышлем Вам посылку. ";

} else {

address = "";

message = "По­жа­луй­ста, ука­жи­те поч­то­вый ад­рес.";

}

Инструкция else if

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

Возможный способ сделать это состоит в применении инструкции else if. Формально она не является самостоятельной инструкцией JavaScript; это лишь распространенный стиль программирования, заключающийся в применении повторяющихся инструкций if/else:

if (n == 1) {// Вы­пол­нить блок кода 1}

else if (n == 2) {// Вы­пол­нить блок кода 2}

else if (n == 3) {// Вы­пол­нить блок кода 3}

else if (n == 4) {// Вы­пол­нить блок кода 4}

else {// Ес­ли ни од­на из пре­ды­ду­щих ин­ст­рук­ций else не бы­ла вы­пол­не­на, вы­пол­нить блок 5}

В этом примере нет ничего особенного. Это просто последовательность инструкций if, где каждая инструкция if является частью конструкции else предыдущей инструкции.

Стиль else if предпочтительнее и понятнее записи в синтаксически эквивалентной форме, полностью показывающей вложенность инструкций:

Условный оператор (?:)

Условный оператор – это единственный тернарный (с тремя операндами) оператор, и иногда он так и называется – «тернарный оператор».

Этот оператор обычно записывается как …?...: …;

Он имеет три операнда, первый перед символом?, второй между? и:, третий после:.

username? console.log("hello " + username): console.log("hello Anonymous");

Операнды условного оператора могут быть любого типа.

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

Вычисляется всегда только какой-то один операнд, второй или третий, и никогда оба.

Тот же результат можно получить с помощью инструкции if, но оператор?: часто оказывается удобным сокращением.

Вот пример, в котором проверяется, определена ли переменная, и если да, то берется ее значение, а если нет, берется значение по умолчанию:

greeting = "hello " + (username? username: "there");

Эта проверка эквивалентна следующей конструкции if, но более компактна:

greeting = "hello ";

if (username) greeting += username;

elsegreeting += "there";

Инструкция switch

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

Инструкция switch предназначена именно для таких ситуаций.

За ключевым словом switch следует выражение в скобках и блок кода в фигурных скобках:

switch(вы­ра­же­ние) { ин­ст­рук­ции }

Однако полный синтаксис инструкции switch более сложен, чем показано здесь.

Различные места в блоке помечены ключевым словом case, за которым следует выражение и символ двоеточия. Ключевое слово case напоминает инструкцию с меткой за исключением того, что оно связывает инструкцию с выражением, а не с именем.

Когда выполняется инструкция switch, она вычисляет значение вы­ра­жения, а затем ищет метку case, равную этому значению (соответствие определяется с помощью оператора идентичности ===).

Если метка найдена, выполняется блок кода, начиная с первой инструкции, следующей за меткой case. Если метка case с соответствующим значением не найдена, выполнение начинается с первой инструкции, следующей за специальной меткой default:. Если метка default: отсутствует, блок инструкции switch пропускается целиком.

Работу инструкции switch сложно объяснить на словах, гораздо понятнее выглядит объяснение на примере. Следующая инструкция switch эквивалентна повторяющимся инструкциям if/else, показанным в предыдущем разделе:

switch(n) {

case 1: // Вы­пол­ня­ет­ся, ес­ли n === 1 // Вы­пол­нить блок 1. break; // Здесь ос­та­но­вить­ся

case 2: // Вы­пол­ня­ет­ся, ес­ли n === 2 // Вы­пол­нить блок 2. break; // Здесь ос­та­но­вить­ся

case 3: // Вы­пол­ня­ет­ся, ес­ли n === 3 // Вы­пол­нить блок 3. break; // Здесь ос­та­но­вить­ся

default: // Ес­ли все ос­таль­ное не под­хо­дит... // Вы­пол­нить блок 4. break; // Здесь ос­та­но­вить­ся

}

Обратите внимание на ключевое слово break в конце каждого блока case.

Инструкция break, приводит к передаче управления в конец инструкции switch и продолжению выполнения инструкций, следующих далее.

Конструкции case в инструкции switch задают только начальную точку выполняемого программного кода, но не задают никаких конечных точек. В случае отсутствия инструкций break инструкция switch начнет выполнение блока кода с меткой case, соответствующей значению вы­ра­же­ния, и продолжит выполнение инструкций до тех пор, пока не дойдет до конца блока. В редких случаях это полезно для написания программного кода, который переходит от одной метки case к следующей, но в 99% случаев следует аккуратно завершать каждый блок case инструкцией break.

Инструкция switch сначала вычисляет выражение после ключевого слова switch, а затем выражения case в том порядке, в котором они указаны, пока не будет найдено совпадающее значение.

Послание по JS № 2

Операторы

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

Несколько операторов мы знаем со школы – это обычные арифметические действия (+, -, *, /), но есть и ряд особенных операторов, с которыми мы тоже должны познакомиться.

Термины: «унарный оператор», «бинарный оператор» и «операнд»

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

Операнд – то, к чему применяется оператор. Например, 5 * 2 – оператор умножения с левым и правым операндами, то есть 5 или 2 в данном случае — это операнд.

Унарным оператором называется тот оператор, который применяется к одному операнду. Например, оператор унарный минус " - " меняет знак числа на противоположный:

var x = 1;

x = -x;

alert(x); // -1, применили унарный минус

Бинарным оператором называется оператор, который применяется к двум операндам. Тот же минус существует и в бинарной форме:

var x = 1, y = 3;

alert(y - x); // 2, бинарный минус

В данном пример минус относится и к левому и к правому операндам.

Приоритет

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

Из школы мы знаем, что умножение в выражении 2 + 2 * 2 выполнится раньше сложения, т.к. его приоритет выше, а скобки явно задают порядок выполнения. Но в JavaScript – гораздо больше операторов, поэтому существует целая таблица приоритетов. Она содержит как уже пройденные операторы, так и те, которые мы еще не проходили. В ней каждому оператору задан числовой приоритет. Тот, у кого число больше – выполнится раньше. Если приоритет одинаковый, то порядок выполнения – слева направо.

Отрывок из таблицы с основными операторами, которые нам сегодня понадобятся:

Приоритет	Тип оператора	Ассоциативность	Операторы
20	Группировка	не определено	(…)
17	Постфиксный инкремент	не определено	… ++
	Постфиксный декремент		… --
16	Унарный плюс	справа налево	+ …
	Унарный минус		- …
	Префиксный инкремент		++ …
	Префиксный декремент		-- …
	typeof		typeof …
14	Умножение	слева направо	… * …
	Деление		… / …
	Остаток		… % …
13	Сложение	слева направо	… + …
	Вычитание		… - …
3	Присваивание	справа налево	… = …
			… += …
			… -= …
			… **= …
			… *= …
			… %= …
1	Запятая / Последовательность	слева направо	…, …

Оператор запятая

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

leta = 1, b = 3, c = 40; // три операции в одной строке

Такие трюки используются JavaScript для укорачивания кода.

Обычные арифметические операторы

Обычные арифметические операторы (+,-,*,/), знакомы нам со школы и поэтому особого смысла их расписывать нет, единственный оператор, на который я хотел бы обратить внимание — это взятие остатка от деления (деление по модулю).

Взятие остатка %

Оператор взятия остатка % интересен тем, что, несмотря на обозначение, никакого отношения к процентам не имеет. Его результат a % b – это остаток от деления a на b.

Например:

alert(5 % 2); // 1, остаток от деления 5 на 2

alert(8 % 3); // 2, остаток от деления 8 на 3

alert(6 % 3); // 0, остаток от деления 6 на 3

Присваивание

Обратим внимание, в таблице приоритетов также есть оператор присваивания =.

У него – один из самых низких приоритетов: 3. Поэтому, когда переменную чему-либо присваивают, например, x = 2 + 2 * 2 сначала выполнится арифметика, а уже затем – произойдёт присваивание.

var x = 2 * 2 + 1;

alert(x); // 5

Оператор "=" возвращает значение