Что делает оператор в javascript

Операторы Javascript

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

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

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

Ниже описаны операторы, которые используются в JavaScript:

Оператор break

Оператор Прерывает текущий цикл for и while, передавая управление первому оператору после цикла.

Следующий пример добавляет элемент к форме в предположении,что все элементы содержат числовые значения. Если встречается значение «0», цикл прекращается.

function CheckValues(form) < var total for (I=0; Ielse < total +=I; document.write("Текущая строка: "+total);>> return total >

Оператор comment

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

Однострочные комментарии начинаются с символа (//).

Многострочные комментарии начинаются /* и заканчиваются */.

/*Начало комментария, а здесь комментарий заканчивается.*/ . строки кода. // Однострочный комментарий

Оператор continue

Передает управление оператору проверки истенности условия в цикле while и оператору обнавления значения счетчика в цикле for. Важное отличее от оператора break заключается в том, что оператор continue не прерывает цикл, а делает следующее.

В цикле while, это переходит назад к условию.

В цикле for, это переходит к модернизированному выражению.

Continue

Следующий пример демострирует цикл while, содержащий оператор continue, который выполняется, когда переменная i равна 3.

i = 0 n = 0 while (i

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

function CheckValues(form) < var total for (I=0; Ielse < total +=I; document.write("Текущая сумма: "+total);>> return total >

Оператор for

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

for (initialExpression;condition;updateExpression)

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

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

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

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

for (var i = 0; i

Следующий пример создает цикл for, продолжающийся до наступления ошибки или выполнения оператора break. Переменная счетчика увеличевается на при каждом проходе цикла:

for (var i = 0; ; i+=2)

Продемонстрируем пример,который представляет цикл, не обновляющий счетчик. Если счетчик нигде не будет обновлен в теле цикла, его значение так и останется равным 0:

for (var i = 0; i

Оператор for. in

Присваевает переменной поочередно все свойства объекта. Для каждого свойства цикл for. in выполняет операторы, содержащиеся в теле цикла:

for (var in obj)

Цикл for. in является полезным средством для отладки благодаря своей способности вывести на экран все свойства объекта в одном цикле.

fanction objectDisplay(obj) < var displayLine; for (var prop in obj) < displayLine =obj.name+"."+prop+"="+obj[prop]; document.write(displayLine+"") > document.write("End of object"+obj.name) >

Оператор function

Объявляет функции языка JavaScript, требует указания имени name и списка параметров param. Для того чтобы возвращать значение, функция должна иметь в себе оператор return, который указывает возвращаемое функцией значение. Оператор функция вы не можете вложить в другую функцию. Принято следующее написание этого оператора:

function name([param] [, param] [. param])

Эта функция возвращает общую долларовую сумму продажи, когда дано число единиц, продаваемых изделий a, b, и c.

function calc_sales(units_a, units_b, units_c)

Оператор if. else

Оператор if. else — это условный оператор, который выполняет первый набор утверждений, если значение condition истинно. В противном случае выполняет второй набор утверждений, заключенные в операторе else, если условие ложно. Если набор утверждений (statments), заключенные в фигурные скобки <> содержит один оператор, то скобки можно опустить. Условные операторы могут быть вложены друг в друга без ограничений.

if (condition) < . statements. >[else < else . statements. >]

Следующая функция преобразует значение минут текущего времени в двузначное число для использования в программе «Часы»:

fanction makeMinutes() < var minstring=""; var now = new Date(); var min = Date.getMinutes(); if (min<10) < minstring+=":0"+min;>else < minstring+=":"+min;>return minstring >

Оператор return

Оператор return указывает значение, которое будет возвращено функцией.

return expression;

Следующая функция возвращает квадрат ее аргумента, x, где x — это число:

function square( x )

Нижеприведенный пример соединяет три строки вместе, используя в качестве разделителя запятую:

function stringAssemble(string1,string2,string3)

Оператор var

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

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

var VariableName [= value] [. VariableName [= value] ]

var num_hits = 0, cust_no = 0

Приведем пример, когда переменная globalString может быть использована в любой функции или скрипте текущего документа, а переменная localString видна только внутри функции bracket:

var globalString function bracket()

Оператор while

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

while (condition)

Следующий цикл while повторяется, пока переменная n меньше чем три. Каждая итерация увеличивает n и прибавляет его к x. Следовательно, x и n пренимают следующие значения:

После первой итерации: x = 1 , n = 1

После второго итерации: x = 2 , n = 3

После третьего итерации: x = 3 , n = 6

n = 0 x = 0 while( n &lt 3 )

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

var found=false n=0 while (n

Оператор with

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

with (object)

Оператор with особенно полезен при ссылках на объект Math в процессе вычислений.Например:

JavaScript Операторы

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

Многие языки (например, Си-подобные) различают инструкцию и определение. Различие в том, что инструкция исполняет код, а определение создаёт идентификатор (то есть можно рассматривать определение как инструкцию присваивания).

Пример

Присвойте значения к переменным и сложите их вместе:

var x = 5; // присвойте значение 5 к x
var y = 2; // присвоить значение 2 к y
var z = x + y; // присвоить значение 7 к z (5 + 2)

Оператор присваивания ( = ) присваивает значение к переменной.

Присвоение

Оператор сложения ( + ) слаживает числа:

Добавление

var x = 5;
var y = 2;
var z = x + y;

Оператор умножения ( * ) умножает числа.

Умножение

var x = 5;
var y = 2;
var z = x * y;

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

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

Оператор	Описание
+	Сложение
—	Вычитание
*	Умножение
**	Возведение в степень (ES2016)
/	Деление
%	Модуль (Остаток деления)
++	Инкремент (увеличение на 1)
—	Декремент (уменьшение на 1)

Арифметические операторы полностью описаны в главе JS Арифметика.

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

Операторы присваивания присваивают значения к переменным JavaScript.

Оператор	Пример	То же, самое
=	x = y	x = y
+=	x += y	x = x + y
-=	x -= y	x = x — y
*=	x *= y	x = x * y
/=	x /= y	x = x / y
%=	x %= y	x = x % y
**=	x **= y	x = x ** y

Оператор присваивания сложения ( += ), добавляет значение к переменной.

Присвоение

var x = 10;
x += 5;

Операторы присваивания полностью описаны в главе JS Присваивание.

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

Оператор + , также может быть использован для добавления (конкатенации) строк.

Пример

var txt1 = «Щипунов»;
var txt2 = «Андрей»;
var txt3 = txt1 + » » + txt2;

Результатом txt3 будет:

Щипунов Андрей

Оператор присваивания += , также может использоваться для добавления (объединения) строк:

Пример

var txt1 = «Сегодня очень «;
txt1 += «хороший день»;

Результатом txt1 будет:

Сегодня очень хороший день

При использовании со строками оператор + называется оператором конкатенации.

Добавление строк и чисел

Добавление двух чисел вернет сумму, а добавление числа и строки вернет строку:

Пример

var x = 5 + 5;
var y = «5» + 5;
var z = «Привет» + 5;
10
55
Привет5

Если вы сложите число и строку, результатом будет строка!

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

Оператор	Описание
==	равно
===	равное значение и равный тип
!=	не равно
!==	не равное значение или не равный тип
>	больше, чем
	меньше, чем
>=	больше или равно
	меньше или равно
?	тернарный оператор

Операторы сравнения полностью описаны в главе JS Сравнения.

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

Оператор	Описание
&&	логический AND
||	логический OR
!	логический NOT

Логические операторы полностью описаны в главе JS Сравнения.

JavaScript Операторы типов

Оператор	Описание
typeof	Возвращает тип переменной
instanceof	Возвращает true, если объект является экземпляром типа объекта

Операторы типов полностью описаны в главе JS Преобразование типов.

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

Битовые операторы работают с 32-битными числами.

Любой числовой операнд в операции преобразуется в 32-битное число. Результат конвертируется обратно в число JavaScript.

Оператор	Описание	Пример	То же, самое	Результат	Десятичные
&	AND	5 & 1	0101 & 0001	0001	1
|	OR	5 | 1	0101 | 0001	0101	5
~	NOT	~ 5	~0101	1010	10
^	XOR	5 ^ 1	0101 ^ 0001	0100	4
	Нулевая заливка сдвиг влево	5	0101	1010	10
>>	Подписанный сдвиг вправо	5 >> 1	0101 >> 1	0010	2
>>>	Нулевая заливка сдвиг вправо	5 >>> 1	0101 >>> 1	0010	2

В приведенных выше примерах используются 4-битные беззнаковые примеры. Но в JavaScript используются 32-битные числа со знаком.
Из-за этого в JavaScript ~ 5 не вернет 10. Он вернет -6.
~00000000000000000000000000000101 вернет 11111111111111111111111111111010

Побитовые операторы полностью описаны в главе JS Побитовое.

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

Операторы в JavaScript делятся на два основных типа: унарные и бинарные (есть еще тернарный оператор, но он всего один и о нем немного позже). Отличие между ними в том, что унарные работают только с одним операндом (примитивом или выражением), а бинарный с двумя или более. Проще всего это продемонстрировать на операторе “ + ”. В бинарном виде он складывает значения. При этом значениями могут быть не только числа, но и строки и в случае, если один из операндом строка — второй тоже будет преобразован в строку, а в унарном — пытается преобразовать строку в число. При этом унарный и бинарный плюс можно комбинировать:

console.log(1 + 2); //число 3 //бинароный плюс с числами console.log("1" + "2"); //12 строкой //банрный плюс со строками console.log(1 + "2"); //12 строкой //бинарный плюс со строкой и числом console.log(+"2"); //число 2 //унареый плюс со строкой console.log(+"строка без цифр"); //NaN //если в троке нет цифр, вернет NaN console.log(1 + +"2");//число 3 //комбинация бинарного и унарного плюса

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

console.log(-"-1");//число 1 console.log(+"-1");//число -1

• Умножение “ * ” — бинарный оператор, который умножает первый операнд на второй.
• Возведение в степень “ ** ” бинарный оператор, который возводит первый операнд в степень, указанную во втором.
• Деление “ / ” бинарный оператор, который делит первый операнд на второй.
• Остаток от деления “ % ” бинарный операнд, который возвращает остаток при делении нацело первого операнда на втрой. Часто используется для нахождения четных и нечетных чисел или кратных чисел.

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

console.log(5 * "2"); //число 10 console.log("5" ** "2"); //число 25 console.log("5" / 2); //число 2.5 console.log("5" % "2"); //число 1

Кроме того в JavaScript есть еще два унарных математических оператора: “`++`” инкремент и “`—`” декремент. Это просто синтаксический сахар, заменяющий прибавление или отнимание единицы. Пишутся они до или после операнда без пробела. Операндом могут быть только переменные, значения которых будут приведены к числу. При этом есть разница в том где они указаны. Оба вида записи изменяют значение переменной, но при указании до переменной оператор возвращает измененное значение, а при указании после — исходное.

let counter1 = 0; console.log(++counter1); //1 let counter2 = "0"; console.log(counter2++); //0 //обе переменные были увеличены на 1 console.log(counter1); //1 console.log(counter2); //1

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

Логические операторы в JavaScript следуют следующим правилам:

• ссылочные типы данный сравниваются по ссылке, а не по значению. Т.е. два массива с одинаковыми значениями, объекта с одинаковыми полями и т.д. не будут равны друг другу, а ссылки на них — да.
• Строки сравниваются посимвольно используя для сравнения каждого символа кодировку Unicode (фактически сравниваются не сами символы, а их код в кодировке).
• При сравнении разных примитивных типов данных они приводятся к числу.

Их можно разделить на строгие и не строгие. Всего существует шесть “нестрогих” операторов сравнения:

• “ > ” больше и “ < ” меньше - возвращает результат сравнения первого операнда со вторым.
• “ > = ” больше или равно и “ < = ” меньше или равно - то же, что предыдущие, но возвращают true и если операнды равны.
• “ == » равенство по значению — возвращает true, если значения операндов равны.
• “ ! = ” неравенство по значению — наоборот вернет true только если значения не равны.

console.log(1 > "1"); //false console.log(1 >= "1"); //true console.log(1 == "1"); //true console.log(1 != "1"); //false const a = [1, 2]; //массив это ссылочный тип данных console.log(a == [1, 2]); // false //поэтому сравнение его с лругим массивом всегда вернет false const b = a; console.log(a == b); //true //обе переменные ссылаются на один массив и сравнение вернет true

В реальных проектах равенство и неравенство по значению применяется очень редко из-за того что они могут возвращать true при сравнении разных типов данных. Вместо них рекомендуется использовать “строгие” варианты операторов “`===`” для равенства и “`! ==`” для неравенства. Эти операторы сравнивают не только значения, но и типы данных операндов.

console.log(1 == "1"); //true console.log(1 === "1"); //false console.log(1 != "1"); //false console.log(1 !== "1"); //true

Хотя я и писал выше, что нестрогое сравниваемые значения приводятся к числам, есть исключения для null и undefined. Их сравнение с нулем дает странный, на первый взгляд результат:

console.log(null > 0); //false console.log(null == 0); //false console.log(null >= 0); //true console.log(undefined > 0); //false console.log(undefined < 0); //false console.log(undefined == 0); //false

Null приводится к числу со значением 0 только при сравнении через операторы `≤` b `≥`, а в остальных случаях остается собой. Undefined при любом сравнении выдает false потому что при приведении к числу возвращает NaN. При этом нестрогое сравнение null и undefined вернет true.

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

Существует 4 логических оператора:

• “ || ” логическое “ИЛИ”- бинарный оператор, который возвращает первое истинное значение т.е. проходится по всем операндам, проверяя их на преобразование в булево значение и возвращает первый операнд из цепочки, который при преобразовании в булево значение будет равен true. Если все значения ложные - возвращает последнее. Часто используется для записи условий с диапазонами доступных значений.
• ts function check(hour) = 8 || hour = 13 || hour else < return "closed";//если не соответствует ни одному >> “ && ” логическо “И” - бинарный операнд, который возвращает первое ложное значение или, если такого нет, возвращает последний операнд. Часто используется для проверки выполнения нескольких условий.
• ts const visitDateTime = < time: 12, dayOfWeek: "Monday" >; function check(dateTime) < if (dateTime.time >= 10 && dateTime.dayOfWeek !== "Sunday") < //если визит назначен не раньще 10 часов и не в всокресенье return "confirmed";//при выполнении обоих условий >else < return "unconfirmed";//при невыполнении хотя бы одного условия >> “ ?? ” оператор нулевого слияния - возвращает первое определенное (не равное null или undefined) значение или , если такого нет, возвращает последний операнд. Часто используется для задания значения по умолчанию.
• ts let first; //значение неопределено let second = undefined; // явно указан undefined let third = null; //явно указан null let fourth = "fourth"; // любое другое значение кроме undefined или null const res = first ?? second ?? third ?? fourth; console.log(res); //fourth //часто используется для установки значений по умолчанию let role; const userRole = role ?? "user"; console.log(userRole); //user “ ! ” логическое “НЕ” - унарный оператор который приводит операнд к виду булева значения и меняет его на противоположное. Часто используется для создания проверки на отсутствие каких-то данных или изменение переменных, содержащих булевы значения.

const userData = ""; //данные не заполнены или не пришли if (!userData) < console.log("Введите данные!"); >//берет пустую строку, которая после приведения к булеву // значению равна false и меняет его на true //т.е. условие в if() сработает let isReady = false; isReady = !isReady;//изменяет значение на противоположное console.log(isReady); //true

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

Кроме обычного оператора присваивания (” = ”) в JavaScript существуют бинарные операторы присваивания с операцией и операторы логического присваивания. Первые позволяют вместо простого присваивания переменной нового значения произвести операцию над его текущим значением. Синтаксис операторов присваивания с операцией объединяет синтаксис оператора нужной арифметической операции и простого присваивания (” *= ” - присваивание с умножением, “ += ” - присваивание со сложением и т.д.). Его вторым оперантом могут быть как числа, так и строки или переменные их содержащие.

let a = 2; let b = 4; b += 1; //b = 5 (5+1) b *= a; //b = 10 (5*2)

Операторы логического присваивания ”`||=`” - присвоение через логическое “ИЛИ”, “`&&=`" - присвоение через логическое “И” и “`??=`” - оператор нулевого присвоения ведут себя схоже со своими логическими собратьями, но вместо первого операнда используют текущее значение переменной.

const userData1 = < name: "", role: "user", age: undefined >; userData1.name ||= "John"; //поле имя имело ложное значение и будет изменено userData1.role ||= "admin"; //роль не была ложным значением и не будет изменена userData1.age ||= 22; //возраст был ложным значением и будет изменен console.log(userData1); // < name: 'John', role: 'user', age: 22 >const userData2 = < name: "", role: "user", age: undefined >; userData2.name &&= "John"; //поле имя имело ложное значение и не будет изменено userData2.role &&= "admin"; //роль не была ложным значением и будет изменена userData2.age &&= 22; //возраст был ложным значением и не будет изменен console.log(userData2); // < name: '', role: 'admin', age: undefined >const userData3 = < name: "", role: "user", age: undefined >; userData3.name ??= "John"; //поле имя не равно ни null ни undefined и не изменится userData3.role ??= "admin"; //роль не равна ни null ни undefined и не изменится userData3.age ??= 22; //возраст равен undefined и будет изменен console.log(userData3); //

Тернарный оператор

Единственным оператором в JavaScript, который принимает три операнда является тернарный оператор. Он принимает условие и два выражения ( условие ? выражение1 : выражение2 ), после чего возвращает первое выражение, если условие истинно или второе, если условие ложно.

const condition = 1; console.log(condition ? "first" : "second");//first //условие истино и вернется первое выражение condition = 0 console.log(condition ? "first" : "second");//second //условие ложно и вернется второе выражение

Операторы доступа к свойствам объектов и optional chaining

Так же в JavaScript операторами считаются точка при обращении к свойствам объектов или квадратные скобки при обращении к элементам массивов. Кроме этих операторов существует оператор опциональной цепочки (optional chaining) ” ?. ", который позволяет обратиться к свойству объекта только при его наличии не ломая исполнение кода. При этом его можно использовать и для обращения через квадратные скобки или вызове функции, являющейся свойством объекта.

const user1 = < name: "John" >; const usersDogName = user1.pets.dog.name; console.log(dog); //TypeError: Cannot read properties of undefined (reading 'dog') const usersCatName = user1.pets?.cat.name; console.log(usersCatName); //undefined //обращение через квадратные скобки const user2 = null; console.log(user2[name]); //ReferenceError: name is not defined console.log(user2?.[name]); //undefined //обращение к функции const someFuncs = < foo() < console.log("foo"); >, >; someFuncs.bar(); //TypeError: someFuncs.bar is not a function someFuncs.bar?.(); //гтчего не произойдет

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

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

const a = (1, 2, 3); console.log(a); //3 const myArr = [ //массив из 10 элементов, каждый элемент //которого тоже массив из 10 элементов ]; for (let i = 0, j = 9; i let a = 1,b = 2,c = 3,d = 4; //объявление нескольких переменных в одну строку

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

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

Существует семь побитовых операторов:

• “ & ” побитовое “И” - бинарный оператор, который возвращает число, состоящее из битов, которые равны 1 у обоих чисел. Например, если a = 1011 и b = 1101, то a & b = 1001.
• “ | ” побитовое “ИЛИ” - бинарный оператор, который возвращает число, состоящее из битов, которые равны 1 хотя бы у одного из чисел. Например, если a = 1011 и b = 1101, то a | b = 1111.
• “ ^ ” побитовое “ИСКЛЮЧИТЕЛЬНОЕ ИЛИ” - бинарный оператор, который возвращает число, состоящее из битов, которые равны 1 только у одного из чисел. Например, если a = 1011 и b = 1101, то a ^ b = 0110.
• “ ~ ” побитовое “НЕ” - унарный оператор, который возвращает инвертированное число, т.е. число, где все биты перевернуты. Если a = 1011, то ~a = 0100.
• “ > ” левый и правый сдвиг - бинарные операторы, которые сдвигают биты числа a на b позиций влево или вправо соответственно, добавляя нули справа. Это эквивалентно умножению числа на 2(при левом сдвиге), возведённое в степень b или делению числа на 2(для правого сдвига), возведенное в степень b.
• “ >>> ” правый сдвиг с заполнением нулями - бинарный оператор, который действует как обычный правый сдвиг, но слева добавляются нули, а в отрицательных числах отбрасывается знак.

Следует отметить, что все числа сначала преобразуются в 32-битные перед применением операции. Результат также представляется как 32-битное целое. Для сокращения записи пример ниже будет представлен 4-битной виде.

const a = 12; // в двоичной системе: 1100 const b = 15; // в двоичной системе: 1111 console.log(a & b); // результат: 12 (в двоичной системе: 1100) const a = 12; // в двоичной системе: 1100 const b = 15; // в двоичной системе: 1111 console.log(a | b); // результат: 15 (в двоичной системе: 1111) const a = 12; // в двоичной системе: 1100 const b = 15; // в двоичной системе: 1111 console.log(a ^ b); // результат: 3 (в двоичной системе: 0011) const a = 12; // в двоичной системе: 1100 console.log(~a); // результат: -13 // Причина в том, что в компьютерах числа хранятся в дополнительном коде, // поэтому результат операции ~a будет равен -(a + 1). const a = 3; // в двоичной системе: 11 console.log(a > 2); // результат: 3 (в двоичной системе: 11) // Это эквивалентно делению числа 12 на 2 в степени 2 (12 / (2**2) = 3) const a = -12; // в двоичной системе: 1100 console.log(a >>> 2); // результат: 1073741821 // Этот оператор сдвигает все биты кправо и заполняет биты слева нулями. // Это отличается от >> тем, что >> сохраняет знак числа, // а >>> игнорирует знак и всегда добавляет нули слева.

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

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

console.log(1 + +"2"); //число 3 //сначала сработал унарный плюс, а потом бинарный console.log(+(1 + "2")); //число 12 // если изменить порядок срабатывания операторов с помощью //группировки скобками мы получим другой результат

Заключение:

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

Выражения и операторы

Эта глава описывает все операторы, выражения и ключевые слова языка JavaScript.

Выражения и операторы по категориям

Алфавитный список смотрите в боковой панели слева.

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

Базовые ключевые слова и общие выражения в JavaScript.

Ключевое слово this ссылается на контекст выполняемой функции.

Ключевое слово function определяет выражение функции.

Ключевое слово class определяет выражение класса.

Ключевое слово function* (со звёздочкой) определяет функцию-генератор.

Пауза или продолжение выполнения функции-генератора.

Делегирует выполнение другому генератору итерируемому объекту.

async function определяет выражение асинхронной функции.

Пауза и продолжение выполнения асинхронной функции и ожидание Promise (результата выполнения) с результатом разрешено/отклонено.

Синтаксис создания инициализатора/литерала массива.

Синтаксис создания инициализатора/литерала объекта

Синтаксис создания литерала регулярного выражения.

Левосторонние выражения

Значения слева являются назначением присваивания.

Операторы доступа к членам предоставляют доступ к свойству или методу объекта ( object.property и object['property'] ).

Оператор new создаёт экземпляр объекта с использованием конструктора.

Свойство new.target ссылается на конструктор или функцию, который был вызван через оператор new .

Ключевое слово super вызывает конструктор родительского класса.

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

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

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

Оператор постфиксного инкремента.

Оператор постфиксного декремента.

Оператор префиксного инкремента. (Значение переменной, сначала, увеличивается на 1, а затем используется в выражении)

Оператор префиксного декремента.

Унарные операторы

Унарные операции — это операции с одним операндом.

Оператор delete удаляет свойство из объекта.

Оператор void отбрасывает возвращаемое значение выражения.

Оператор typeof определяет тип переданного объекта.

Оператор унарного плюса преобразует свой операнд в тип Number .

Оператор унарного минуса преобразует свой операнд в тип Number , а затем меняет его знак.

Оператор побитового НЕ.

Оператор логического НЕ.

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

Арифметические операторы своими операндами принимают числовые значения (литералы или переменные) и возвращают одно числовое значение.

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

Оператор возведения в степень.

Реляционные операторы

Реляционные операторы (операторы отношения) сравнивают свои операнды и возвращают значение типа Boolean , зависящее от того, был ли результат сравнения истинным или ложным.

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

Оператор instanceof определяет, является ли объект экземпляром потомком Prototype (или экземпляром) другого объекта.

Оператор меньше или равно.

Оператор больше или равно.

Примечание: => это не оператор. Это нотация для Стрелочных функций.

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

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

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

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

Оператор проверки на идентичность.

Оператор проверки на неидентичность.

Операторы побитового сдвига

Операции для сдвига всех битов операнда.

Оператор побитового сдвига влево.

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

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

Бинарные побитовые операторы

Побитовые операторы трактуют свои операнды как набор из 32 битов (нулей и единиц) и возвращают стандартные числовые значения JavaScript.

Оператор побитового И.

Оператор побитового ИЛИ.

Оператор побитового ИСКЛЮЧАЮЩЕГО ИЛИ.

Бинарные логические операторы

Логические операторы обычно используются вместе с булевыми (логическими) значениями и в сочетании с ними они возвращают булево значение.

Оператор логического И.

Оператор логического ИЛИ.

Условный (тернарный) оператор

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

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

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

Оператор присваивания с умножением.

Оператор присваивания с делением.

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

Оператор присваивания со сложением.

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

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

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

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

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

Оператор присваивания с побитовым ИСКЛЮЧАЮЩИМ ИЛИ.

Оператор присваивания с побитовым ИЛИ.

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

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

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

Нестандартные особенности

Ключевое слово function может быть использовано для определения устаревших функций-генераторов в одном выражении. Для того, чтобы сделать такую функцию, её тело должно содержать хотя бы одно выражение yield .

Синтаксис закрытого выражения для сокращённого написания простейших функций.

Упрощённый синтаксис создания массива.

Упрощённый синтаксис создания генератора.

Спецификации

Specification
ECMAScript Language Specification # sec-addition-operator-plus
ECMAScript Language Specification # sec-assignment-operators
ECMAScript Language Specification # sec-async-function-definitions
ECMAScript Language Specification # sec-async-generator-function-definitions
ECMAScript Language Specification # prod-BitwiseANDExpression
ECMAScript Language Specification # sec-bitwise-not-operator
ECMAScript Language Specification # prod-BitwiseORExpression
ECMAScript Language Specification # prod-BitwiseXORExpression
ECMAScript Language Specification # sec-class-definitions
ECMAScript Language Specification # sec-comma-operator
ECMAScript Language Specification # sec-conditional-operator
ECMAScript Language Specification # sec-postfix-decrement-operator
ECMAScript Language Specification # sec-delete-operator
ECMAScript Language Specification # sec-destructuring-assignment
ECMAScript Language Specification # sec-destructuring-binding-patterns
ECMAScript Language Specification # sec-multiplicative-operators
ECMAScript Language Specification # sec-equality-operators
ECMAScript Language Specification # sec-exp-operator
ECMAScript Language Specification # sec-function-definitions
ECMAScript Language Specification # sec-generator-function-definitions
ECMAScript Language Specification # sec-relational-operators
ECMAScript Language Specification # sec-grouping-operator
ECMAScript Language Specification # sec-import-calls
ECMAScript Language Specification # prod-ImportMeta
HTML Standard # hostgetimportmetaproperties
ECMAScript Language Specification # sec-postfix-increment-operator
ECMAScript Language Specification # sec-left-shift-operator
ECMAScript Language Specification # prod-LogicalANDExpression
ECMAScript Language Specification # sec-logical-not-operator
ECMAScript Language Specification # prod-LogicalORExpression
ECMAScript Language Specification # sec-new-operator
ECMAScript Language Specification # sec-built-in-function-objects
ECMAScript Language Specification # sec-null-value
ECMAScript Language Specification # prod-CoalesceExpression
ECMAScript Language Specification # sec-object-initializer
ECMAScript Language Specification # prod-OptionalExpression
ECMAScript Language Specification # sec-property-accessors
ECMAScript Language Specification # sec-signed-right-shift-operator
ECMAScript Language Specification # prod-SpreadElement
ECMAScript Language Specification # prod-ArgumentList
ECMAScript Language Specification # prod-PropertyDefinition
ECMAScript Language Specification # sec-subtraction-operator-minus
ECMAScript Language Specification # sec-super-keyword
ECMAScript Language Specification # sec-this-keyword
ECMAScript Language Specification # sec-typeof-operator
ECMAScript Language Specification # sec-unary-minus-operator
ECMAScript Language Specification # sec-unary-plus-operator
ECMAScript Language Specification # sec-unsigned-right-shift-operator
ECMAScript Language Specification # sec-void-operator
ECMAScript Language Specification # prod-YieldExpression
ECMAScript Language Specification # sec-generator-function-definitions-runtime-semantics-evaluation

Смотрите также

Found a content problem with this page?

• Edit the page on GitHub.
• Report the content issue.
• View the source on GitHub.

This page was last modified on 18 окт. 2023 г. by MDN contributors.

Your blueprint for a better internet.

MDN

Support

• Product help
• Report an issue

Our communities

Developers

• Web Technologies
• Learn Web Development
• MDN Plus
• Hacks Blog

• Website Privacy Notice
• Cookies
• Legal
• Community Participation Guidelines

Visit Mozilla Corporation’s not-for-profit parent, the Mozilla Foundation.
Portions of this content are ©1998– 2023 by individual mozilla.org contributors. Content available under a Creative Commons license.