Базовые операторы в JavaScript.

Звучит сложно. Но на самом деле все просто. Так что это такое?  

Прежде всего это арифметические операторы:

• сложение +
• умножение * 
• вычитание —
• деление / 
• отрицательное число  -<имя переменной>

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

• взятие остатка от деления %
• возведение в степень  **

 

Взятие остатка: к процентам эта операция отношения не имеет. 

Если написать  a%b, то нам будет выдан остаток от целочисленного деления a на b.

Например:

console.log(7%5);  // Результат  2.  = 5*1 + 2 
console.log(9%4);  // Результат  1.  = 4*2 + 1
console.log(26%4);  // Результат 2   = 6*4 + 2

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

 

Возведение в степень: с возведением в степень все попроще: мы знакомы с этим действием со школы.  Просто запись не привычная: a ** b. То есть число a умножается само на себя b раз. Например:

console.log(3**2);  // 9 = 3*3;
console.log(2**3);  // 8 = 2*2*2;
console.log(5**2);  // 25 = 5*5

 

Этим же оператором можно возвести в дробную степень. Что то же самое что и извлечь корень из числа. Например квадратный корень это ½, кубический корень ⅓,  корень 4 степени ¼  итд. 

console.log(49**(1/2);  // 7
console.log(16**(1/4);  // 2
console.log(125**(1/3);  // 5

 

Соединение (или конкатенация строк) при помощи “+”

В языках программирования, в том числе и JS,  знак + еще применяется для переменных типа строка. + объединяет 2 и более строки в одну длинную строку. Обратим внимание, что если хотя бы один из слагаемых — строка, то сложение будет применено к типу строки. И число будет выведено как набор символов.  

Например:

console.log(“строка1 ” + ”строка2 ” + ”2020 ” + “еще одна строка.”);   
// “строка1 строка2 2020 еще одна строка.”

 

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

x = 4*2 + 2*3;

В такой конструкции сначала выполнятся арифметические операции — сложение, умножение, деление итд. Причем у умножения и деления выше приоритет, чем у сложения и вычитания. Вот таблица приоритетов:

 

Приоритет	Название	Обозначение
10	унарный плюс (служит для приведения строки к числу)
10	унарный минус(служит для превращения положительного числа в отрицательное)
9	возведение в степень	**
8	умножение	*
8	деление	/
7	сложение	+
7	вычитание	—
…	…	…
3	присваивание	=
…	…	….

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

 

Сокращенное присваивание.

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

let s = 0;
s = s + 5;  

То есть, если запустить такую сумму в цикле, мы получим числовую последовательность типа: 0, 5, 10, 15, 20, 25 итд.

В JavaScript есть синтаксис сокращенной записи.

let s = 0;

for (let i = 0; i <=7; i++){
   s += 5;
   console.log(“i = ” + i + “, s = ” +s);  // выведем в цикле значение каждой итерации цикла i и соответствующее ей значение s
}

Итак сокращенная запись:

• умножение с присваиванием:  а *= 4;
• деление с присваиванием: в /= 2;
• сложение с присваиванием:  с +=6;
• вычитание с присваиванием:  р -= 1;

Приоритет у таких операций такой же как и у простого присваивания: низкий. 

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

Визитной карточкой одного из универсальных языков программирования Cи++ являются два загадочных плюсика. Что они значат? 

Есть одна из частых и стандартных операций в цикле (счетчике итераций) приращение или уменьшение счетчика на 1. Выглядит это так: 

let i = 0; 
i = i+1;

Так вот, чтобы каждый раз не писать: i = i+1; в другом цикле i = i+1; еще в одном цикле ниже i = i+1; программисты придумали сокращенную запись

i++;

Все.

Такая операция называется инкремент.  То есть увеличение переменной на 1. 

Поэтому, возвращаясь к C++, мы можем понять тонкий намек, что это является следующим шагом, улучшением к языку программирования С.

i--;  //  декремент, уменьшение на 1

 

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

И опять нам многое знакомо, да и собственно, взято из математики. 

• Больше/меньше  x > y,  x < z.
• Больше или равно/меньше или равно  x >= y,  x <= z.
• Равно ли  f==g;  Не одинарный знак =, иначе получим просто присваивание. Для сравнения двух значений используется именно двойной знак ==
• Не равно.   d != f;   так и только так. 

В 1с например “не равно” будет записываться вот так: П <> Я

Жаль в JS нет знака ><   

Ну да ладно )))

 

Итак, результат сравнения всегда имеет логическое значение: истина/ложь   или да/нет.

• true — означает “истина”, “да”, “верно”, “правда”
• false — означает “ложь”, “нет”, “не верно”, “кривда”

Результат сравнения можно присвоить любой переменной:

let res = 10 > 5; // получим true

 

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

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

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

Здесь у нас возможны 3 варианта:  

• логическое И            ||
• логическое ИЛИ      &&
• логическое НЕ          !

Изначально работают эти операторы с булевым типом данных: true/false.  Но могут применяться к разным типам данных. Но об этом позже.

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

 

|| (ИЛИ)

Действие	Результат
true || true	true
false || true	true
true || false	true
false || false	false

 

Как видно, результат операции всегда равен true, если ХОТЯ БЫ ОДИН ИЗ операндов равен true.

И только если все равны false, то и результат false.

 

&& (И)

Этот оператор пишется как два амперсанда без пробелов. &&

Традиционно логическое И  возвращает true, если оба (или все) аргументы истинны. Иначе — false

Действие	Результат
true || true	true
false || true	false
true || false	false
false || false	false

! (НЕ)

Оператор НЕ записывается восклицательным знаком. Помните не равно?: !=

Синтаксис  прост:

res = !value;

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

• Сначала приводит аргумент к логическому типу true/false.
• Затем возвращает противоположное значение.

Таблица истинности такая:

Действие  res = !value;	Результат
true	false
false	true