Термины

Операнд или аргумент

Операнд или аргумент - то, к чему применяется оператор.

console.log(2 * 3) // 2 и 3 - это операнды. 

Унарный(Унарная операция)

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

let x = 3;
console.log(-x) // - 3

Бинарный(Бинарная операция)

Бинарный - так называется оператор, который применяется к двум операндам.

// обычное прибавление например.
let y = 2;
let x = 1;

console.log( y + x) // 3

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

Оператор присваивания выглядит как равно =.

let j = 1; // присвоили переменной j единицу!
console.log(j) // 1

Есть такое понятие как ассоциативность - оно определяет порядок выполнения операторов с одинаковым приоритетом. У оператора присваивания правая ассоциативность, что значит работать они будут справа налево. У разных операторов своя ассоциативность и свой приоритет выполнения, знать наизусть все не нужно, вся документация есть на MDN.

let k;
let h;
let b = 20;

let sum = k = h = b; // сначала мы в h присвоили b(20), далее в k присвоили h(20) и так по цепи.
console.log(sum); // поэтому в коносль выведет 20

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

let k,h,b,sum;
// тут более понятная запись присваивания по цепи.
b = 20;
h = b;
k = h;
sum = k;
console.log(sum); // 20

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

В javaScript есть составные операторы присваивания. Самые популярные: +=, -=, *=, /=, и тд. Эти операторы перед присваиванием выполняют еще другую операцию.
Например: += - присваивание со сложением. Складывает(прибавляет), а потом присваивает. Это нужно для сокращения подобной записи:

let a = 11;
let b = 10;

b = a + b; // здесь можно так же заметить приоритетность, сначала мы прибавляем, а потом присваиваем. плюс имеет больший приоритет чем присваивание.
console.log(b) // 21
// Теперь используем оператор +=
b += a;
console.log(b) // 21

Как же я ЛЮБЛЮ ОПЕРАТОРЫ вот они слева направо:

• Присваивание с вычитанием -=
• Присваивание с умножением *=
• Присваивание с делением /=
• Присваивание с делением с остатком %=
  

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

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

Операторы сравнения сравнивают два операнда и возвращают булевое значение. Если сравнение правдивое, то будет true в остальных случаях false.

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

Оператор равенста выглядит как два равно ==

console.log(2 * 5 == 10) // true
// приоритет умножения больше чем у равенства, поэтому сначала мы умножили и получилось 10, а потом мы сравниваем 10 с 10, и получаем true так как 10 это 10.

При сравнении значений разных типов JavaScript приводит каждое из них к числу.
Если это булевые значения то true = 1, false = 0

console.log(2 * 5 == '10') //  true
console.log(true == 1); // true
console.log(false == 0); // true

Строгое равенство выглядит как три равно === и сравнивает без приведения типов.

console.log(2 * 5 === '10'); // false
console.log(false === 0) // false

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

Оператор не равенства записывается как != и делает обратное равенству.

console.log(2 * 5 != 10); // false
// мы как бы спрашиваем 10 и 10 не равно друг другу? нет, они равны, поэтому мы получаем false. 
// при равенстве мы спрашиваем равны ли они, а здесь все наоборот, поэтому где при равентсве true, при не равенстве всегда будет false.

И так же строгое не равно !==

console.log(2 * 5 !== '10'); // true
// 10 не равно '10' - это правда поэтому получаем true

Операторы (больше) и (меньше) и операторы (больше или равно) и (меньше или равно)

Оператор больше > - возвращает true, если операнд слева больше операнда справа.

console.log(2 > 1); // true
console.log(1 > 2) // false
// два больше чем один? Да, поэтому получаем true и наоборот

Оператор меньше < - возвращает true, если операнд слева меньше операнда справа.

console.log(1 < 2); // true (1 меньше 2)
console.log(1 < 0); // false ( 1 не меньше 0)

Оператор больше или равно >= - возвращает true, если операнд слева больше или равен операнду справа.

console.log(2 >= 1); // true (2 больше 1)
console.log(2 >= 2); // true (2 равно 2)

Оператор меньше или равно <= - возвращает true, если операнд слева меньше или равен операнду справа

console.log(1 <= 1); // true (1 равен 1)
console.log(20 <= 2); // false (20 больше 2)

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

Оператор взятия остатка % - оставляет остаток после деления.

console.log(30 % 60); // остаток 0

Немного деления для маленьких(это я про себя).
Когда мы делим у нас есть делитель, делимое и частное.

console.log(154 / 50); // 154 - это делитель, 50 - это делимое, а то, что получится - 3.08 частное.

Обычное деление разбивает и делит все. 150 / 50 дают нам 3 целых, остаток в 4 тоже делится, 4 / 50 что дает нам 0.08. В итоге - 3.08. Взятие остатка, как раз этот остаток в 4 не делит, а возвращает нам.

console.log(154 % 50); // 4
// Остаток у нас так и будет приходить, пока мы не дойдем до 200,250,300 и так далее

console.log(199 % 50); // 49. 150 делится ровно на 3, а 49 нет, поэтому этот остаток нам возвращают.
console.log(200 % 50); // 0
console.log(201 % 50); // 1
console.log(202 % 50); // 2

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

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

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

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

Унарный плюс и минус
Унарный плюс приводит к числу не число.

console.log(5 + +'5'); // 10 (Используем бинарный плюс и унарный вместе)
console.log(+""); // 0
console.log(+true); // 1
let apples = "2";
console.log(+apples) // 2

Унарный минус преобразует положительное число в отрицательное

let z = 10;
console.log(-z) // -10

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

Инкремент выглядит как ++ и прибавляет 1.
Декримент выглядит как -- и отнимает 1.
Имеется постфиксная форма и префиксная форма.

let incr = 10;
let decr = 10;
      
//постфиксная форма: Сначала возвращает старое значение.
console.log(incr++); // вернет 10
console.log(decr--); // вернет 10
// но если мы теперь проверим переменные, то увидим новое значение.
console.log(incr); // 11
console.log(dect); // 9     
// Префиксная форма: Сразу возвращает новое значение.
console.log(++incr); // сразу вернет 12
console.log(--decr); // сразу вернет 8

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

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

Оператор И && - возвращает true, если оба аргумента правдивы, а иначе – false

const isCheck = true,
    isClose = true,
    isFalse = false;
console.log(isCheck && isClose); // true
console.log(isCheck && isClose && isFalse); // false

По сути это звучит так 'если и там и там true то мы делаем что-то'. Или можно сказать так 'И то и то должно быть верным'. У && есть небольшое правило связанное с возвратом значения:

console.log(2 && 1 && null && 0 && undefined); // false
// оператор слева на право проверяет 2 - true, 1 - true, далее null - false

Оператор всегда запинается на первом false и его взвращает.

Оператор ИЛИ || - Если есть хотя бы одно true, он вернет true,

const isOpen = true,
    isclosed = false;
    
console.log(isOpen || isclosed); // true
// мы как бы говорим: если есть хотя бы ЭТО или ЭТО и если есть одно из них, мы получаем true!

Тут тоже правило что и с && только запинается на первом true

console.log(0 || 3 || 0); // 3
Слева на право проверяет 0 - false, 3 - true и возвращает нам 3.

Оператор НЕ ! - меняет true на false и на оборот

console.log(!1); // false
console.log(!0); // true

Со всеми операторами в javaScript можно ознакомиться на MDN.