Теория JavaScript.ч.3. Операторы, Операнды и Выражения.

Содержание статьи
  1. Термины: «унарный», «бинарный», «операнд»
  2. Математика
  3. Взятие остатка %
  4. Возведение в степень **
  5. Сложение строк при помощи бинарного +
  6. Приведение к числу, унарный +
  7. Приоритет операторов
  8. Присваивание
  9. Присваивание = возвращает значение
  10. Присваивание по цепочке
  11. Сокращённая арифметика с присваиванием
  12. Инкремент/декремент
  13. Побитовые операторы
  14. Выражения
  15. Операторы
  16. Ассоциативность операторов
  17. Приоритет операторов
  18. Арифметические операторы
  19. Инкремент и декремент
  20. Присваивание
  21. Оператор группировки
  22. Оператор typeof
  23. Оператор запятая
  24. Переменные
  25. ▍Ключевое слово var
  26. ▍Ключевое слово let
  27. ▍Ключевое слово const
  28. Типы данных
  29. ▍Примитивные типы данных
  30. Тип number
  31. Тип string
  32. Шаблонные литералы
  33. Тип boolean
  34. Тип null
  35. Тип undefined
  36. Выражения
  37. Арифметические выражения
  38. Строковые выражения
  39. Первичные выражения
  40. Выражения инициализации массивов и объектов
  41. Логические выражения
  42. Выражения доступа к свойствам
  43. Выражения создания объектов
  44. Выражения объявления функций
  45. Выражения вызова
  46. Работа с объектами
  47. ▍Прототипное наследование
  48. Функции-конструкторы
  49. ▍Классы
  50. Объявление класса
  51. Наследование, основанное на классах
  52. Статические методы
  53. Приватные методы
  54. Геттеры и сеттеры
  55. Итоги
  56. JavaScript выражения.
  57. JavaScript операторы. Все операторы JavaScript.
  58. Арифметические операторы JavaScript.
  59. Логические операторы JavaScript.
  60. Строковые операторы JavaScript.
  61. Операторы равенства JavaScript, неравенства JavaScript, неидентичности JavaScript, идентичности JavaScript.
  62. Операторы отношения JavaScript. Операторы сравнения JavaScript.
  63. Поразрядные операторы JavaScript.
  64. Операторы присваивания JavaScript. Операторы присваивания с операцией.
  65. JavaScript операторы. Другие операторы JavaScript.
  66. Математические операторы
  67. Операторы присваивания
  68. Операторы сравнения
  69. Строковые операторы
  70. Побитовые операторы
  71. Приоритет операторов

Многие операторы знакомы нам ещё со школы: сложение умножение вычитание и так далее.

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

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

Прежде, чем мы двинемся дальше, давайте разберёмся с терминологией.

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

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

    let x = 1;x = -x;alert( x ); // -1, применили унарный минус
  • Бинарным называется оператор, который применяется к двум операндам. Тот же минус существует и в бинарной форме:

    let x = 1, y = 3;alert( y - x ); // 2, бинарный минус вычитает значения

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

Математика

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

  • Сложение
  • Вычитание
  • Умножение
  • Деление
  • Взятие остатка от деления
  • Возведение в степень

Первые четыре оператора очевидны, а про и стоит сказать несколько слов.

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

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

Результат a % b – это остаток от целочисленного деления a на b

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

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

В выражении a ** b оператор возведения в степень умножает a на само себя b раз.

alert( 2 ** 2 ); // 4  (2 умножено на себя 2 раза)alert( 2 ** 3 ); // 8  (2 * 2 * 2, 3 раза)alert( 2 ** 4 ); // 16 (2 * 2 * 2 * 2, 4 раза)

Математически, оператор работает и для нецелых чисел. Например, квадратный корень является возведением в степень 1/2

alert( 4 ** (1/2) ); // 2 (степень 1/2 эквивалентна взятию квадратного корня)alert( 8 ** (1/3) ); // 2 (степень 1/3 эквивалентна взятию кубического корня)

Сложение строк при помощи бинарного +

Давайте рассмотрим специальные возможности операторов JavaScript, которые выходят за рамки школьной арифметики.

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

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

let s = "моя" + "строка";alert(s); // моястрока

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

alert( '1' + 2 ); // "12"alert( 2 + '1' ); // "21"

Как видите, не важно, первый или второй операнд является строкой.

Вот пример посложнее:

alert(2 + 2 + '1' ); // будет "41", а не "221"

Здесь операторы работают один за другим. Первый складывает два числа и возвращает 4 затем следующий объединяет результат со строкой, производя действие 4 + '1' = 41

Сложение и преобразование строк — это особенность бинарного плюса Другие арифметические операторы работают только с числами и всегда преобразуют операнды в числа.

Например, вычитание и деление:

alert( 6 - '2' ); // 4, '2' приводится к числуalert( '6' / '2' ); // 3, оба операнда приводятся к числам

Приведение к числу, унарный +

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

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

 Не влияет на числаlet x = 1;alert( +x ); // 1let y = -2;alert( +y ); // -2// Преобразует не числа в числаalert( +true ); // 1alert( +"" );   // 0

На самом деле это то же самое, что и Number(...) только короче.

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

Бинарный плюс сложит их как строки:

let apples = "2";let oranges = "3";alert( apples + oranges ); // "23", так как бинарный плюс объединяет строки

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

let apples = "2";let oranges = "3";// оба операнда предварительно преобразованы в числаalert( +apples + +oranges ); // 5// более длинный вариант// alert( Number(apples) + Number(oranges) ); // 5

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

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

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

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

Из школы мы знаем, что умножение в выражении 1 + 2 * 2 выполнится раньше сложения. Это как раз и есть «приоритет». Говорят, что умножение имеет более высокий приоритет, чем сложение.

Скобки важнее, чем приоритет, так что, если мы не удовлетворены порядком по умолчанию, мы можем использовать их, чтобы изменить приоритет. Например, написать 1 + 2) * 2

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

Отрывок из таблицы приоритетов (нет необходимости всё запоминать, обратите внимание, что приоритет унарных операторов выше, чем соответствующих бинарных):

Приоритет Название Обозначение
15 унарный плюс
15 унарный минус
14 возведение в степень
13 умножение
13 деление
12 сложение
12 вычитание
2 присваивание =

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

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

Давайте отметим, что в таблице приоритетов также есть оператор присваивания = У него один из самых низких приоритетов: 2

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

let x = 2 * 2 + 1;alert( x ); // 5

Присваивание = возвращает значение

Тот факт, что = является оператором, а не «магической» конструкцией языка, имеет интересные последствия.

Большинство операторов в JavaScript возвращают значение. Для некоторых это очевидно, например сложение или умножение Но и оператор присваивания не является исключением.

Вызов x = value записывает value в x и возвращает его.

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

let a = 1;let b = 2;let c = 3 - (a = b + 1);alert( a ); // 3alert( c ); // 0

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

Забавное применение присваивания, не так ли? Нам нужно понимать, как это работает, потому что иногда это можно увидеть в JavaScript-библиотеках.

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

Присваивание по цепочке

Рассмотрим ещё одну интересную возможность: цепочку присваиваний.

let a, b, c;a = b = c = 2 + 2;alert( a ); // 4alert( b ); // 4alert( c ); // 4

Такое присваивание работает справа налево. Сначала вычисляется самое правое выражение 2 + 2 и затем результат присваивается переменным слева: c b и a В конце у всех переменных будет одно значение.

Опять-таки, чтобы код читался легче, лучше разделять подобные конструкции на несколько строчек:

Польза от такого стиля особенно ощущается при быстром просмотре кода.

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

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

let n = 2;n = n + 5;n = n * 2;

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

let n = 2;n += 5; // теперь n = 7 (работает как n = n + 5)n *= 2; // теперь n = 14 (работает как n = n * 2)alert( n ); // 14

Подобные краткие формы записи существуют для всех арифметических и побитовых операторов: , = и так далее.

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

let n = 2;n *= 3 + 5;alert( n ); // 16  (сначала выполнится правая часть, выражение идентично n *= 8)

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

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

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

  • Инкремент

    увеличивает переменную на 1:

    let counter = 2;counter++;        // работает как counter = counter + 1, просто запись корочеalert( counter ); // 3
  • Декремент

    уменьшает переменную на 1:

    let counter = 2;counter--;        // работает как counter = counter - 1, просто запись корочеalert( counter ); // 1

Инкремент/декремент можно применить только к переменной. Попытка использовать его на значении, типа 5++, приведёт к ошибке.

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

  • Когда оператор идёт после переменной — это «постфиксная форма»: counter++
  • «Префиксная форма» — это когда оператор идёт перед переменной: counter

Обе эти инструкции делают одно и то же: увеличивают counter на 1

Есть ли разница между ними? Да, но увидеть её мы сможем, только если будем использовать значение, которое возвращают

Давайте проясним этот момент. Как мы знаем, все операторы возвращают значение. Операторы инкремента/декремента не исключение. Префиксная форма возвращает новое значение, в то время как постфиксная форма возвращает старое (до увеличения/уменьшения числа).

Чтобы увидеть разницу, вот небольшой пример:

let counter = 1;let a = ++counter; // (*)alert(a); // 2

В строке префиксная форма counter увеличивает counter и возвращает новое значение 2 Так что alert покажет 2

Теперь посмотрим на постфиксную форму:

let counter = 1;let a = counter++; // (*) меняем ++counter на counter++alert(a); // 1

В строке постфиксная форма counter++ также увеличивает counter но возвращает старое значение (которое было до увеличения). Так что alert покажет 1

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

    let counter = 0;counter++;++counter;alert( counter ); // 2, обе строки сделали одно и то же
  • Если хочется тут же использовать результат, то нужна префиксная форма:

    let counter = 0;alert( ++counter ); // 1
  • Если нужно увеличить и при этом получить значение переменной до увеличения – нужна постфиксная форма:

    let counter = 0;alert( counter++ ); // 0

Инкремент/декремент можно использовать в любых выражениях

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

let counter = 1;alert( 2 * ++counter ); // 4
let counter = 1;alert( 2 * counter++ ); // 2, потому что counter++ возвращает "старое" значение

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

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

Лучше использовать стиль «одна строка – одно действие»:

let counter = 1;alert( 2 * counter );counter++;

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

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

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

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

  • AND(и) ( &
  • OR(или) (
  • XOR(побитовое исключающее или) (
  • NOT(не) (
  • LEFT SHIFT(левый сдвиг) (
  • RIGHT SHIFT(правый сдвиг) (
  • ZERO-FILL RIGHT SHIFT(правый сдвиг с заполнением нулями) (

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

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

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

let a = (1 + 2, 3 + 4);alert( a ); // 7 (результат вычисления 3 + 4)

Первое выражение 1 + 2 выполняется, а результат отбрасывается. Затем идёт 3 + 4 выражение выполняется и возвращается результат.

Запятая имеет очень низкий приоритет

Пожалуйста, обратите внимание, что оператор имеет очень низкий приоритет, ниже = поэтому скобки важны в приведённом выше примере.

Без них в a = 1 + 2, 3 + 4 сначала выполнится суммируя числа в a = 3, 7 затем оператор присваивания = присвоит a = 3 а то, что идёт дальше, будет игнорировано. Всё так же, как в a = 1 + 2), 3 + 4

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

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

 три операции в одной строкеfor (a = 1, b = 3, c = a * b; a < 10; a++) { ...}

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

Выражения

Выражение

— это любая единица исходного кода программы, которая может быть вычислена для получения значения. Выражения делятся простые (их также называют первичными), и сложные.
Первичные выражения являются самостоятельными выражениями — они не включают в себя ещё более простых выражений. К первичным выражениям относятся: ключевое слово this идентификаторы, литералы и оператор группировки.
Сложные выражения состоят из простых выражений.
Типичный способ конструирования сложных выражений из простых выражений заключается в использовании операторов:

script Код: Выделить всё Развернуть
Примеры первичных выражений
this                     // Значение зависит от контекста выполнения
11                       // Числовой литерал
str                      // Возвращает значение переменной
                       // Литерал массива
                       // Оператора группировки
script Код: Выделить всё Развернуть
Примеры сложных выражений
alpha + 19               // Возвращает результат арифметической операции
alpha - 37) * beta / 2  // Возвращает результат арифметических операций
foo()                    // Возвращает результат вызова функции
mass[1]                  // Возвращает значение элемента массива

Операторы

Оператор

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

унарным

, с двумя —

бинарным

, с тремя —

тернарным

.

Существует один оператор, у которого нет операндов — это

оператор группировки

.

Операторы могут автоматически преобразовывать типы своих операндов по мере необходимости.
Например, оператор умножения ожидает получить числовые операнды, поэтому выражение "2" * "3" считается вполне допустимым благодаря тому, что интерпретатор выполнит неявное преобразование строковых операндов в числа.

Ассоциативность операторов

Ассоциативность

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

script Код: Выделить всё Развернуть
w = x - y - z;
w = (x - y) - z;

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

имеет ассоциативность справа налево, поэтому следующие два выражения в инструкциях также эквивалентны:

script Код: Выделить всё Развернуть
w = x = y = z;
w = (x = (y = z));

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

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

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

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

В колонке »

Типы значений

» указаны ожидаемые типы операндов (перед стрелкой) и тип результата возвращаемого оператором (после стрелки).
В колонке »

О

» указано количество операндов.

lval

(сокращение от left value) — левостороннее выражение.
Это исторический термин, обозначающий — выражение, которое может присутствовать слева от оператора присваивания. Левосторонними выражениями являются: переменные, свойства объектов и элементы массивов.

Оператор Операция Ассоциатив. О Типы значений
…) Оператор группировки отсутствует любой

.



new … (…)

Оператор доступа
Оператор доступа
Создание объекта
слева направо
слева направо
отсутствует
2
2
1
lval, lval → любой
lval, строка или число → любой
конструктор → объект
… (…) Оператор вызова функции слева направо 1 функция → любой
Префиксный и постфиксный инкремент
Префиксный и постфиксный декремент
отсутствует
отсутствует
1
1
lval → число
lval → число

delete
typeof
void

Унарный плюс
Унарный минус
Логическое НЕ (инверсия)
Поразрядная инверсия
Удаление свойства
Определяет тип данных операнда
Возврат неопределённого значения
справа налево
справа налево
справа налево
справа налево
справа налево
справа налево
справа налево
1
1
1
1
1
1
1
число → число
число → число
булево → булево
целое → целое
lval → булево
любое → строка
любое → undefined
Умножение
Деление
Деление по модулю
слева направо
слева направо
слева направо
2
2
2
число, число → число
число, число → число
число, число → число
Сложение
Вычитание
Конкатенация
слева направо
слева направо
слева направо
2
2
2
число, число → число
число, число → число
строка, строка → строка
Сдвиг битов влево
Сдвиг битов вправо с сохранением знака
Сдвиг битов вправо с заполнением нулями
слева направо
слева направо
слева направо
2
2
2
целое, целое → целое
целое, целое → целое
целое, целое → целое
<, <=, >, >=
<, <=, >, >=
in
instanceof
Сравнение числовых значений
Сравнение строковых значений
Проверка наличия свойства
Проверка на принадлежность к данному типу
слева направо
слева направо
слева направо
слева направо
2
2
2
2
число, число → булево
строка, строка → булево
строка, объект → булево
объект, функция → булево
==
=
===
==
Проверка равенства
Проверка неравенства
Проверка строгого равенства (идентичности)
Проверка неидентичности
слева направо
слева направо
слева направо
слева направо
2
2
2
2
любое, любое → булево
любое, любое → булево
любое, любое → булево
любое, любое → булево
& Поразрядное И слева направо 2 целое, целое → целое
Поразрядное ИСКЛЮЧАЮЩЕЕ ИЛИ слева направо 2 целое, целое → целое
Поразрядное ИЛИ слева направо 2 целое, целое → целое
&& Логическое И слева направо 2 любое, любое → любое
Логическое ИЛИ слева направо 2 любое, любое → любое

?

:

Выбор второго или третьего операнда справа налево 3 булево, любое, любое → любое
= Присваивание справа налево 2 lval, любое → любое
=, -=, *=,
=, %=, +=,
=, &=,
=, =,
=
Операции с присваиванием справа налево 2 lval, любое → любое

,

Вычисляет оба операнда и возвращает значение второго слева направо 2 любое, любое → любое

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

Оператор Операция Ассоциативность Операнды Типы значений
Сложение
Вычитание
Умножение
Деление
Деление по модулю (с остатком)
Унарный минус
Унарный плюс
слева направо
слева направо
слева направо
слева направо
слева направо
справа налево
справа налево
2
2
2
2
2
1
1
число, число → число
число, число → число
число, число → число
число, число → число
число, число → число
число → число
число → число

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

script Код: Выделить всё Развернуть
var num1 = 10;
var num2 = 2;
var num3 = 5
document.write(num1 + num2 + "<br>");
document.write(num1 - num2 + "<br>");

document.write(num1 / num2 + "<br>");

document.write(-num3 % num2);

Оператор

унарный плюс

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

script Код: Выделить всё Развернуть
var x = "5";
alert(+x - 2);

Оператор

унарный минус

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

script Код: Выделить всё Развернуть
var x = "3";
alert(4 + (-x));

В данном случае круглые скобки не нужны вокруг «-x», но они помогают организовать код таким образом, чтобы было понятно, что имеет место сложение чисел -3 и 4.

Нечисловые операнды

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

script Код: Выделить всё Развернуть
var str = "1x";
var num = 5;
alert(num - str);
alert(++str);
alert(+str);

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

Оператор Операция Ассоциативность Операнды Типы значений
Префиксный и постфиксный инкремент
Префиксный и постфиксный декремент
не поддерживается
не поддерживается
1
1
lval → число
lval → число

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

Инкремент

имеет две формы — постфиксную (после операнда — x++) и префиксную (перед операндом — ++x).
Значение, возвращаемое оператором ++, зависит от его положения по отношению к операнду.
Если он используется в постфиксной форме, то сначала возвращается исходное значение операнда, и только затем значение операнда увеличивается на единицу:

script Код: Выделить всё Развернуть
var x = 5;
alert(x++);
alert(x);

В отличие от постфиксной формы, инкремент в префиксной форме сразу увеличивает значение своего операнда на единицу:

script Код: Выделить всё Развернуть
var x = 5;
alert(++x);

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

php Код: Выделить всё Развернуть
var x = 1
= x  1

Обратите внимание

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

2

, тогда как выражение x + 1 или x += 1 вернёт строку »

11

«:

script Код: Выделить всё Развернуть
var x = "1";
var y = "1";
x = x + 1;
y;

document.write("y: " + y);

Оператор

декремент

( работает аналогично оператору но не увеличивает значение своего операнда, а наоборот, уменьшает его на единицу:

script Код: Выделить всё Развернуть
var x = 5;
alert(--x);

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

Оператор Операция Ассоциативность Операнды Типы значений
=
=, -=, *=, /=, %=
Присваивание
Операция с присваиванием
справа налево
справа налево
2
2
lval, любое → любое
lval, любое → любое

Для присваивания значения используется оператор присваивания.

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

обозначается символом =равно).
Левым операндом оператора = должно быть левостороннее выражение.
Правым операндом может быть значение любого типа. Возвращаемым значением оператора присваивания является значение правого операнда.

script Код: Выделить всё Развернуть
var x = 20;
var y = x + 32;

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

script Код: Выделить всё Развернуть
var a, d, f;
a = d = f = 101;

Значение присваивается справа налево, сначала переменной «f», затем значение переменной «f» присваивается переменной «d» и, наконец, значение переменной «d» присваивается переменной «a».
Такой способ присваивания «по цепочке» удобен для присваивания общего значения целой группе переменных.

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

script Код: Выделить всё Развернуть
a op= b

где op означает оператор, эквивалентно выражению:

script Код: Выделить всё Развернуть
a = a op b

Например, оператор = выполняет сложение и присваивание.
Следующее выражение:

script Код: Выделить всё Развернуть
x += 5;
script Код: Выделить всё Развернуть
x = x + 5;

Как и ожидается, оператор = работает и с числами, и со строками.
Для числовых операндов он выполняет сложение и присваивание, а для строковых — конкатенацию и присваивание.

Оператор группировки

Синтаксис оператора группировки:

script Код: Выделить всё Развернуть
выражение)

Оператор группировки

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

function () )

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

script Код: Выделить всё Развернуть
w = x + y * z;
w = (x + y) * z;

Оператор typeof

Оператор Операция Ассоциативность Операнды Типы значений
typeof Определяет тип данных операнда справа налево 1 любое→строка

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

тип данных

операнда.
Следующая таблица содержит значения возвращаемые оператором typeof для всех типов значений, возможных в JavaScript.

Значение x typeof x
undefined
null
true или false
любое число, Infinity или NaN
любая строка
любая функция
любой объект или массив базового языка
«undefined»
«object»
«boolean»
«number»
«string»
«function»
«object»

Операнд оператора typeof может быть записан в двух формах:

script Код: Выделить всё Развернуть
var x = 5;
document.write(typeof x + "<br>");
document.write(typeof (x));

Форма записи операнда никак не влияет на результат: можно использовать скобки, а можно и не использовать — работает одинаково.

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

Оператор Операция Ассоциативность Операнды Типы значений

,

Вычисляет оба операнда и возвращает значение второго слева направо 2 любое, любое → любое

Оператор запятая ( является бинарным оператором и может принимать операнды любого типа.
Он вычисляет оба операнда (слева направо) и возвращает значение правого операнда:

script Код: Выделить всё Развернуть
var n = (5, 10);
document.write(n);    // =>10

var a, b, c
a = (b=1, c=4);

document.write(b);    // =>1

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

script Код: Выделить всё Развернуть
var n = (1, 2, 3, 4);

Следующий пример эквивалентен примеру выше — он показывает порядок выполнения выражений:

script Код: Выделить всё Развернуть
var a = (((1, 2), 3), 4);

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

script Код: Выделить всё Развернуть
for (var i=1, j=5; i <= 5; i++, j--)

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

→ Часть 1: первая программа, особенности языка, стандарты
→ Часть 2: стиль кода и структура программ
→ Часть 3: переменные, типы данных, выражения, объекты
→ Часть 4: функции
→ Часть 5: массивы и циклы
→ Часть 6: исключения, точка с запятой, шаблонные литералы

→ Часть 8: обзор возможностей стандарта ES6
→ Часть 9: обзор возможностей стандартов ES7, ES8 и ES9

Переменные

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

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

Прежде чем использовать переменную, её нужно объявить с использованием ключевого слова var или let Если речь идёт о константе, применяется ключевое слово const Объявить переменную и присвоить ей некое значение можно и не используя эти ключевые слова, но делать так не рекомендуется.

▍Ключевое слово var

До появления стандарта ES2015 использование ключевого слова var было единственным способом объявления переменных.

var a = 0

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

Так, если включён так называемый строгий режим (strict mode), подобное вызоветЕсли строгий режим не включён, произойдёт неявное объявление переменной и она будет назначена глобальному объекту. В частности, это означает, что переменная, неявно объявленная таким образом в некоей функции, окажется доступной и после того, как функция завершит работу. Обычно же ожидается, что переменные, объявляемые в функциях, не «выходят» за их пределы. Выглядит это так:

В консоль попадёт 1 такого поведения от программы обычно никто не ждёт, выражение bNotVar = 1 выглядит не как попытка объявления и инициализации переменной, а как попытка обратиться к переменной, находящейся во внешней по отношению к функции области видимости (это — вполне нормально). Как результат, неявное объявление переменных сбивает с толку того, кто читает код и может приводить к неожиданному поведению программ. Позже мы поговорим и о функциях, и об областях видимости, пока же постарайтесь всегда, когда смысл некоего выражения заключается в объявлении переменной, пользоваться специализированными ключевыми словами. Если в этом примере тело функции переписать в виде var bNotVar = 1 то попытка запустить вышеприведённый фрагмент кода приведёт к появлению сообщения об ошибке (его можно увидеть в консоли браузера).

Выглядеть оно, например, может так: Uncaught ReferenceError: bNotVar is not defined Смысл его сводится к тому, что программа не может работать с несуществующей переменной. Гораздо лучше, при первом запуске программы, увидеть такое сообщение об ошибке, чем писать непонятный код, который способен неожиданно себя вести.

Если, при объявлении переменной, её не инициализируют, не присваивают ей какого-либо значения, ей автоматически будет присвоено значение undefined

var a //typeof a === 'undefined'

Переменные, объявленные с помощью ключевого слова var можно многократно объявлять снова, назначая им новые значения (но это может запутать того, кто читает код).

var a = 1var a = 2

В одном выражении можно объявить несколько переменных:

var a = 1, b = 2

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

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

Если в функции, с использованием var объявлена переменная, имя которой совпадает с именем некоей переменной из глобальной области видимости, она «перекроет» глобальную переменную. То есть, при обращении к такой переменной внутри функции будет использоваться именно её локальный вариант.

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

Если в коде функции объявлена некая переменная, она видна всему коду функции. Даже если переменная объявлена с помощью var в конце кода функции, обратиться к ней можно и в начале кода, так как в JavaScript работает механизм поднятия переменных (hoisting). Этот механизм «поднимает» объявления переменных, но не операции их инициализации. Это может стать источником путаницы, поэтому возьмите себе за правило объявлять переменные в начале функции.

▍Ключевое слово let

Ключевое слово let появилось в ES2015, его, упрощённо, можно назвать «блочной» версией var Область видимости переменных, объявленных с помощью ключевого слова let ограничивается блоком, оператором или выражением, в котором оно объявлено, а также вложенными блоками.

Если само слово «let» кажется не очень понятным, можно представить, что вместо него используется слово «пусть». Тогда выражение let color = 'red' можно перевести на английский так: «let the color be red», а на русский — так: «пусть цвет будет красным».

При использовании ключевого слова let можно избавиться от неоднозначностей, сопутствующих ключевому слову varнапример, не удастся два раза, используя let объявить одну и ту же переменную). Использование let за пределами функции, скажем, при инициализации циклов, не приводит к созданию глобальных переменных.

Например, такой код вызовет

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

В наши дни, при разработке JS-программ на основе современных стандартов, вполне можно полностью отказаться от var и использовать только ключевые слова let и const

▍Ключевое слово const

Значения переменных, объявленных с использованием ключевых слов var или let могут быть перезаписаны. Если же вместо этих ключевых слов используется const то объявленной и инициализированной с его помощью константе новое значение присвоить нельзя.

const a = 'test'

В данном примере константе a нельзя присвоить новое значение. Но надо отметить, что если a — это не примитивное значение, наподобие числа, а объект, использование ключевого слова const не защищает этот объект от изменений.

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

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

В константу obj при инициализации, записывается новый пустой объект. Попытка обращения к его свойству a несуществующему, ошибки не вызывает. В консоль попадает undefined После этого мы добавляем в объект новое свойство и снова пытаемся обратиться к нему. В этот раз в консоль попадает значение этого свойства — 1 Если раскомментировать последнюю строку примера, то попытка выполнения этого кода приведёт к ошибке.

Ключевое слово const очень похоже на let в частности, оно обладает блочной областью видимости.

В современных условиях вполне допустимо использовать для объявления всех сущностей, значения которых менять не планируется, ключевое слово const прибегая к let только в особых случаях. Почему? Всё дело в том, что лучше всего стремиться к использованию как можно более простых из доступных конструкций для того, чтобы не усложнять программы и избегать ошибок.

Типы данных

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

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

▍Примитивные типы данных

Вот список примитивных типов данных JavaScript:

  • numberчисло)
  • stringстрока)
  • booleanлогическое значение)
  • nullспециальное значение null
  • undefinedспециальное значение undefined
  • symbolсимвол, используется в особых случаях, появился в ES6)

Здесь названия типов данных приведены в том виде, в котором их возвращает оператор typeof

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

Тип number

Значения типа number в JavaScript представлены в виде 64-битных чисел двойной точности с плавающей запятой.

В коде числовые литералы представлены в виде целых и дробных чисел в десятичной системе счисления. Для записи чисел можно использовать и другие способы. Например, если в начале числового литерала имеется префикс 0x — он воспринимается как число, записанное в шестнадцатеричной системе счисления. Числа можно записывать и в экспоненциальном представлении (в таких числах можно найти букву e

Вот примеры записи целых чисел:

1053545767673210xCC // шестнадцатеричное число

Вот дробные числа.

Числовые литералы (такое поведение характерно и для некоторых других примитивных типов), при попытке обращения к ним как к объектам, автоматически, на время выполнения операции, преобразуются в соответствующие объекты, которые называют «объектными обёртками». В данном случае речь идёт об объектной обёртке Number

Вот, например, как выглядит попытка обратиться к переменной a в которую записан числовой литерал, как к объекту, в консоли Google Chrome.

Подсказка по объектной обёртке Number

Если, например, воспользоваться методом toString() объекта типа Number он возвратит строковое представление числа. Выглядит соответствующая команда, которую можно выполнить в консоли браузера (да и в обычном коде) так:

Обратите внимание на двойные скобки после имени метода. Если их не поставить, система не выдастно, вместо ожидаемого вывода, в консоли окажется нечто, совсем не похожее на строковое представление числа 5.

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

Тип string

Значения типа string представляют собой последовательности символов. Такие значения задают в виде строковых литералов, заключённых в одинарные или двойные кавычки.

'A string'"Another string"

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

"A string"

Строка может содержать так называемые escape-последовательности, интерпретируемые при выводе строки в консоль. Например, последовательность n означает символ перевода строки. Символ обратной косой черты можно использовать и для того, чтобы добавлять кавычки в строки, заключённые в такие же кавычки. Экранирование символа кавычки с помощью приводит к тому, что система не воспринимает его как специальный символ.

'I'm a developer'

Строки можно конкатенировать с использованием оператора

"A " + "string"

Шаблонные литералы

В ES2015 появились так называемые шаблонные литералы, или шаблонные строки. Они представляют собой строки, заключённые в обратные кавычки ( и обладают некоторыми интересными свойствами.

a string`

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

Использование обратных кавычек упрощает многострочную запись строковых литералов:

a stringwith${something}`

Тип boolean

В JavaScript есть пара зарезервированных слов, использующихся при работе с логическими значениями — это истина), и ложь). Операции сравнения, например, такие, как == === < > возвращают или

Логические выражения используются в конструкциях наподобие if и while помогая управлять ходом выполнения программы.

При этом надо отметить, что там, где ожидается значение или можно использовать и другие значения, которые автоматически расцениваются языком как истинные (truthy) или ложные (falsy).

В частности, ложными значениями являются следующие:

0-0NaNundefinednull'' //пустая строка

Остальные значения являются истинными.

Тип null

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

Тип undefined

Значение undefined записанное в некую переменную, указывает на то, что эта переменная не инициализирована и значение для неё отсутствует.

Это значение автоматически возвращается из функций, результат работы которых не возвращается явно, с использованием ключевого слова return Если функция принимает некий параметр, который, при её вызове, не указан, он также устанавливается в undefined

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

typeof v>▍Объекты

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

Выражения

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

Арифметические выражения

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

1 / 2i++i -= 2i * 2

Строковые выражения

Результатом вычисления таких выражений являются строки.

'A ' + 'string''A ' += 'string'

Первичные выражения

В эту категорию попадают литералы, константы, ссылки на идентификаторы.

Сюда же можно отнести и некоторые ключевые слова и конструкции JavaScript.

functionclassfunction* //генераторyield //команда приостановки/возобновления работы генератораyield* //делегирование другому итератору или генераторуasync function* //асинхронное функциональное выражение await //организация ожидания выполнения асинхронной функции/pattern/i //регулярное выражение() //группировка

Выражения инициализации массивов и объектов

литерал массива //объектный литерал[1,2,3]{a: 1, b: 2}{a: {b: 1}}

Логические выражения

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

a && ba  b!a

Выражения доступа к свойствам

Эти выражения позволяют обращаться к свойствам и методам объектов.

Выражения создания объектов

new object()new a(1)new MyRectangle('name', 2, {a: 4})

Выражения объявления функций

function() function(a, b) { return a * b }(a, b) => a * ba => a * 2() => { return 2 }

Выражения вызова

Такие выражения используются для вызова функций или методов объектов.

Работа с объектами

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

▍Прототипное наследование

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

У каждого JavaScript-объекта есть особое свойство (__proto__ которое указывает на другой объект, являющийся его прототипом. Объект наследует свойства и методы прототипа.

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

const car = 

Или мы создали объект, воспользовавшись конструктором Object

const car = new Object()

В любом из этих случаев прототипом объекта car будет

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

const list = //или такconst list = new Array()

Проверить это можно следующим образом.

Здесь мы пользовались свойством __proto__ оно не обязательно должно быть доступно разработчику, но обычно обращаться к нему можно. Надо отметить, что более надёжным способом получить прототип объекта является использование метода getPrototypeOf() глобального объекта Object

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

Подсказка по массиву

Базовым прототипом для всех объектов является

У прототипа нет.

То, что мы видели выше, является примером цепочки прототипов.

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

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

Проверить, входит ли некий объект в цепочку прототипов другого объекта, можно с использованием метода isPrototypeOf()

Функции-конструкторы

Выше мы создавали новые объекты, пользуясь уже имеющимися в языке функциями-конструкторами (при их вызове используется ключевое слово new Такие функции можно создавать и самостоятельно. Рассмотрим пример.

Здесь мы создаём функцию-конструктор. При её вызове создаётся новый объект, на который указывает ключевое слово this в теле конструктора. Мы добавляем в этот объект свойство name и записываем в него то, что передано конструктору. Этот объект возвращается из конструктора автоматически. С помощью функции-конструктора можно создать множество объектов, свойства name которых будут содержать то, что передано при их создании конструктору.

После создания конструктора мы добавляем в его прототип функцию, которая будет выводить в консоль значение свойства name объекта, созданного с помощью этой функции. Все объекты, созданные с помощью этого конструктора, будут иметь один и тот же прототип, а значит и пользоваться одной и той же функцией hello() Это несложно проверить, создав ещё один объект типа Person и сравнив его функцию hello() с функцией уже имеющегося в примере объекта (имя функции в таком случае записывают без скобок).

▍Классы

В стандарте ES6 в JavaScript пришло такое понятие как «класс».

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

Объявление класса

Вот как выглядит объявление класса.

У класса есть идентификатор, который можно использовать для создания новых объектов с применением конструкции new ClassIdentifier()

При создании нового объекта вызывается метод constructor ему передаются параметры.

В классе можно объявлять методы. В нашем случае hello() — это метод, который могут вызывать все объекты, созданные на основе класса. Вот как выглядит создание нового объекта с использованием класса Person

Наследование, основанное на классах

Классы могут расширять другие классы. Объекты, созданные на основе таких классов, будут наследовать и методы исходного класса, и методы, заданные в расширенном классе.

Если класс, расширяющий другой класс (наследник этого класса) имеет метод, имя которого совпадает с тем, который есть у класса-родителя, этот метод имеет преимущество перед исходным.

При вызове метода hello() в вышеприведённом примере будет возвращена строка Hello, I am Flavio. I am a programmer

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

Внутри класса можно обращаться к родительскому классу с использованием ключевого слова super

Статические методы

Методы, описываемые в классе, можно вызывать, обращаясь к объектам, созданным на основе этого класса, но не к самому классу. Статические (static методы можно вызывать, обращаясь непосредственно к классу.

Приватные методы

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

Геттеры и сеттеры

В классе можно описывать методы, предваряя их ключевыми словами get или set Это позволяет создавать так называемые геттеры и сеттеры — функции, которые используются для управления доступом к свойствам объектов, созданных на основе класса. Геттер вызывается при попытке чтения значения псевдо-свойства, а сеттер — при попытке записи в него нового значения.

Итоги

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

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

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

Операторы

JavaScript

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

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

Выражения

JavaScript

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

JavaScript выражения.

  • JavaScript выражения.
  • JavaScript операторы. Все операторы JavaScript.
  • Арифметические операторы JavaScript.
  • Логические операторы JavaScript.
  • Строковые операторы JavaScript.
  • Операторы отношения JavaScript. Операторы сравнения JavaScript.
  • Поразрядные операторы JavaScript.
  • Операторы присваивания JavaScript. Операторы присваивания с операцией.
  • JavaScript операторы. Другие операторы JavaScript.

JavaScript выражения

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

Это все JavaScript выражения, выражениями могут быть логические значения JavaScript, специальные значения JavaScript такие как: null и undefined, регулярное выражение JavaScript тоже является выражением.

Все вышеперечисленные выражения JavaScript являются простыми выражениями, при помощи операторов JavaScript можно объединять простые JavaScript выражения в сложные.

Здесь мы объединили два простых JavaScript выражения(переменную JavaScript и число) в одно сложное выражение при помощи арифметического оператора сложения. То есть, JavaScript операторы объединяют простые выражения JavaScript в сложные выражения. В данном случае JavaScript оператор сложения является бинарным оператором, так как ему требуется два JavaScript операнда, чтобы получилось сложное выражение. Также бывают тернарные операторы JavaScript и унарные операторы JavaScript.

Можно сделать еще более сложное выражение:

В данном случае я добавил еще два оператора JavaScript: оператор () и оператор — . Таким образом, JavaScript выражение стало еще более сложным, конечно, данные примеры притянуты за уши и на самом деле придется составлять более

сложные JavaScript выражения

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

JavaScript операторы. Все операторы JavaScript.

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

JavaScript операторы

могут записывать как символами JavaScript (+, — , *, /). Запятая – это тоже JavaScript оператор. JavaScript оператор может быть ключевым словом, например оператор typeof. У JavaScript операторов есть ассоциативность. Ассоциативность операторов – это направления выполнения оператора(слева направо или справа на лево). Каждый JavaScript оператор выполняет различные функции.

Некоторые JavaScript операторы могут работать с каким-либо отдельным типом данных JavaScript, а некоторые работают со всеми типами данных. Операторы делятся на: унарные, тернарные и бинарные.

  • Бинарные операторы JavaScript объединяют два JavaScript выражение в одно, и для их работы требуется два операнда JavaScript.
  • Унарные операторы JavaScript требует для своей работы только один JavaScript операнд.
  • Тернарные операторы JavaScript объединяют три JavaScript выражения в одно и поэтому для их работы необходимо три операнда.

При написании программ на языке JavaScript все эти факторы нужно учитывать! Перейдем к JavaScript операторам.

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

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

JavaScript

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

Арифметические операторы JavaScript
JavaScript оператор Ассоциативность оператора JavaScript Тип операнда, который принимает JavaScript оператор Операция, которую выполняет JavaScript оператор Тип оператора JavaScript
Инкремент Справа налево JavaScript числа Увеличивает JavaScript переменную на единицу (инкрементирует) Унарный оператор JavaScript
Декремент Справа налево JavaScript числа Уменьшает JavaScript переменную на единицу (декрементирует) Унарный оператор JavaScript
Вычитание Слева направо JavaScript числа Вычитает из одного JavaScript операнда другой Бинарный оператор JavaScript
Сложение Слева направо JavaScript числа Складывает два JavaScript операнда. Бинарный оператор JavaScript
Унарный минус Справа налево JavaScript числа Меняет знак переменной или числа Унарный оператор JavaScript
Унарный Справа налево JavaScript числа Не выполняет никаких операций Унарный оператор JavaScript
Деление Слева направо JavaScript числа Делит по модулю JavaScript переменные и числа Бинарный оператор JavaScript
Деление Слева направо JavaScript числа Делит JavaScript переменные и числа Бинарный оператор JavaScript
Умножение Слева направо JavaScript числа Перемножает JavaScript переменные и числа Бинарный оператор JavaScript

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

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

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

JavaScript

, как и в любом другом языке программирования, например PHP, выполняют операции булевой алгебры. Обычно, логические операторы используют совместно с операторами сравнения и JavaScript инструкциями циклов (while, for) или инструкцией условием if. В JavaScript всего три логических оператора: логическое И(&&), логическое НЕ(!) и логическое .

Логические операторы JavaScript
JavaScript оператор Ассоциативность оператора JavaScript Тип операнда, который принимает JavaScript оператор Операция, которую выполняет JavaScript оператор Тип оператора JavaScript
Логическое И(&&) JavaScript Слева направо Логические значения JavaScript (Значения логической истинности) Логическое И (похоже на сложение чисел) Бинарный оператор JavaScript
Логическое НЕ(!) JavaScript Справа налево Логические значения JavaScript (Значения логической истинности) Логическое отрицание (похоже на смену знака числа) Унарный оператор JavaScript
Логическое JavaScript Слева направо Логические значения JavaScript (Значения логической истинности) Логическое ИЛИ (похоже на перемножение чисел) Бинарный оператор JavaScript

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

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

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

JavaScript

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

Строковые операторы JavaScript.
JavaScript оператор Ассоциативность оператора JavaScript Тип операнда, который принимает JavaScript оператор Операция, которую выполняет JavaScript оператор Тип оператора JavaScript
КонкатенацияJavaScript (+) Слева направо Строки JavaScript Конкатенация строк JavaScript Бинарный оператор JavaScript
Больше чемJavaScript > Слева направо Строки JavaScript Больше чем (результатом такой операции будет логическое значение) Бинарный оператор JavaScript
Меньше чемJavaScript < Слева направо Строки JavaScript Меньше чем (результатом такой операции будет логическое значение) Бинарный оператор JavaScript
Меньше или равно JavaScript<= Слева направо Строки JavaScript Меньше или равно (результатом такой операции будет логическое значение) Бинарный оператор JavaScript
Больше или равно JavaScript>= Слева направо Строки JavaScript Больше или равно(результатом такой операции будет логическое значение) Бинарный оператор JavaScript

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

Операторы равенства JavaScript, неравенства JavaScript, неидентичности JavaScript, идентичности JavaScript.

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

JavaScript

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

Операторы равенства JavaScript, неравенства JavaScript, неидентичности JavaScript, идентичности JavaScript.
JavaScript оператор Ассоциативность оператора JavaScript Тип операнда, который принимает JavaScript оператор Операция, которую выполняет JavaScript оператор Тип оператора JavaScript
Проверка равенства JavaScript== Слева направо Любой JavaScript операнд Проверяет на равенство два выражения Бинарный оператор JavaScript
Проверка идентичности JavaScript=== Слева направо Любой JavaScript операнд Проверяет на идентичность два выражения Бинарный оператор JavaScript
Проверка неравенства JavaScript!= Слева направо Любой JavaScript операнд Проверяет на неравенство два выражения Бинарный оператор JavaScript
Проверка неидентичности JavaScript!== Слева направо Любой JavaScript операнд Проверяет на неидентичность два выражения Бинарный оператор JavaScript

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

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

Операторы отношения

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

JavaScript

– это операторы, которые что-то с чем-то сравнивают, но если операторы сравнения работают с простыми типами данных, то операторы отношения работают с объектными типами данных: JavaScript массивы, JavaScript объекты, JavaScript функции и т.д... Результатом выполнения этих операторов будут значения логической истинности true или false.

Операторы отношения JavaScript. Операторы сравнения JavaScript.
JavaScript оператор Ассоциативность оператора JavaScript Тип операнда, который принимает JavaScript оператор Операция, которую выполняет JavaScript оператор Тип оператора JavaScript
Больше чемJavaScript > Слева направо Числа или строки JavaScript Больше чем (результатом такой операции будет логическое значение) Бинарный оператор JavaScript
Меньше чемJavaScript < Слева направо Числа или строки JavaScript Меньше чем (результатом такой операции будет логическое значение) Бинарный оператор JavaScript
Меньше или равно JavaScript<= Слева направо Числа или строки JavaScript Меньше или равно (результатом такой операции будет логическое значение) Бинарный оператор JavaScript
Больше или равно JavaScript>= Слева направо Числа или строки JavaScript Больше или равно(результатом такой операции будет логическое значение) Бинарный оператор JavaScript
Проверка типа объекта JavaScript instanceof Слева направо JavaScript объект, JavaScript конструктор Проверка типа объекта (результатом такой операции будет логическое значение) Бинарный оператор JavaScript
Проверка наличия свойства JavaScript in Слева направо Строки, объекты Проверка на наличие свойства (результатом такой операции будет логическое значение) Бинарный оператор JavaScript

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

Поразрядные операторы JavaScript.

Поразрядные операторы  

JavaScript

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

Поразрядные операторы JavaScript.
JavaScript оператор Ассоциативность оператора JavaScript Тип операнда, который принимает JavaScript оператор Операция, которую выполняет JavaScript оператор Тип оператора JavaScript
Поразрядное И JavaScript (&) Слева направо Целые числа JavaScript Поразрядное и (выполняется над каждым битом в отдельности) Бинарный оператор JavaScript
Поразрядное ИЛИ JavaScript Слева направо Целые числа JavaScript Поразрядное или (выполняется над каждым битом в отдельности) Бинарный оператор JavaScript
Поразрядное исключающее ИЛИ JavaScript (^) Слева направо Целые числа JavaScript Поразрядное исключающее или (выполняется над каждым битом в отдельности) Бинарный оператор JavaScript
Поразрядное НЕ JavaScript (~) Слева направо Целые числа JavaScript Поразрядное исключающее не (выполняется над каждым битом в отдельности) Бинарный оператор JavaScript
Сдвиг влево JavaScript ( ) Слева направо Целые числа JavaScript Сдвигает биты влево Бинарный оператор JavaScript
Сдвиг вправо с сохранением знака JavaScript ( ) Слева направо Целые числа JavaScript Сдвигает биты вправо и при этом сохраняет знак числа Бинарный оператор JavaScript
Сдвиг вправо с заполнением нулями JavaScript ( ) Слева направо Целые числа JavaScript Сдвигает биты вправо, а свободные биты заполняет нулями Бинарный оператор JavaScript

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

Операторы присваивания JavaScript. Операторы присваивания с операцией.

– это операторы, которые можно было бы отнести к арифметическим. Оператор присваивания всего один «=». Не стоит путать оператор присваивания с операторами равенства. Оператор присваивания служит для присваивания какого-либо значения переменной. Оператор присваивания не возвращает никакого результата он лишь указывает интерпретатору, что нужно сохранить в той или иной переменной JavaScript. Переменная – это именованное место памяти.

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

Операторы присваивания JavaScript. Операторы присваивания с операцией.
JavaScript оператор Ассоциативность оператора JavaScript Тип операнда, который принимает JavaScript оператор Операция, которую выполняет JavaScript оператор Тип оператора JavaScript
= Справа налево Любые типы данных JavaScript Присваивает значение переменной Бинарный оператор JavaScript
= Справа налево Числа JavaScript и строки JavaScript Присваивает значение переменной и увеличивает его на соответствующее значение Бинарный оператор JavaScript
= Справа налево Все числа JavaScript Присваивает значение переменной и умножает его на соответствующее значение Бинарный оператор JavaScript
= Справа налево Все числа JavaScript Присваивает значение переменной и уменьшает его на соответствующее значение Бинарный оператор JavaScript
= Справа налево Все числа JavaScript Присваивает значение переменной и выполняет деление по модулю на соответствующее значение Бинарный оператор JavaScript
Справа налево Все числа JavaScript Присваивает значение переменной и делит его на соответствующее значение Бинарный оператор JavaScript
= Справа налево Целые числа JavaScript Присваивает значение переменной и выполняет операцию поразрядного сдвига битов вправо с заполнением нулями Бинарный оператор JavaScript
= Справа налево Целые числа JavaScript Присваивает значение переменной и выполняет операцию поразрядного сдвига битов вправо с сохранением знака Бинарный оператор JavaScript
= Справа налево Целые числа JavaScript Присваивает значение переменной и выполняет операцию поразрядного сдвига битов влево Бинарный оператор JavaScript
= Справа налево Целые числа JavaScript Присваивает значение переменной и выполняет операцию поразрядное исключающее ИЛИ Бинарный оператор JavaScript
Справа налево Целые числа JavaScript Присваивает значение переменной и выполняет операцию поразрядное ИЛИ Бинарный оператор JavaScript
&= Справа налево Целые числа JavaScript Присваивает значение переменной и выполняет операцию поразрядное И Бинарный оператор JavaScript

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

и операторы присваивания с операцией являются бинарными операторами, все без исключения, их ассоциативность всегда справа налево, это обусловлено символом «=». Оператор присваивания может работать с любыми JavaScript операндами: объекты, функции, массивы, числа, строки, логические значения, значение null, значение undefined, регулярные выражения JavaScript и т.д.

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

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

JavaScript операторы. Другие операторы JavaScript.

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

– это единственный тернарный оператор JavaScript, его еще называют тернарный оператор JavaScript. Тернарный он потому, что для его работы требуется три операнда. Результатом работы тернарного оператора будет значение логической истинности true или false. Условный оператор обычно используют вместо инструкции if, инструкции условия, иногда это оказывается удобным сокращением.

Оператор создания объекта JavaScript (new)

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

Оператор

delete

JavaScript

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

Оператор

typeof

JavaScript

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

Запятая JavaScript. Запятая – это тоже JavaScript оператор, причем оператор запятая является бинарным JavaScript оператором, оператор запятая всегда возвращает значение своего правого операнда.

Оператор

void

JavaScript

– оператор void является унарным оператором. Оператор void довольно необычный, все дело в том, что оператор void заменяет значение любой JavaScript переменной на значение undefined.

Оператор JavaScript

 — это символ, набор символов или ключевое слово JavaScript (зарезервированное слово JavaScript), за которым закреплено строго определенное действие согласно лексической структуре языка JavaScript.

При помощи JavaScript операторов можно выполнять преобразование строка в число и число в строку JavaScript.

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

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

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

8 + 4;  // 12 (результат сложения)8 - 4;  // 4  (результат вычитания)8 * 4;  // 32 (результат умножения)8 / 4;  // 2  (результат деления)8 % 4;  // 0  (результат вычисления остатка от деления)2 ** 3; // 8  (результат возведения числа 2 в степень 3)++7;    // 8  (увеличение числа 7 на 1)--8;    // 7  (уменьшение числа 8 на 1)

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

5 – 15;      // -10 (1 пример)'5' - '15';  // -10 (2 пример)

JavaScript – это язык с динамическим приведением типов.

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

Ещё один пример с использованием оператора

5 - 'px'; // NaN

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

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

5 + 'px';  // "5px"

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

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

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

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


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

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

5 + (-10); //-5;-(-15);    // 15-'5';      // -5-'5px';    // NaN

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


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

100 % 3; // 1

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

JavaScript - Использование оператора процент  как вычисляется остаток от деления

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

Оператор равно (= используется для присвоения (установления) левому операнду (переменной) значение правого операнда.

num = 33;     // присвоим переменной num число 33num1 = num2;  // присвоим переменной num1 значение переменной num2

В JavaScript имеются ещё составные операторы присваивания: = = = , = = = = = &= = Данные операторы выполняют перед присваиванием ещё одну операцию.

Эти операторы являются просто сокращёнием следующей записи:

operand1 = operand1 operator operand2;// эта запись имеет тот же смысл что и верхняяoperand1 operator= operand2;
var x = 7;x += 8;   // 15x += '3'; // "153"x -= 30;  // 123x **= 2;  // 15129

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

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

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

 СРАВНЕНИЕ ЧИСЕЛ5 > 10;        // false5 === 2 + 3;   // true7 < 2 * 3;     // false4 <= 4;        // true+0 === -0;     // true// СРАВНЕНИЕ БУЛЕВЫХ ЗНАЧЕНИЙtrue > false;  // truetrue == false; // false// РАВЕНСТВО null и undefinednull == undefined; // true (особенность языка)

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

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

 ПРИМЕР 1// 51 - код символа '3' // '3'.charCodeAt(0)// 50 - код символа '2' // '2'.charCodeAt(0)'3' > '25'; // true, т.к. 51 > 50// ПРИМЕР 2// 1080 - код символа 'и' // 'и'.charCodeAt(0)// 1090 - код символа 'т' // 'т'.charCodeAt(0)'символ' > 'строка'; // false, т.к. 1080 не больше 1090// ПРИМЕР 3'домик' > 'дом'; // true, т.к. у него больше символов

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

 1044 - код символа 'Д' // 'Д'.charCodeAt(0)// 1076 - код символа 'д' // 'д'.charCodeAt(0)'Дом' === 'дом'; // false, т.к. 'Д' не равно 'д''Дом'.toLowerCase() === 'дом'.toLowerCase(); // true

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

var  obj1 = {    num: 3  },  obj2 = {    num: 3  },  obj3 = obj1;  obj1 == obj2;   // false, т.к. переменные имеют разные ссылкиobj1 == obj3;   // true, т.к. переменные ссылаются на один и тотже объектobj1 === obj3;  // true, т.к. переменные ссылаются на один и тотже объект

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

Если операнды имеют примитивный тип данных то они приводится при операции сравнения к числу

'2' == 2;    // true, т.к. строка '2' будет приведена к числу 2true != 0;   // true, т.к. true будет приведено к 1false == 0;  // true, т.к. false == true'' > -5;     // true, т.к. пустая строка будет приведена к 0'' == false; // true, т.к. пустая строка будет приведена к 0 и false тоже к 0'5px' == 5;  // false, т.к. строка '5px' будет приведена к NaN

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


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

2 === '2';  // false, т.к. тип данных разныйtrue === 1; // false, т.к. тип данных разный

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

Для выполнения операций со строками в JavaScript нет никаких специальных операторов

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

"одна строка " + "другая строка"; // "одна строка другая строка" (использование оператора + для сложения строк)7 + 8; // 15 (использование оператора + для сложения чисел)+"7"; // 7 (использование оператора + для приведения строки к числу)

Для сравнения строк используются операторы строго равенства (===), больше (>), меньше (<) и др. Т.е. точно такие же операторы которые используются для сравнения чисел, объектов и других типов данных.

var str = "некоторый текст";str === "некоторый текст"; // true

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

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

Представление числа в двоичной системе осуществляется посредством 32 битов.

 5  => 0000 0000 0000 0000 0000 0000 0000 0101// 10 => 0000 0000 0000 0000 0000 0000 0000 1010

В JavaScript имеются следующие побитовые операторы: &побитовое И), побитовое ИЛИ), побитовое НЕ), исключающее ИЛИ), сдвиг влево), сдвиг вправо), сдвиг вправо с заполнением нулями).

Пример с использованием оператора &

 ПРИМЕР 15 & 10; // 0// 5      => ... 0000 0101// 10     => ... 0000 1010// 5 & 10 => ... 0000 0000// 02 = 010 ПРИМЕР 25 & 7; // 5// 5      => ... 0000 0101// 7      => ... 0000 0111// 5 & 7  => ... 0000 0101// 1012 = 510 выполнение логической операции «И» осуществляется для каждой пары битов, находящихся на одинаковых позициях в двоичных представлениях операндов// логическое "И" работает так: 0 & 0 = 0, 1 & 0 = 0, 0 & 1 = 0, 1 & 1 = 1.

Пример с использованием оператора

 ПРИМЕР 15  10; // 15// 5      => ... 0000 0101// 10     => ... 0000 1010// 5  10 => ... 0000 1111// 11112 = 1510 ПРИМЕР 25  4; // 5// 5      => ... 0000 0101// 4      => ... 0000 0100// 5  4  => ... 0000 0101// 1012 = 510 выполнение логической операции «ИЛИ» осуществляется для каждой пары битов, находящихся на одинаковых позициях в двоичных представлениях операндов// логическое "ИЛИ" работает так: 0  0 = 0, 1  0 = 1, 0  1 = 1, 1  1 = 1.

Примеры с использованием оператора

 ПРИМЕР 15 ^ 7; // 2// 5      => ... 0000 0101// 7      => ... 0000 0111// 5 ^ 7  => ... 0000 0010// 102 = 210 ПРИМЕР 25 ^ 4; // 1// 5      => ... 0000 0101// 4      => ... 0000 0100// 5 ^ 4  => ... 0000 0001// 12 = 110 выполнение логической операции «исключающее ИЛИ» осуществляется для каждой пары битов, находящихся на одинаковых позициях в двоичных представлениях операндов// исключающее "ИЛИ" работает так: 0 ^ 0 = 0, 1 ^ 0 = 1, 0 ^ 1 = 1, 1 ^ 1 = 0.

Пример с использованием оператора

 ПРИМЕР 1~5; // -6// 5       => 0000 0000 0000 0000 0000 0000 0000 0101// ~5 (-6) => 1111 1111 1111 1111 1111 1111 1111 1010// выполнение логической операции «НЕ» осуществляется для каждого бита двоичного представления операнда (число 0 заменяется на 1, а 1 на 0).

Пример с использованием оператора

 ПРИМЕР 15   3; // 40// 5      => 0000 0000 0000 0000 0000 0000 0000 0101// 5   3 => 0000 0000 0000 0000 0000 0000 0010 1000// 1010002 = 4010 operand1   operand2// оператор   сдвигает двоичное представление operand1 на количество битов, указанных посредством второго операнда operand2, добавляя нули справа.

Пример с использованием оператора

 ПРИМЕР 145   3; // 5// 45      => 0000 0000 0000 0000 0000 0000 0010 1101// 45   3 => 0000 0000 0000 0000 0000 0000 0000 0101// 1012 = 510 operand1   operand2// оператор   сдвигает двоичное представление operand1 на количество битов, указанных посредством второго операнда operand2; лишние биты, сдвинутые вправо, отбрасываются.

Пример с использованием оператора

 ПРИМЕР 1-30   3; // 536870908// -30       => 1111 1111 1111 1111 1111 1111 1110 0010// -30   3 => 0001 1111 1111 1111 1111 1111 1111 1100 // 111111111111111111111111111002 = 53687090810 operand1   operand2// оператор   сдвигает двоичное представление operand1 на количество битов, указанных посредством второго операнда operand2; лишние биты, сдвинутые вправо, отбрасываются; число слево дополняется нулевыми битами.

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

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

Таблица, содержащая операторы и их приоритет.

Операторы Порядок Приоритет
группировка) не определено 1
доступ к свойствам и методам объекта) доступ к элементам) слева направо 2
newсоздание объекта со списком аргументов) не определено
вызов функции, метода) слева направо 3
newсоздание объекта без списка аргументов) справа налево
постфиксный инкремент), постфиксный декремент) не определено 4
логическое отрицание), побитовое отрицание), унарный плюс), унарный минус), префиксный инкремент), префиксный декремент), typeof void delete справа налево 5
возведение в степень) справа налево 6
умножение), деление), остаток от деления) слева направо 7
сложение), вычитание) слева направо 8
сдвиг влево), сдвиг вправо), сдвиг вправо с заполнением нулями) слева направо 9
<меньше), <=меньше или равно), >больше), >=больше или равно), in instanceof слева направо 10
==равенство), =не равенство), ===строгое равенство), ==строгое не равенство) слева направо 11
&побитовое И) слева направо 12
побитовое исключающее ИЛИ) слева направо 13
побитовое ИЛИ) слева направо 14
&&логическое И) слева направо 15
логическое ИЛИ) слева направо 16
условный оператор) справа налево 17
=присваивание), = = = , = = = = = &= = справа налево 18
yield yield* справа налево 19
...расширение) неопределено 20
запятая) слева направо 21

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

Последние новости:  Кто будет грозить России с юга?
Оцените статью
( Пока оценок нет )

Андрей Шутько, журналист и репортер Anticwar.ru. Об армии он пишет более 15 лет. Несколько раз он был военным корреспондентом в Афганистане.

andreyshutko7@gmail.com