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

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

Изучите различные логические операторы, поддерживаемые JavaScript, в том числе оператор объединения ES6 Nullish.

Логический оператор И (&&)

Оператор AND (&&) — это логический оператор, который возвращает истинный если оба операнда оцениваются как истинный и ЛОЖЬ в противном случае.

Вот синтаксис оператора AND:

а && б

Вот пример использования оператора AND:

константа а = 5;
константа б = 10;
константа с = 15;
константа результат_1 = (а < б) && (б < с);
консоль.log (результат_1); // истинный
константа результат_2 = (а > б) && (б < с);
консоль.log (результат_2); // ЛОЖЬ

В этом примере результат_1 оценивает истинный потому что два операнда в выражении оцениваются как

instagram viewer
истинный. Однако, результат_2 оценивает ЛОЖЬ потому что первый операнд (а > б) возвращается ЛОЖЬ.

Если оба операнда не логические, JavaScript попытается преобразовать их в логические значения перед вычислением выражения. Чтобы преобразовать их в логические значения, JavaScript сначала оценивает, являются ли значения истинными или ложными.

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

Однако определенные значения и типы данных в JavaScript являются ложными, поэтому, когда JavaScript преобразует их, они оцениваются как логические ЛОЖЬ.

Ложные значения в JavaScript:

  • ЛОЖЬ
  • нулевой
  • неопределенный
  • NaN (Не число)
  • 0
  • BigInt (0n)
  • Пустая строка ("" или '' или ``)
  • неопределенный

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

Однако, если первый операнд верен, выражение переходит к оценке второго операнда. Если второй операнд верен, он возвращает его.

Например:

константа а = 5;
константа б = 'Привет';
константа с = нулевой;
константа результат_1 = а && б;
консоль.log (результат_1); // "Привет"
константа результат_2 = с && б;
консоль.log (результат_2); // нулевой

В этом примере результат_1 оценивается как «Hello», потому что оба операнда в выражении истинны. Однако, результат_2 короткие замыкания и возвраты нулевой без оценки второго операнда.

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

Логический оператор ИЛИ (||)

Оператор ИЛИ (||) — это логический оператор, который возвращает истинный тогда и только тогда, когда один или несколько его операндов истинный. Он только возвращает ЛОЖЬ когда оба операнда ЛОЖЬ.

Вот синтаксис оператора ИЛИ:

а || б

Вот пример использования оператора OR:

константа а = 5;
константа б = 10;
константа с = 15;
константа результат_1 = (а < б) || (б < в);
консоль.log (результат_1); // истинный


константа результат_2 = (а > б) || (б < в);
консоль.log (результат_2); // истинный
константа результат_3 = (а > б) || (б > в);
консоль.log (результат_3); // ЛОЖЬ

В приведенном выше примере результат_1 оценивает истинный потому что оба операнда в выражении оцениваются как истинный. результат_2 оценивает истинный потому что второй операнд оценивается как истинный. результат_3 оценивает ЛОЖЬ потому что два операнда в выражении оцениваются как ЛОЖЬ.

Когда вы используете оператор OR в нелогических контекстах, JavaScript пытается преобразовать его в логические значения перед вычислением выражения.

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

Например:

константа а = 5;
константа б = 'Привет';
константа с = нулевой;
константа результат_1 = а || б;
консоль.log (результат_1); // 5


константа результат_2 = с || б;
консоль.log (результат_2); // "Привет"
константа результат_3 = с || " ";
консоль.log (результат_3); // " "

В приведенном выше примере результат_1 короткие замыкания и возвраты 5 потому что это истинное значение. результат_2 возвращает «Hello», потому что это первое истинное значение, встречающееся в выражении. результат_3 возвращает пустую строку, поскольку это последнее ложное значение в выражении.

Логический оператор НЕ (!)

Логический оператор НЕ (!) — это унарный оператор, возвращающий противоположное логическое значение своего операнда.

Вот синтаксис оператора НЕ:

!Икс

Где Икс является логическим или истинным или ложным значением.

Вот пример использования оператора NOT:

константа а = 5;
константа б = '';
константа с = истинный;
константа результат_1 = !а;
консоль.log (результат_1); // ЛОЖЬ


константа результат_2 = !b;
консоль.log (результат_2); // истинный
константа результат_3 = !с;
консоль.log (результат_3); // ЛОЖЬ

В приведенном выше примере оператор НЕ возвращает обратное значение логических операндов. Когда вы используете оператор NOT в небулевых контекстах (результат_1 & результат_2), он преобразует истинные значения в обратное значение истинный и преобразует ложные значения в обратное значение ЛОЖЬ.

Нулевой оператор объединения (??)

Нулевой оператор объединения — это логический оператор, который оценивает два операнда и возвращает первый операнд, если он не нулевой или неопределенный. В противном случае возвращается второй операнд.

На первый взгляд может показаться, что нулевой оператор объединения идентичен логическому оператору ИЛИ (||), но это не так. Ключевое отличие заключается в том, что оператор ИЛИ возвращает правый операнд, если левый операнд является «любым» ложным значением, а не только нулевой или неопределенный.

Он обеспечивает краткий способ выбора значения по умолчанию при встрече с нулевой или неопределенный ценности.

Вот синтаксис нулевого оператора объединения:

Икс?? у

Вот пример использования нулевого оператора объединения:

константа имя = нулевой;
константа имя по умолчанию = "Джон Доу";
константа результат_1 = имя?? имя по умолчанию;
консоль.log (результат_1); // "Джон Доу"


константа возраст = 0;
константа возраст по умолчанию = 25;
константа результат_2 = возраст?? возраст по умолчанию;
консоль.log (результат_2); // 0

В приведенном выше примере результат_1 возвращает «Джон Доу», потому что первый операнд имел значение нулевой. результат_2 возвращается 0 потому что, хотя это и ложное значение, оно ни нулевой ни неопределенный.

Использование логических операторов в вашем коде

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

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