Для чего нужны операторы в javascript

An Easy Guide to Operators in JavaScript

In the last article we looked at the types that JavaScript has to offer. But what we didn’t talk about is their operators, basically what make a value act on or be acted on to produce a result. These includes but not limited to +(plus), -(minus) etc., and you might be thinking can a string type have an operator, well that answer is a resounding yes.

Note: These are not standardize(official), it is just my own way of trying to structure it.

Categories of Operator

There are three categories of operators in JavaScript

• Unary Operator
• Binary Operator
• Ternary Operator

These are majorly due to their functionality on other, how they behave.

Note: NOT ALL OPERATORS ARE SYMBOLS

Unary Operators

These are operators that act on an operand(value) i.e they act on a single value. Example typeof , —(minus sign), !(exclamation mark) etc. The typeof keyword produces a string value naming the type of the value you provide it.

Binary Operators

These are operators that act on two operands(values). This is where most of all operators fall into. They are common, some of which you might know. Example +(plus), -(minus).

Ternary Operator

These are operators that operate on three operands(values). It is likely this is not the first time you have heard of this term. Try to guess it… Yep it is the question mark(?) and the colon(:). As for now it is the only operator that has such functionality, we will know how it operates later on in the article.

Types of Operators

I will be discussing the following operators below. These are not the only types of operators

• Arithmetic
• Logical
• Comparison
• Conditional

Arithmetic

These are operators that perform arithmetic operation. These includes Addition(+), Subtraction(-), Division(/), Multiplication(*). If you have done basic math these symbols and their meaning are known to you, but there are other arithmetic symbols that have functionalities that you don’t know about.

Strings can also use the + symbol. This is called concatenation.

For instance if you want to find a remainder of a division operation or if you want an integer(whole number) from a floating-point number(decimal number, JavaScript doesn’t have this type). Well wait no further, I introduce the Modulus(%) and Floor(//) operation.

The Floor operator which is a double forward slash(//), basically ignores any value after the decimal place, irrespective of whether the value is over .5 or less than than .5.

The Modulus operator which is a percent(%) sign, returns the remainder of the division operation. This can be useful when you want to know if a number is an even number or an odd number.

Logical Operators

These operator that operate on boolean values. They include and, or and, not. Well in JavaScript they are represented in symbols. So and(&&), or (||), not (!).

The && operator represents logical and. It is a binary operator(i.e operates on two values), and its result is true only if both the values given to it are true.

Comparison Operator

The > and < signs are the traditional symbols for “is greater than” and “is
less than”, respectively. They are binary operators. Applying them results in
a Boolean value that indicates whether they hold true in this case.
Strings can be compared in the same way.

Conditional Operator

This operator is a ternary(operating on three values). It is written with a question and a colon. So the way it works is if it is true the value before the colon(:) and after the question mark(​​​​​​​​​​​​​?) will be returned, if false the value after the colon will be returned.

It is like an easy way to write a conditional statement which doesn’t have any other conditions.

Automatic Type Conversion

JavaScript goes out of its way to accept almost any program you give it, event program that do odd things.

When an operator is applied to the “wrong” type of value, JavaScript will
silently convert that value to the type it needs, using a set of rules that often
aren’t what you want or expect. This is called type conversion. When something that doesn’t map to a number in an obvious way (such as
“five” or undefined) is converted to a number, you get the value NaN.

When using == to compare values of the same type, the outcome is easy to
predict. The result should give you true if both values are the same, except in the case of NaN. But when the types differ, JavaScript uses a complicated and confusing set of rules to determine what to do. In most cases, it just tries to convert one of the values to the other value’s type. However, when null or undefined occurs on either side of the operator, it produces true only if both sides are one of null or undefined.

Short-circuiting

The logical operators && and || handle values of different types in a peculiar
way. They will convert the value on their left side to Boolean type in order
to decide what to do, but depending on the operator and the result of that
conversion, they will return either the original left-hand value or the right-hand value.

The || operator will return the value to the left when true and return the right when false.

This doesn’t work for boolean values, but for other values. The rules for converting strings and numbers to Boolean values state that 0, null, undefined, empty string, NaN count as false, while others count as true.

The && operator will return the value to the right when true and return the left when false.

This is useful when you have a variable that is dynamically set, in case the value is an empty string, null, or undefined which all evaluates to a falsy; the value to the right will be the default value.

“A falsy (sometimes written falsey) value is a value that is considered false when encountered in a Boolean context.” — Mozilla Developer Network

When a value evaluates to true it is regarded as truthy, if otherwise it is regarded as falsy. It is colloquial term so, it is not a technical term. Values that evaluates to falsy are 0,0n(Bigint), null, NaN, false, undefined and empty string(“”).

There are types of operators that were not covered in this article, but you can find here. Also precedence in operators is also a thing, so make sure you know about them to prevent unintended bugs

Summary

We have learnt about the operators of JavaScript, based on how many operand they act on

• Unary Operator
• Binary Operator
• Ternary Operator

Based on types they act on

• Arithmetic
• Logical
• Comparison
• Conditional

Also we look at Short circuiting and Automatic Conversion. So be careful of Automatic Conversion it is an avenue to introduce bugs.

Выразительный JavaScript: Величины, типы и операторы

Под поверхностью машины движется программа. Без усилий, она расширяется и сжимается. Находясь в великой гармонии, электроны рассеиваются и собираются. Формы на мониторе – лишь рябь на воде. Суть остаётся скрытой внутри…

Мастер Юан-Ма, Книга программирования

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

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

К примеру, номер 13. Вместо десятичной системы, состоящей из 10 цифр, у вас есть двоичная система с двумя цифрами. Значение каждой позиции числа удваивается при движении справа налево. Биты, составляющие число 13, вместе с их весами:

Получается двоичное число 00001101, или 8 + 4 + 1, что равно 13.

Величины.

Представьте океан бит. Типичный современный компьютер хранит более 30 миллиардов бит в оперативной памяти. Постоянная память (жёсткий диск) обычно ещё на пару порядков объёмнее.

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

Для создания величины вам нужно указать её имя. Это удобно. Вам не надо собирать стройматериалы или платить за них. Нужно просто позвать – и оп-па, готово. Они не создаются из воздуха – каждая величина где-то хранится, и если вы хотите использовать огромное их количество, у вас могут закончиться биты. К счастью, это только если они все нужны вам одновременно. Когда величина вам станет не нужна, она растворяется, и использованные ею биты поступают в переработку как стройматериал для новых величин.

В этой главе мы знакомимся с атомами программ JavaScript – простые типы величин и операторы, которые к ним применимы.

Числа

Величины числовых типов, это – сюрприз – числа. В программе JavaScript они записываются как

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

JavaScript использует фиксированное число бит (64) для хранения численных величин. Число величин, которые можно выразить при помощи 64 бит, ограничено – то есть и сами числа тоже ограничены. Для N десятичных цифр количество чисел, которые ими можно записать, равно 10 в степени N. Аналогично, 64 битами можно выразить 2 в 64 степени чисел. Это довольно много.

Раньше у компьютеров памяти было меньше, и тогда для хранения чисел использовали группы из 8 или 16 бит. Было легко случайно превысить максимальное число для таких небольших чисел – то есть, использовать число, которое не помещалось в этот набор бит. Сегодня у компьютеров памяти много, можно использовать куски по 64 бит, и значит вам надо беспокоиться об этом только, если вы работаете с астрономическими числами.

Правда, не все числа меньше 2^64 помещаются в число JavaScript. В этих битах также хранятся отрицательные числа – поэтому, один бит хранит знак числа. Кроме того, нам нужно иметь возможность хранить дроби. Для этого часть бит используется для хранения позиции десятичной точки. Реальный максимум для чисел – примерно 10^15, что в общем всё равно довольно много.

Дроби записываются с помощью точки.

Очень большие или маленькие числа записываются научной записью с буквой “e” (exponent), за которой следует степень:

Это 2.998 × 10^8 = 299800000.

Вычисления с целыми числами (которые также называются integer), меньшими, чем 10^15, гарантировано будут точными. Вычисления с дробями обычно нет. Так же, как число π (пи) нельзя представить точно при помощи конечного числа цифр, так и многие дроби нельзя представить в случае, когда у нас есть только 64 бита. Плохо, но это мешает в очень специфических случаях. Важно помнить об этом и относиться к дробям как к приближённым значениям.

Арифметика

Главное, что можно делать с числами – это арифметические вычисления. Сложения и умножения используют два числа и выдают третье. Как это записывается в JavaScript:

Символы + и * называются операторами. Первый – сложение, второй – умножение. Помещаем оператор между двумя величинами и получаем значение выражения.

А в примере получается «сложить 4 и 100 и затем умножить результат на 11» или умножение выполняется сначала? Как вы могли догадаться, умножение выполняется первым. Но как и в математике, это можно изменить при помощи скобок:

Для вычитания используется оператор -, а для деления — /

Когда операторы используются без скобок, порядок их выполнения определяется их приоритетом. У операторов * и / приоритет одинаковый, выше, чем у + и -, которые между собой равны по приоритету. При вычислении операторов с равным приоритетом они вычисляются слева направо:

вычисляется как (1 — 2) + 1

Пока беспокоиться о приоритетах не надо. Если сомневаетесь – используйте скобки.

Есть ещё один оператор, который вы не сразу узнаете. Символ % используется для получения остатка. X % Y – остаток от деления X на Y. 314 % 100 даёт 14, и 144 % 12 даёт 0. Приоритет у оператора такой же, как у умножения и деления. Его ещё часто называют «деление по модулю», хотя более правильно «с остатком».

Специальные числа

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

Это Infinity и -Infinity , которые представляют положительную и отрицательную бесконечности. Infinity — 1 = Infinity, и так далее. Не надейтесь сильно на вычисления с бесконечностями, они не слишком строгие.

Третье число: NaN . Обозначает «not a number» (не число), хотя это величина числового типа. Вы можете получить её после вычислений типа 0 / 0, Infinity – Infinity, или других операций, которые не ведут к точным осмысленным результатам.

Строки

Следующий базовый тип данных – строки. Они используются для хранения текста. Записываются они в кавычках:

Можно использовать как двойные, так и одинарные кавычки – главное использовать их вместе. Почти всё можно заключить в кавычки и сделать из этого строку. Но некоторые символы вызывают проблемы. Например, сложно заключить кавычки в кавычки. Перевод строки тоже нельзя просто так заключить в них – строка должна идти одной строкой.

Для заключения специальных символов используется обратный слеш \. Он обозначает, что символ, идущий за ним, имеет специальное значение – это называется «экранирование символов» (escape character). \” можно заключать в двойные кавычки. \n обозначает перевод строки, \t – табуляцию.

Строка “Между первой и второй\nсимвол будет небольшой” на самом деле будет выглядеть так:

Если вам нужно включить в строку обратный слеш, его тоже нужно экранировать: \\. Инструкцию “Символ новой строки — это “\n”” нужно будет написать так:

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

Есть много способов манипуляций со строками, которые мы обсудим в главе 4.

Унарные операторы

Не все операторы записываются символами – некоторые словами. Один из таких операторов – typeof , который выдаёт название типа величины, к которой он применяется.

Будем использовать вызов console.log в примерах, когда захотим увидеть результат на экране. Как именно будет выдан результат – зависит от окружения, в котором вы запускаете скрипт.

Предыдущие операторы работали с двумя величинами, однако typeof использует только одну. Операторы, работающие с двумя величинами, называются бинарными, а с одной – унарными. Минус (вычитание) можно использовать и как унарный, и как бинарный.

Булевские величины

Часто вам нужна величина, которая просто показывает одну из двух возможностей – типа «да» и «нет», или «вкл» и «выкл». Для этого в JavaScript есть тип Boolean, у которого есть всего два значения – true и false (правда и ложь).

Сравнения

Один из способов получить булевские величины:

Знаки < и > традиционно обозначают «меньше» и «больше». Это бинарные операторы. В результате их использования мы получаем булевскую величину, которая показывает, является ли неравенство верным.

Строки можно сравнивать так же:

Строки сравниваются по алфавиту: буквы в верхнем регистре всегда «меньше» букв в нижнем регистре. Сравнение основано на стандарте Unicode. Этот стандарт присваивает номер практически любому символу из любого языка. Во время сравнения строк JavaScript проходит по их символам слева направо, сравнивая номерные коды этих символов.

Другие сходные операторы – это >= (больше или равно), <= (меньше или равно), == (равно), != (не равно).

В JavaScript есть только одна величина, которая не равна самой себе – NaN («не число»).

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

Логические операторы

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

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

Оператор || — логическое «или». Выдаёт true, если одна из величин true.

«Нет» записывается при помощи восклицательного знака “!”. Это унарный оператор, который обращает данную величину на обратную. !true получается false, !false получается true.

При использовании логических и арифметических операторов не всегда ясно, когда нужны скобки. На практике вы можете справиться с этим, зная, что у || приоритет ниже всех, потом идёт &&, потом операторы сравнения, потом все остальные. Такой порядок был выбран для того, чтобы в выражениях типа следующего можно было использовать скобок по минимуму:

Последний логический оператор не унарный и не бинарный – он тройной. Записывается при помощи вопросительного знака и двоеточия:

Это условный оператор, у которого величина слева от вопросительного знака выбирает одну из двух величин, разделённых двоеточием. Когда величина слева true, выбираем первое значение. Когда false, второе.

Неопределённые значения

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

Много операторов, которые не выдают значения, возвращают undefined просто для того, чтобы что-то вернуть. Разница между undefined и null появилась в языке случайно, и обычно не имеет значения.

Автоматическое преобразование типов

Ранее я упоминал, что JavaScript позволяет выполнять любые, подчас очень странные программы. К примеру:

Когда оператор применяется «не к тому» типу величин, JavaScript втихую преобразовывает величину к нужному типу, используя набор правил, которые не всегда соответствуют вашим ожиданиям. Это называется приведением типов (coercion). В первом выражении null превращается в 0, а “5” становится 5 (из строки – в число). Однако в третьем выражении + выполняет конкатенацию (объединение) строк, из-за чего 1 преобразовывается в “1’ (из числа в строку).

Когда что-то неочевидное превращается в номер (к примеру, “пять” или undefined), возвращается значение NaN. Последующие арифметические операции с NaN опять получают NaN. Если вы получили такое значение, поищите, где произошло случайное преобразование типов.

При сравнении величин одного типа через ==, легко предсказать, что вы должны получить true, если они одинаковые (исключая случай с NaN). Но когда типы различаются, JavaScript использует сложный и запутанный набор правил для сравнений. Обычно он пытается преобразовать тип одной из величин в тип другой. Когда с одной из сторон оператора возникает null или undefined, он выдаёт true, если обе стороны имеют значение null или undefined.

Последний пример демонстрирует полезный приём. Когда вам надо проверить, имеет ли величина реальное значение вместо null или undefined, вы просто сравниваете её с null при помощи == или !=.

Но что, если вам надо сравнить нечто с точной величиной? Правила преобразования типов в булевские значения говорят, что 0, NaN и пустая строка “” считаются false, а все остальные – true. Поэтому 0 == false и “” == false. В случаях, когда вам не нужно автоматическое преобразование типов, можно использовать ещё два оператора: === и !==. Первый проверяет, что две величины абсолютно идентичны, второй – наоборот. И тогда сравнение “” === false возвращает false.

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

Короткое вычисление логических операторов

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

К примеру, || вернёт значение с левой части, когда его можно преобразовать в true – а иначе вернёт правую часть.

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

Оператор && работает сходным образом, но наоборот. Если величина слева преобразовывается в false, он возвращает эту величину, а иначе – величину справа.

Ещё одно важное их свойство – выражение в правой части вычисляется только при необходимости. В случае true || X неважно, чему равно X. Даже если это какое-то ужасное выражение. Результат всегда true и X не вычисляется. Так же работает false && X – X просто игнорируется. Это называется коротким вычислением.

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

Мы рассмотрели четыре типа величин JavaScript: числа, строки, булевские и неопределённые.

Эти величины получаются, когда мы пишем их имена (true, null) или значения (13, “ёпрст”). Их можно комбинировать и изменять при помощи операторов. Для арифметики есть бинарные операторы (+, -, *, /, and %), объединение строк (+), сравнение (==, !=, ===, !==, <, >, <=, >=), и логические операторы (&&, ||), так же, как и несколько унарных операторов (- для отрицательного значения,! для логического отрицания, и typeof для определения типа величины).

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

Операторы в JavaScript

В JavaScript очень много операторов и их можно разделить на следующие группы:

; ; ; ; ; ; ;
• запятая; .

Оператор – это просто внутренняя функция JavaScript. При использовании того или иного оператора мы, по сути, просто запускаем ту или иную встроенную функцию, которая выполняет какие-то определённые действия и возвращает результат.

Унарные и бинарные операторы

Каждый оператор оперирует определённым количеством операндов. Операнд – это то, что находится слева и (или) справа от оператора. Иногда операнды называют ещё аргументами.

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

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

У унарных операторов всегда один операнд (аргумент). Примеры унарных операторов:

• оператор delete удаляет свойство объекта obj.a ;
• ++ увеличивает значение операнда b на 1 ;
• typeof позволяет узнать тип операнда c ;
• оператор new создаёт новый экземпляр объекта типа Date ;
• + конвертирует значение операнда d к числу.

У бинарных операторов в отличие от унарных всегда два операнда (аргумента) . Примеры бинарных операторов:

• оператор += имеет два операнда a и число 7 ; он складывает значение переменной а с числом 7 , а затем полученный результат присваивает a ;
• — отнимает от значения операнда c значение операнда b ;
• = присваивает ‘Привет’ переменной d ;
• === сравнивает значения e и 4 с учетом типа;
• && вычисляет логическое «И» операндов f1 и f2 .

Нотации записей операторов

В зависимости от того, в каком стиле записан оператор относительно операнда(ов) он имеет инфиксную, префиксную или постфиксную запись.

Инфиксную форму записи имеют операторы, которые находятся между операндами. Т.е. это все бинарные операторы:

Префиксную запись имеют операторы, которые пишутся перед операндом:

Постфиксную нотацию имеют операторы, которые идут после операнда:

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

Некоторые операторы в JavaScript, как например, ++ и — имеют как префиксную, так и постфиксную запись.

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

Оператор присваивания обозначается с помощью знака = . Он используется, когда вам нужно присвоить той или иной переменной какое-то значение.

В данном примере на второй строчке мы переменной a , которая была объявлена ранее, присваиваем значение 7 .

Что же такое оператор, например, присваивания или любой другой?

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

Как мы знаем у операторов имеются операнды, в данном случае их два. Один расположен слева от = , а другой справа. Эти операнды являются аргументами, которые мы передаём в эту функцию = .

После получения этих аргументов, в данном случае переменной a и выражения 7 , функция выполняет следующие действия:

• вычисляет результат выражения 7 ;
• пытается найти переменную a ; если переменная не найдена выбрасывает ошибку;
• присваивает переменной a результат выражения 7 ;
• возвращает в качестве результата выполнения функции = результат выражения 7 .

Это краткий пример того, как внутри JavaScript работает оператор = .

Данные операторы перед присваиванием, выполняют ещё одно дополнительное действие. Например, оператор += складывает значение переменной с результатом выражения, указанного справа от += :

То есть инструкцию x =+ 5 по другому можно записать так:

По сути, x += 5 это просто сокращенная запись от x = x + 5 .

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

В JavaScript выделяют следующие математические операторы :

• унарный плюс + и минус — ;
• сложение + ;
• вычитание — ;
• умножение * ;
• деление / ;
• остаток от деления % ;
• возведение в степень ** ;
• увеличение значения переменной на 1 ++ ;
• уменьшение значения переменной на 1 — .

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

JavaScript – это язык с динамическим приведением типов. Во втором примере оператор минус ( – ) является математическим и может оперировать только с числами . Для выполнения этой операции JavaScript приведёт значения первого и второго операнда к числам (5 и 15), а затем уже выполнит вычитание .

Ещё один пример с использованием оператора минус ( — ):

В этом примере JavaScript приведёт строку «px» к специальному числовому значению NaN . В результате вычисления 5 – NaN будет возвращён результат NaN .

Пример с использованием оператора плюс ( + ):

Оператор плюс ( + ) не только математический , он также используется для конкатенации (соединения) строк .

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

В этом примере второй операнд является строкой , следовательно, данная операция будет операцией конкатенацией строк . Т.к. первый операндов не является строкой, то JavaScript приведёт его к ней. В результате будет возвращена строка «5px».

Ещё оператор плюс ( + ) может применяться к одному операнду :

Унарный оператор плюс ( + ) в основном используется для явного преобразования не числовых типов данных к числам .

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

Операторы инкремента ( ++ ) и декремента ( — ) имеют префиксную и постфиксную форму.

Оператор процент ( % ) вычисляет остаток от деления первого операнда на второй:

Как вычисляется остаток от деления показано на картинке:

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

Операторы сравнения предназначены для сравнения двух операндов. Если сравнение верное, то в качестве результата этой операции возвращается true . В противном случае, значение false .

В JavaScript выделяют следующие операторы сравнения: == (равенство), != (не равенство), === (строгое равенство), !== (строгое не равенство), > (больше), >= (больше или равно), < (меньше), <= (меньше или равно).

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

При этом какой символ больше другого определяется по их кодам в таблице Unicode.

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

Если оба операнда являются объектами , то сравниваются их ссылки.

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

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

При сравнении объекта с примитивным типом данных , JavaScript вызывает его метод valueOf или toString . Полученное значение, если оно не объект, сравнивается с примитивным типом данных и возвращается результат. В противном случае, если метод valueOf или toString возвращают не примитивный тип, то выбрасывается ошибка: «Cannot convert object to primitive value».

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

Строковые операторы

В JavaScript оператор + можно использовать также для конкатенации или, другими словами, объединения строк:

В этом примере оператор + соединяет две строки. В результате вы получите «Hello, world!» .

В качестве операндов вы можете использовать переменные:

В JavaScript создавать строковые значения можно также с помощью шаблонной строки (template string literal). В отличие от строк, задаваемых с помощью одинарных или двойных кавычек, этот механизм имеет множество мощных возможностей.

Одна из возможностей – это использовать JavaScript выражения внутри строк. Пример, приведённый выше, с использованием шаблонной строки:

Обратите внимание, что шаблонная строка заключается в обратные кавычки. Внутри неё можно помещать различные выражения JavaScript, заключая их в ${} .

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

Шаблонные строки можно очень просто использовать для создания многострочных строк:

Ещё примеры с использованием шаблонной строки:

Пример соединения числа со строкой:

В данном случае интерпретатор JavaScript автоматически конвертировал число 50 в строку «50» , а потом соединил две строки: «Bob» и «50» . Данный процесс в JavaScript называется автоматическим приведением типов.

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

Текстовые операторы

Текстовые операторы – это такие, которые записываются не с помощью значков, а посредством символов. Например:

• typeof – позволяет узнать тип того или иного значения;
• instanceOf – можно проверить принадлежность объекта к тому или иному классу;
• delete – удаляет то или иное свойство объекта.

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

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

В этом примере оператор * имеет более высокий приоритет. Поэтому сначала выполнится умножение, а потом вычитание и сложение.

Но с использованием оператора «группировка» ( . ) порядок выполнения выражение будет другим, т.к. он имеет более высокий приоритет чем * :

Список операторов, упорядоченных по приоритету (от более высокого к низкому, через тире указана их специфичность):

1. Группировка () – не определено;
2. Доступ к свойствам . , [] , вызов функции () , ?. – слева направо, создание экземпляра объекта со списком аргументов new – не определено;
3. создание экземпляра объекта без аргументов new – справа налево;
4. Постфиксный инкремент ++ и декремент — – не определено;
5. Логическое ! и побитовое отрицание

В этом выражении операторы * и % имеют одинаковый приоритет, поэтому порядок выполнения этого выражения будет определяться в соответствии с ассоциативностью. Т.к. оператор * имеет левую ассоциативность (слева направо), то сначала будет выполнено 20 * 3 , а потом остаток от деления. Другими словами, это выражение будет обрабатываться так:

Если бы оператор * имел бы правую ассоциативность, то это выражение интерпретировалась бы так:

Например, оператор присваивания имеет правую ассоциативность (справа налево):

Т.е. в этом выражении сначала выполнится b = 7 , а затем результат этого выражения будет присвоен переменной a . Т.е. так:

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

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

Несколько операторов мы знаем со школы – это обычные сложение + , умножение * , вычитание и так далее.

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

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

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

Прежде, чем мы двинемся дальше – несколько терминов, чтобы понимать, о чём речь.

Операнд – то, к чему применяется оператор. Например: 5 * 2 – оператор умножения с левым и правым операндами. Другое название: «аргумент оператора».

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

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

Сложение строк, бинарный +

Обычно при помощи плюса ‘+’ складывают числа.

Но если бинарный оператор ‘+’ применить к строкам, то он их объединяет в одну:

Иначе говорят, что «плюс производит конкатенацию (сложение) строк».

Если хотя бы один аргумент является строкой, то второй будет также преобразован к строке!

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

Это приведение к строке – особенность исключительно бинарного оператора "+" .

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

Преобразование к числу, унарный плюс +

Унарный, то есть применённый к одному значению, плюс ничего не делает с числами:

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

Тем не менее, он широко применяется, так как его «побочный эффект» – преобразование значения в число.

Например, когда мы получаем значения из HTML-полей или от пользователя, то они обычно в форме строк.

А что, если их нужно, к примеру, сложить? Бинарный плюс сложит их как строки:

Поэтому используем унарный плюс, чтобы преобразовать к числу:

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

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

Приоритет

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

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

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

Отрывок из таблицы:

Приоритет	Название	Обозначение
…	…	…
15	унарный плюс	+
15	унарный минус	—
14	умножение	*
14	деление	/
13	сложение	+
13	вычитание	—
…	…	…
3	присваивание	=
…	…	…

Так как «унарный плюс» имеет приоритет 15 , выше, чем 13 у обычного «сложения», то в выражении +apples + +oranges сначала сработали плюсы у apples и oranges , а затем уже обычное сложение.

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

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

У него – один из самых низких приоритетов: 3 .

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

Возможно присваивание по цепочке:

Такое присваивание работает справа-налево, то есть сначала вычислятся самое правое выражение 2+2 , присвоится в c , затем выполнится b = c и, наконец, a = b .

Все операторы возвращают значение. Вызов x = выражение не является исключением.

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

В примере выше результатом (a = b + 1) является значение, которое записывается в a (т.е. 3 ). Оно используется для вычисления c .

Забавное применение присваивания, не так ли?

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

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

Оператор взятия остатка % интересен тем, что, несмотря на обозначение, никакого отношения к процентам не имеет.

Его результат a % b – это остаток от деления a на b .

Инкремент/декремент: ++ , —

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

Для этого существуют даже специальные операторы:

Инкремент ++ увеличивает на 1:

Декремент — уменьшает на 1:

Инкремент/декремент можно применить только к переменной. Код 5++ даст ошибку.

Вызывать эти операторы можно не только после, но и перед переменной: i++ (называется «постфиксная форма») или ++i («префиксная форма»).

Обе эти формы записи делают одно и то же: увеличивают на 1 .

Тем не менее, между ними существует разница. Она видна только в том случае, когда мы хотим не только увеличить/уменьшить переменную, но и использовать результат в том же выражении.

В строке (*) вызов ++i увеличит переменную, а затем вернёт ее значение в a . Так что в a попадёт значение i после увеличения.

Постфиксная форма i++ отличается от префиксной ++i тем, что возвращает старое значение, бывшее до увеличения.

В примере ниже в a попадёт старое значение i , равное 1 :

Если результат оператора не используется, а нужно только увеличить/уменьшить переменную – без разницы, какую форму использовать:

Если хочется тут же использовать результат, то нужна префиксная форма:

Если нужно увеличить, но нужно значение переменной до увеличения – постфиксная форма:

При этом он имеет более высокий приоритет и выполняется раньше, чем арифметические операции:

При этом, нужно с осторожностью использовать такую запись, потому что в более длинной строке при быстром «вертикальном» чтении кода легко пропустить такой i++ , и будет неочевидно, что переменая увеличивается.

Три строки, по одному действию в каждой – длиннее, зато нагляднее:

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

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

Эти операторы не являются чем-то специфичным для JavaScript, они поддерживаются в большинстве языков программирования.

Поддерживаются следующие побитовые операторы:

• AND(и) ( & )
• OR(или) ( | )
• XOR(побитовое исключающее или) ( ^ )
• NOT(не) (

Сокращённая арифметика с присваиванием

Часто нужно применить оператор к переменной и сохранить результат в ней же, например:

Эту запись можно укоротить при помощи совмещённых операторов, вот так:

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

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

Один из самых необычных операторов – запятая ‘,’ .

Его можно вызвать явным образом, например:

Запятая позволяет перечислять выражения, разделяя их запятой ‘,’ . Каждое из них – вычисляется и отбрасывается, за исключением последнего, которое возвращается.

Запятая – единственный оператор, приоритет которого ниже присваивания. В выражении a = (5,6) для явного задания приоритета использованы скобки, иначе оператор ‘=’ выполнился бы до запятой ‘,’ , получилось бы (a=5), 6 .

Зачем же нужен такой странный оператор, который отбрасывает значения всех перечисленных выражений, кроме последнего?

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

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