Rivalry2

HTML Diff

0 added 0 removed

Original 2026-01-01

Modified 2026-02-21

1 <a>#статьи</a>

2 <ul><li>17 июл 2025</li>

3 <li>0</li>

4 </ul>Что делает =, чем === отличается от == и зачем нужен typeof, - всё про операторы JS.

5 Иллюстрация: Оля Ежак для Skillbox Media

6 Онлайн-журнал для тех, кто влюблён в код и информационные технологии. Пишем для айтишников и об айтишниках.

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

8 Содержание

9 <ul><li><a>Что такое оператор в JavaScript</a></li>

10 <li><a>Работа с данными: как изменять и вычислять значения</a></li>

11 <li><a>Сравнение и выбор: операторы для принятия решений в коде</a></li>

12 <li><a>Логические операции: связываем условия между собой</a></li>

13 <li><a>Оператор запятая: выполняем сразу несколько выражений</a></li>

14 <li><a>Приоритеты операторов в JavaScript</a></li>

15 <li><a>Ошибки при работе с операторами в JavaScript</a></li>

16 <li><a>Частые вопросы на собеседованиях</a></li>

17 </ul>Операторы - это действия, которые JavaScript выполняет с данными. С их помощью можно сложить числа, сравнить значения, присвоить переменной новое значение, проверить условие - и многое другое. Без операторов код был бы просто текстом: ничего бы не делал.

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

19 let x = 5 + 3;Здесь два оператора:

20 <ul><li>= - оператор присваивания: кладёт результат в переменную x;</li>

21 <li>+ - арифметический оператор: складывает 5 и 3.</li>

22 </ul>В итоге x получит значение 8.

23 Операторы работают с операндами - это значения, над которыми совершается действие. Операндом может быть:

24 <ul><li>число - 1, 2, 42;</li>

25 <li>строка - "hello";</li>

26 <li>логическое значение - true или false;</li>

27 <li>переменная - x, userName, isActive;</li>

28 <li>выражение - например, 2 + 2 или Math.random().</li>

29 </ul>Если у оператора два операнда (например, 5 + 3), это бинарный оператор. Если один - унарный (+a, !isAdmin).

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

31 Разберём основные из них: арифметические, унарные, операторы присваивания, инкремент и декремент.

32 Арифметические операторы нужны для того, чтобы выполнять обычные математические действия: сложение, вычитание, деление, умножение и другие. Они работают с двумя значениями, например 5 + 7, это называется бинарной операцией.

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

34 <ul><li>+ - сложение;</li>

35 <li>- - вычитание;</li>

36 <li>* - умножение;</li>

37 <li>/ - деление;</li>

38 <li>% - остаток от деления;</li>

39 <li>** - возведение в степень.</li>

40 </ul>let a = 5; let b = 7; console.log(a + b); // 12 - сложение console.log(a - b); // -2 - вычитание console.log(a * b); // 35 - умножение console.log(a / b); // 0.714... - деление console.log(a % b); // 5 - остаток от деления console.log(a ** b); // 78125 - возведение в степеньЧтобы сохранить значение в переменную, нужен оператор присваивания - =. Он работает просто: берёт значение справа и кладёт его в переменную слева.

41 let a = 10; console.log(a);В переменную a положили число 10, и теперь мы можем использовать его в любом месте кода. Если нужно обновить значение, снова используем =:

42 a = 50;a = 50; console.log(a);В итоге переменная a теперь хранит значение 50.

43 Это и есть основная задача оператора присваивания - сохранить или заменить значение переменной.

44 Составные операторы - гибрид арифметических операторов и оператора присваивания. Они просто сокращают запись. Вместо x = x + 5 мы пишем x += 5, получается немного короче.

45 Вообще, составных операторов много, вот самые основные:

46 Оператор присваиванияЧто делаетКак пишетсяКакую конструкцию сокращает+=Прибавляетx += 5x = x + 5-=Вычитаетx -= 5x = x - 5*=Умножаетx *= 5x = x * 5/=Делитx /= 5x = x / 5%=Возвращает остаток от деленияx %= 5x = x % 5**=Возводит в степеньx **= 5x = x ** 5Инкремент и декремент - это унарные операторы, которые изменяют значение переменной на единицу.

47 <ul><li>++ - инкремент: увеличивает значение на 1.</li>

48 <li>-- - декремент: уменьшает значение на 1.</li>

49 </ul>Такие операторы часто используются в циклах, счётчиках шагов, в таймерах и при других пошаговых изменениях.

50 Инкремент и декремент имеют две формы: префиксную и постфиксную. Разберём по порядку, как они работают.

51 Если оператор записан перед переменной, это префиксная форма. Она сначала изменяет значение, а потом возвращает его.

52 // Объявляем переменные a и b: let a = 0; let b = 2; // 1. Сначала увеличиваем значение a на 1 // 2. Потом кладём новое значение в переменную b b = ++a; // Смотрим, что получилось console.log(a); // Вывод в консоль: 1 console.log(b); // Вывод в консоль: 1То же самое работает и для декремента - только значение уменьшается.

53 Если оператор записан после переменной, это постфиксная форма. Она сначала возвращает текущее значение, а потом изменяет его.

54 // Объявляем переменные a и b: let a = 2; let b = 0; // 1. Сначала кладём значение переменной a в переменную b // 2. Потом уменьшаем значениеьa на 1 b = a--; // Смотрим, что получилось console.log(a); // Вывод в консоль: 1 console.log(b); // Вывод в консоль: 2Унарные операторы в JavaScript - это операторы, которые работают только с одним значением и пишутся перед операндом. Есть два базовых унарных оператора:

55 <ul><li>+ (унарный плюс) - преобразует значение в число. Применяется для упрощения кода и быстрого преобразования типов данных, например строки в число.</li>

56 <li>- (унарный минус) - меняет знак числа (положительное число на отрицательное и, наоборот, - отрицательное на положительное). Применяется при математических расчётах.</li>

57 </ul>Смотрим, как работает унарный плюс:

58 // Строка "5" становится числом 5 console.log(+"5"); // 5 // Булево значение true становится 1 console.log(+true); // 1 // Значение null становится 0 console.log(+null); // 0 // Infinity - уже число console.log(+Infinity); // Infinity // Строка, не являющаяся числом, становится NaN console.log(+"Hello"); // NaNОбратите внимание: NaN - это специальное значение, которое означает "не число". Оно появляется, когда преобразование выполнить невозможно.

59 Всё то же самое, но с унарным минусом:

60 // Строка "5" сначала становится 5, затем меняется знак console.log(-"5"); // -5 // true → 1 → -1 console.log(-true); // -1 // null → 0 → -0 console.log(-null); // -0 // Infinity → -Infinity console.log(-Infinity); // -Infinity // Строка, не являющаяся числом → NaN console.log(-"Hello"); // NaNНа практике -0 ведёт себя почти так же, как 0, но технически это разные значения: это важно в редких случаях - например, при работе с математикой низкого уровня или при сравнении с бесконечностью (Infinity).

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

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

63 Вот список операторов сравнения:

64 <ul><li>== - сравнивает значения, приводит типы автоматически;</li>

65 <li>=== - сравнивает значения и типы без преобразования;</li>

66 <li>!= - сравнивает два значения и возвращает true, если они разные (с приведением типов);</li>

67 <li>!== - сравнивает значения и их типы и возвращает true, если они разные (строго);</li>

68 <li>> - больше чем;</li>

69 <li>>= - больше чем или равно;</li>

70 <li>< - меньше чем;</li>

71 <li><= - меньше чем или равно.</li>

72 </ul>В JavaScript можно сравнивать значения разных типов:

73 <ul><li>Числа - обычные, целые, десятичные, положительные и отрицательные.</li>

74 <li>Строки - JavaScript сравнивает их по буквам, как в словаре.</li>

75 </ul><ul><li>Логические значения(true и false) - они преобразуются в числа: true = 1, false = 0.</li>

76 </ul><ul><li>Значения из форм - обычно приходят как строки, даже если выглядят как числа.</li>

77 <li>null и undefined - ведут себя особо (о них чуть позже).</li>

78 </ul>console.log(10 > 5); // true - сравниваются числа console.log("apple" < "banana"); // true - сравниваются строки по алфавиту console.log(true > false); // true - true → 1, false → 0 console.log(null >= 0); // true - null → 0 console.log(undefined < 10); // false - undefined → NaN, сравнение с NaN = false console.log("7" > 3); // true - строка "7" → число 7Можно даже сравнивать значения разных типов друг с другом - JavaScript не запрещает этого. Если типы данных разные, JavaScript пытается привести их к одному типу, обычно к числу. Это происходит автоматически, но результат может быть неожиданным.

79 Вот как это работает:

80 <ul><li>строка "5" становится числом 5;</li>

81 <li>true превращается в 1, false - в 0;</li>

82 <li>null - почти всегда превращается в 0;</li>

83 <li>undefined - становится NaN, а любое сравнение с NaN всегда даёт false;</li>

84 <li>строки между собой сравниваются по символам - лексикографически.</li>

85 </ul>console.log(10 > 5); // true - числа console.log("7" < 10); // true - строка "7" превращается в число console.log(true >= 1); // true - true → 1 console.log(false <= 0); // true - false → 0 console.log(null < 1); // true - null → 0 console.log(undefined > 0); // false - undefined → NaN console.log("apple" < "banana"); // true - строки сравниваются по буквамПриводите данные к одному типу вручную, если не хотите, чтобы программа сама решила, как их сравнивать.

86 В JavaScript есть два похожих оператора сравнения:

87 <ul><li>== - сравнение по значению, с автоматическим приведением типов.</li>

88 <li>=== - сравнение и по значению, и по типу (его называют строгим сравнением).</li>

89 </ul>Когда вы используете ==, JavaScript пытается привести разные типы к одному. Это может дать неожиданный результат - например, строка "0" и число 0 вдруг окажутся равны.

90 Оператор == сравнивает число и строку:

91 console.log(0 == "0"); // trueОператор привёл значения к одному типу и сравнил. Получилось, что 0 равен 0. С точки зрения JavaScript всё в порядке.

92 Тот же пример с ===:

93 console.log(0 === "0"); // falseА здесь число не равно строке.

94 Если не хотите непредсказуемой самодеятельности JavaScript, используйте строгое сравнение ===, оно надёжнее.

95 Иногда нужно понять, что за данные перед нами - число, строка, объект или что-то ещё. Для этого в JavaScript есть специальный оператор typeof.

96 Он проверяет значение и возвращает, что это за тип: number, string, boolean, object, function и так далее.

97 console.log(typeof 42); // 'number' - число console.log(typeof "42"); // 'string' - строка console.log(typeof true); // 'boolean' - логическое значение console.log(typeof undefined); // 'undefined' - значение не задано console.log(typeof null); // 'object' - такой результат - особенность JavaScript console.log(typeof {}); // 'object' - обычный объект console.log(typeof []); // 'object' - массив тоже объект console.log(typeof function(){}); // 'function' - функцияС помощью typeof удобно отлавливать ошибки в данных или писать универсальный код, который подстраивается под тип значений.

98 Тернарный оператор ? : запускает один или другой блок кода в зависимости от условия.

99 Условие - это вопрос, на который JavaScript может ответить true или false.

100 <ul><li>5 > 2 - да, это правда;</li>

101 <li>10 === 7 - нет, это ложь.</li>

102 </ul>Общий вид:

103 условие ? значение_если_да : значение_если_нет;Если условие истинно, срабатывает первая часть. Если оно ложно, срабатывает вторая.

104 let num = 100; // Создаём переменную num и кладём в неё число 100 // Проверяем: num больше или равна 0? // Если true, результат будет "A" // Если false, результат будет "B" let result = num >= 0 ? "A" : "B"; // Выводим результат в консоль console.log(result); // AЛогические операторы помогают принимать решения в коде. Они проверяют условия и возвращают результат - true или false. Всего таких операторов три: && (И), || (ИЛИ) и ! (НЕ).

105 Логический оператор && (И) действует как умножение, где ложь - это 0, а истина - это 1. Он возвращает true, только если оба условия - истина.

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

107 console.log(false && true); // false console.log(1 > 0 && 5 < 3); // false - первое условие true, второе false console.log(false && console.log("Я не выполнюсь")); // false - второе даже не запустится console.log(true && console.log("Я выполнюсь!")); // true - выполнится вторая частьЛогический оператор || работает как сложение, только логическое. Оператор возвращает true, если хотя бы одно из условий - истина. Если первое условие - уже true, второе даже не проверяется.

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

109 console.log(false || true); // true console.log(0 == 5 || true); // true - первое условие false, но второе true console.log(true || console.log("Я не выполнюсь!")); // true - вторая часть не выполнится console.log(false || console.log("Я выполнюсь!")); // Я выполнюсь! - сработает вторая частьОператор ! меняет значение на противоположное: true становится false, false - true.

110 Пример:

111 // НЕ ложь = истина console.log(!false); // Вывод в консоль: true // НЕ истина = ложь console.log(!true); // Вывод в консоль: falseЭтот оператор используют, чтобы проверить обратное условие. Например, если у нас есть переменная isAdmin и она содержит true, то !isAdmin вернёт false. Это можно использовать в ситуациях, когда код нужно выполнить только в случае, если пользователь не админ:

112 if (!isAdmin) { console.log("Доступ запрещён"); }Такая конструкция читается как "если пользователь не админ, показать сообщение".

113 Оператор запятая (,) позволяет выполнить несколько выражений сразу в одной строке. Это редкий оператор, но иногда он бывает полезен.

114 Это удобно, когда нужно компактно записать несколько действий - особенно в циклах или при инициализации переменных.

115 let x = (1, 2, 3); console.log(x); // 3В скобках выполняются все три выражения: 1, 2, 3. Но в переменную x попадёт только последнее - 3.

116 То же самое можно сделать с двумя переменными:

117 let a, b; a = (b = 10, b + 5); console.log(a, b); // 15 10Что происходит:

118 <ul><li>b = 10 - в переменную b записали число 10.</li>

119 <li>b + 5 - посчитали сумму: 10 + 5 = 15.</li>

120 <li>Всё выражение справа от = вернуло 15, и это значение записали в a.</li>

121 </ul>Чаще всего оператор запятая встречается в циклах, где нужно управлять сразу несколькими переменными:

122 // В цикле for два счётчика - i и j через запятую for (let i = 0, j = 10; i < 5; i++, j--) { console.log(i, j); }Вывод:

123 0 10 1 9 2 8 3 7 4 6При такой записи удобно одновременно увеличивать один счётчик (i++) и уменьшать другой (j--). Всё это происходит в одной строке - благодаря оператору запятая.

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

125 В таблице приведена важность операторов от самого высокого (1) до самого низкого приоритета (17).

126 ПриоритетОператорОписание1x++, x--Постфиксный инкремент/декремент2++x, --xПрефиксный инкремент/декремент3!, ~, +, -, typeofУнарные операторы, оператор приведения типа4**Возведение в степень5*, /, %Умножение, деление, деление с остатком6+, -Сложение, вычитание7<<, >>, >>>Побитовые сдвиги - это редкий оператор, не описанный в статье8<, <=, >, >=Сравнения9==, !=, ===, !==Равенство10&Побитовое И (AND) - это редкий оператор, не описанный в статье11^Побитовое исключающее ИЛИ (XOR) - это редкий оператор, не описанный в статье12|Побитовое ИЛИ - это редкий оператор, не описанный в статье13&&Логическое И14||Логическое ИЛИ15? :Тернарный оператор16=, +=, -=, *=, /=, %=, **=, <<=, >>=, >>>=, &=, ^=, |=Операторы присваивания17,Операторы присваиванияПример c арифметическими операторами и сравнение:

127 // Объявляем три переменные a, b, c let a = 5; let b = 10; let c = 20; // Расчёт выражения // Сначала выполнится деление: c / 2 = 20 / 2 = 10 // Далее выполнится сложение: a + b = 5 + 10 = 15 // И в конце сравнение получившихся результатов: 15 > 10 = Истина (true) let result = a + b > c / 2; console.log(result); // Вывод в консоль: trueОператоры выполняются в математическом порядке. Сначала деление, потом сложение и в конце сравнение.

128 Пример c логическими операторами:

129 // Объявляем три переменные x, y, z let x = true; let y = false; let z = true; // Расчёт выражения // Сначала выполнится логическое умножение y && z = false && true = false (ложь) // Далее: x || false = true || false = true (Истина) let result = x || y && z; console.log(result); // Вывод в консоль: trueЛогические операторы выполняются также по математическим законам: сначала логическое умножение, затем логическое сложение и так далее в соответствии с таблицей.

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

131 // Строка превращается в число, console.log("5" - 1); // Вывод в консоль (Тип данных Числа): 4 // Число превращается в строку console.log("5" + 1); // Вывод в консоль (Тип данных Строка): 51Чтобы избежать таких ситуаций, лучше заранее проверять типы данных. Это можно сделать с помощью оператора typeof:

132 console.log(typeof "5"); // string console.log(typeof 5); // numberЕсли вы точно знаете, какой тип вам нужен, используйте явное преобразование:

133 // Преобразуем строку "5" в число console.log(Number("5") - 1); // 4 // Преобразуем число 5 в строку console.log(String(5) + "1"); // 51Новичкам в JavaScript бывает непросто сразу понять разницу между тремя равно: =, == и ===. Особенно трагично перепутать = и === : вместо того чтобы сравнивать значение, вы его перезаписываете.

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

135 // Объявляем переменную a let a = 0; // Ошибка. Здесь не сравнение, а присваивание if (a = 10) { console.log("Выполняется всегда"); // Вывод в консоль: Выполняется всегда } console.log(a); // Вывод в консоль: 10Просто запомните, что количество знаков равно в операторе имеет значение.

136 Все ответы на эти вопросы вы можете найти в статье.

137 1. В чём разница между операторами == и === и какой из них лучше использовать?

138 2. Что выведет код с оператором запятая (,) и для чего он нужен?

139 let x = (45, 78, 33, 11); console.log(x);3. Объясните разницу между префиксной и постфиксной формой инкремента и декремента.

140 console.log(3 % 10); console.log(-10 % 3);4. Какие операторы используются в этом коде и что они выведут?

141 let x = 85; let y = x > 75 ? "B" : "F"; console.log(y);<a>Научитесь: Профессия Фронтенд-разработчик + ИИ Узнать больше</a>