Логиката е основата на всяка програма, така че ще искате да овладеете логическите оператори, за да структурирате ефективно своя код.

Логическите оператори ви позволяват да извършвате логически операции върху булеви стойности. Те ви позволяват да комбинирате, отричате или сравнявате булеви стойности и да вземате логически решения във вашия код въз основа на резултата.

Разгледайте различните логически оператори, които JavaScript поддържа, включително оператора за обединяване на ES6 Nullish.

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

Операторът И (&&) е логически оператор, който връща вярно ако и двата операнда дават резултат вярно и невярно в противен случай.

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

a && b

Ето пример за използвания оператор AND:

конст а = 5;
конст b = 10;
конст c = 15;
конст резултат_1 = (a < b) && (b < c);
конзола.log (резултат_1); // вярно
конст резултат_2 = (a > b) && (b < c);
конзола.log (резултат_2); // невярно

В този пример, резултат_1 оценява до вярно защото двата операнда в израза се оценяват на вярно. Въпреки това, резултат_2 оценява до невярно защото първият операнд (a > b) се завръща невярно.

instagram viewer

Ако и двата операнда не са булеви, JavaScript ще се опита да ги конвертира в булеви стойности, преди да изчислите израза. За да ги преобразува в булеви стойности, JavaScript първо оценява дали стойностите са верни или грешни.

JavaScript счита всяка стойност, която не е изрично фалшива, за истинска стойност. Когато се преобразуват, те се оценяват като булево вярно.

Въпреки това определени стойности и типове данни в JavaScript са фалшиви, така че когато JavaScript ги преобразува, те се оценяват като булево невярно.

Фалшивите стойности в JavaScript са:

  • невярно
  • нула
  • недефиниран
  • NaN (Не е номер)
  • 0
  • BigInt (0n)
  • Празен низ ("" или '' или ``)
  • недефиниран

Когато използвате оператора И за оценка на небулеви стойности, изразът незабавно връща стойността на първия операнд, ако операндът е фалшив, без да оценява втория. Това поведение е известно като късо съединение и можете да го използвате, за да пишете условни изрази в JavaScript.

Въпреки това, ако първият операнд е верен, изразът продължава да оценява втория операнд. Ако вторият операнд е верен, той го връща.

Например:

конст а = 5;
конст b = 'Здравейте';
конст c = нула;
конст резултат_1 = a && b;
конзола.log (резултат_1); // "Здравейте"
конст резултат_2 = c && b;
конзола.log (резултат_2); // нула

В този пример, резултат_1 дава оценка на „Здравей“, защото и двата операнда в израза са верни. Въпреки това, резултат_2 късо съединение и връщане нула без оценка на втория операнд.

Обърнете внимание, че ако има повече операнди, операторът И ще продължи да ги оценява, докато срещне фалшива стойност. Ако не срещне фалшива стойност, той връща последната вярна стойност, която среща.

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

Операторът ИЛИ (||) е логически оператор, който връща вярно ако и само ако един или повече от неговите операнди са вярно. Само се връща невярно когато и двата операнда са невярно.

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

а || b

Ето пример за използван оператор OR:

конст а = 5;
конст b = 10;
конст c = 15;
конст резултат_1 = (a < b) || (b < c);
конзола.log (резултат_1); // вярно


конст резултат_2 = (a > b) || (b < c);
конзола.log (резултат_2); // вярно
конст резултат_3 = (a > b) || (b > c);
конзола.log (резултат_3); // невярно

В примера по-горе, резултат_1 оценява до вярно тъй като и двата операнда в израза се оценяват на вярно. резултат_2 оценява до вярно защото вторият операнд се оценява на вярно. резултат_3 оценява до невярно защото двата операнда в израза се оценяват на невярно.

Когато използвате оператора OR в небулев контекст, JavaScript се опитва да преобразува в булеви стойности, преди да оцени израза.

Когато изразът се оценява, ако първият операнд е верен, операторът прави късо съединение и го връща. Ако обаче е фалшив, той продължава да оценява следващия операнд, докато не срещне верен операнд. Ако в израза няма верни операнди, той връща последната грешна стойност, която среща.

Например:

конст а = 5;
конст b = 'Здравейте';
конст c = нула;
конст резултат_1 = a || b;
конзола.log (резултат_1); // 5


конст резултат_2 = c || b;
конзола.log (резултат_2); // "Здравейте"
конст резултат_3 = c || " ";
конзола.log (резултат_3); // " "

В примера по-горе, резултат_1 късо съединение и връщане 5 защото това е истинска стойност. резултат_2 връща „Hello“, защото това е първата вярна стойност, която среща в израза. резултат_3 връща празен низ, защото това е последната фалшива стойност в израза.

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

Логическият оператор НЕ (!) е унарен оператор, който връща противоположната булева стойност на своя операнд.

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

!х

Където х е булева или вярна или невярна стойност.

Ето пример за използвания оператор NOT:

конст а = 5;
конст b = '';
конст c = вярно;
конст резултат_1 = !a;
конзола.log (резултат_1); // невярно


конст резултат_2 = !b;
конзола.log (резултат_2); // вярно
конст резултат_3 = !c;
конзола.log (резултат_3); // невярно

В примера по-горе операторът NOT връща обратната стойност на булевите операнди. Когато използвате оператора NOT в небулев контекст (резултат_1 & резултат_2), преобразува верните стойности в обратната стойност на вярно и преобразува фалшивите стойности в обратната стойност на невярно.

Операторът Nullish Coalescing (??).

Операторът за нулево обединяване е логически оператор, който оценява два операнда и връща първия операнд, ако не е нула или недефиниран. В противен случай връща втория операнд.

На пръв поглед операторът за нулево обединяване може да изглежда идентичен с логическия оператор ИЛИ (||), но това не е така. Ключовата разлика е, че операторът OR връща десния операнд, ако левият операнд е „всяка“ фалшива стойност, не само нула или недефиниран.

Той предоставя кратък начин за избор на стойност по подразбиране при среща нула или недефиниран стойности.

Ето синтаксиса за нулевия коалесцентен оператор:

х?? г

Ето пример за използван нулев коалесцентен оператор:

конст име = нула;
конст име по подразбиране = "Джон Доу";
конст резултат_1 = име?? defaultName;
конзола.log (резултат_1); // "Джон Доу"


конст възраст = 0;
конст възраст по подразбиране = 25;
конст резултат_2 = възраст?? defaultAge;
конзола.log (резултат_2); // 0

В примера по-горе, резултат_1 връща „Джон Доу“, тъй като първият операнд имаше стойност от нула. резултат_2 се завръща 0 защото, въпреки че е фалшива стойност, тя не е нито едно от двете нула нито недефиниран.

Използване на логически оператори във вашия код

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

Като използвате тези логически оператори, можете да напишете по-сбит и изразителен код, който обработва различни сценарии въз основа на истинността или неистинността на стойностите.