• Оператор - служебный символ, необходимый для проведения операции, например, оператор + необходим для операции сложения.

• Операнд - то, к чему применяется оператор, например, в операции сложения 1 + 2 участвуют два оператора, левый равен 1, а правый 2.

Операторы делятся на унарные, бинарные и тернарный по следующим критериям:

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

• Бинарные операторы применяются к двум операндам.

• Тернарный оператор применяется к трем операндам.

JS поддерживает следующие математические операции:

• Сложение +,

• Вычитание -,

• Умножение *,

• Деление /,

• Взятие остатка от деления %,

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

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

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

JS позволяет складывать строки

let s = "медведь" + "сгорел";
alert(s); // медведьсгорел
//Если хотя бы один операнд является строкой, то второй будет автоматически преобразован в строку.
alert( '1' + 2 ); // "12"
alert( 2 + '1' ); // "21"
alert(2 + 2 + '1' ); // будет "41", а не "221"

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

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

Унарный плюс никак не меняет числа, но остальные типы данных приводятся к числу. Может быть использован как короткий аналог функции приведения к числу Number(value).

// Не влияет на числа
let x = 1;
alert( +x ); // 1

let y = -2;
alert( +y ); // -2

// Преобразует не числа в числа
alert( +true ); // 1
alert( +"" );   // 0

Важно!

Значения полей HTML-формы — это строки, поэтому для того, чтобы складывать значения и применяются унарный плюс и функция Number(value)

let apples = "2";
let oranges = "3";
alert( apples + oranges ); // "23"
alert( +apples + +oranges ); // 5
// что равнозначно 
// alert( Number(apples) + Number(oranges) ); // 5

Унарный минус - меняет значение числа на противоположное.

= оператор присваивания, возвращает присваиваемое значение

let x = 2 * 2 + 1;
alert( x ); // 5, сначала выполяются * и +, а затем =

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

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

Сокращенная арифметика

let n = 2;
n = n + 5;
n = n * 2;
alert(n); // 14

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

Инкремент и декремент нужны для увеличения или уменьшения значения переменный на 1:

• Инкремент ++ увеличивает переменную на 1

• Декремент -- уменьшает переменную на 1

let counter = 2;
counter++;        // равнозначно counter = counter + 1
alert( counter ); // 3

let counter = 2;
counter--;        // равнозначно  counter = counter - 1
alert( counter ); // 1

У декремента и инкремента существует две формы:

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

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

Обе эти инструкции делают одно и то же: увеличивают counter на 1. Разница между ними состоит в том, что префиксная форма возвращает новое значение, в то время как постфиксная форма возвращает старое (до увеличения/уменьшения числа).

• ND(и) ( & )

• OR(или) ( | )

• XOR(побитовое исключающее или) ( ^ )

• NOT(не) ( ~ )

• LEFT SHIFT(левый сдвиг) ( << )

• RIGHT SHIFT(правый сдвиг) ( >> )

• ZERO-FILL RIGHT SHIFT(правый сдвиг с заполнением нулями) ( >>> )

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

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

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

• Больше/меньше: a > b, a < b.

• Больше/меньше или равно: a >= b, a <= b.

• Равно: a == b. Обратите внимание, для сравнения используется двойной знак равенства ==. Один знак равенства a = b означал бы присваивание.

• Не равно: a != b.

Результат сравнения имеет логический тип!

alert( 2 > 1 );  // true (верно)
alert( 2 == 1 ); // false (неверно)
alert( 2 != 1 ); // true (верно)

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

alert( 'Я' > 'А' ); // true
alert( 'Коты' > 'Кода' ); // true
alert( 'Сонный' > 'Сон' ); // true

При сравнении значений разных типов JavaScript приводит каждое из них к числу.

alert( '2' > 1 ); // true, строка '2' становится числом 2
alert( '01' == 1 ); // true, строка '01' становится числом 1

Оператор строгого равенства === проверяет равенство без приведения типов.

Другими словами, если a и b имеют разные типы, то проверка a === b немедленно возвращает false без попытки их преобразования.

alert( 0 == false ); // true
// Равенство преобразует значения, используя числовое преобразование, поэтому "0" становится 0. В то время как явное преобразование с помощью Boolean использует другой набор правил.
alert( 0 === false ); // false, так как сравниваются разные типы

Ещё есть оператор строгого неравенства !==, аналогичный !=.

alert( null === undefined ); // false

alert( null == undefined ); // true

При использовании математических операторов и других операторов сравнения < > <= >=значения null/undefined преобразуются к числам: null становится 0, а undefined – NaN.

https://learn.javascript.ru/operators

https://learn.javascript.ru/comparison