Како користити логичке операторе у ЈаваСцрипт-у

Логички оператори вам омогућавају да изводите логичке операције над логичким вредностима. Они вам омогућавају да комбинујете, негирате или упоредите логичке вредности и доносите логичне одлуке у свом коду на основу резултата.

Истражите различите логичке операторе које ЈаваСцрипт подржава, укључујући ЕС6 Нуллисх коалесцентни оператор.

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

Оператор АНД (&&) је логички оператор који враћа истина ако оба операнда процењују на истина и лажно иначе.

Ево синтаксе оператора АНД:

а && б

Ево примера АНД оператора који се користи:

конст а = 5;
конст б = 10;
конст ц = 15;
конст резултат_1 = (а < б) && (б < ц);
конзола.лог (резултат_1); // истина
конст резултат_2 = (а > б) && (б < ц);
конзола.лог (резултат_2); // фалсе

У овом примеру, резултат_1 процењује да истина јер два операнда у изразу процењују на истина. Међутим, резултат_2 процењује да лажно јер први операнд (а > б) враћа лажно.

Ако оба операнда нису логички, ЈаваСцрипт ће покушати да их конвертује у логичке вредности пре процене израза. Да би их претворио у логичке вредности, ЈаваСцрипт прво процењује да ли су вредности истините или нетачне.

ЈаваСцрипт сваку вредност која није експлицитно нетачна сматра истинитом вредношћу. Када се конвертују, процењују се у логички истина.

Међутим, одређене вредности и типови података у ЈаваСцрипт-у су лажни, тако да када их ЈаваСцрипт конвертује, процењују се у логички лажно.

Лажне вредности у ЈаваСцрипт-у су:

• лажно
• нула
• недефинисан
• НаН (није број)
• 0
• БигИнт (0н)
• Празан низ ("" или '' или ``)
• недефинисан

Када користите оператор АНД за процену не-боолеових вредности, израз одмах враћа вредност првог операнда ако је операнд нетачан без процене другог. Ово понашање је познато као кратки спој и можете га користити за писање условне изјаве у ЈаваСцрипт-у.

Међутим, ако је први операнд истинит, израз наставља да процењује други операнд. Ако је други операнд истинит, он га враћа.

На пример:

конст а = 5;
конст б = 'Здраво';
конст ц = нула;
конст резултат_1 = а && б;
конзола.лог (резултат_1); // "Здраво"
конст резултат_2 = ц && б;
конзола.лог (резултат_2); // нула

У овом примеру, резултат_1 вреднује у „Здраво“ јер су оба операнда у изразу истинита. Међутим, резултат_2 кратки спојеви и поврати нула без процене другог операнда.

Имајте на уму да ако има више операнада, оператор АНД ће наставити да их процењује све док не наиђе на погрешну вредност. Ако не наиђе на нетачну вредност, враћа последњу истиниту вредност на коју наиђе.

Логички ОР (||) оператор

Оператор ОР (||) је логички оператор који враћа истина ако и само ако је један или више његових операнада истина. Само се враћа лажно када су оба операнда лажно.

Ево синтаксе оператора ОР:

а || б

Ево примера оператора ОР који се користи:

конст а = 5;
конст б = 10;
конст ц = 15;
конст резултат_1 = (а < б) || (б < ц);
конзола.лог (резултат_1); // истина
конст резултат_2 = (а > б) || (б < ц);
конзола.лог (резултат_2); // истина
конст резултат_3 = (а > б) || (б > ц);
конзола.лог (резултат_3); // фалсе

У горњем примеру, резултат_1 процењује да истина јер оба операнда у изразу процењују на истина. резултат_2 процењује да истина јер други операнд процењује да истина. резултат_3 процењује да лажно јер два операнда у изразу процењују на лажно.

Када користите оператор ОР у не-боолеанским контекстима, ЈаваСцрипт покушава да конвертује у логичке вредности пре него што процени израз.

Када се израз процени, ако је први операнд истинит, оператор кратко спаја и враћа га. Међутим, ако је нетачан, он наставља да процењује следећи операнд све док не наиђе на истинит операнд. Ако у изразу нема истинитих операнда, он враћа последњу лажну вредност на коју наиђе.

На пример:

конст а = 5;
конст б = 'Здраво';
конст ц = нула;
конст резултат_1 = а || б;
конзола.лог (резултат_1); // 5
конст резултат_2 = ц || б;
конзола.лог (резултат_2); // "Здраво"
конст резултат_3 = ц || " ";
конзола.лог (резултат_3); // " "

У горњем примеру, резултат_1 кратки спојеви и поврати 5 јер је истинита вредност. резултат_2 враћа „Здраво“ јер је то прва истинита вредност на коју наилази у изразу. резултат_3 враћа празан стринг јер је то последња нетачна вредност у изразу.

Логички НОТ (!) Оператор

Логички НОТ (!) оператор је унарни оператор који враћа супротну логичку вредност свог операнда.

Ево синтаксе НОТ оператора:

!Икс

Где Икс је логичка или истинита или лажна вредност.

Ево примера НОТ оператора у употреби:

конст а = 5;
конст б = '';
конст ц = истина;
конст резултат_1 = !а;
конзола.лог (резултат_1); // фалсе
конст резултат_2 = !б;
конзола.лог (резултат_2); // истина
конст резултат_3 = !ц;
конзола.лог (резултат_3); // фалсе

У примеру изнад, НОТ оператор враћа инверзну вредност логичких операнада. Када користите НОТ оператор у не-боолеовим контекстима (резултат_1 & резултат_2), претвара истините вредности у инверзну вредност од истина и претвара нетачне вредности у инверзну вредност од лажно.

Нуллисх коалесцинг (??) Оператор

Оператор спајања нуле је логички оператор који процењује два операнда и враћа први операнд ако није нула или недефинисан. У супротном, враћа други операнд.

На први поглед, нулти оператор спајања може изгледати идентичан логичком ОР (||) оператору, али то није случај. Кључна разлика је у томе што оператор ОР враћа операнд са десне стране ако је леви операнд „било која“ лажна вредност, не само нула или недефинисан.

Пружа сажет начин одабира подразумеване вредности приликом сусрета нула или недефинисан вредности.

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

Икс?? и

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

конст име = нула;
конст дефаултНаме = "Н.Н. лице";
конст резултат_1 = име?? дефаултНаме;
конзола.лог (резултат_1); // "Н.Н. лице"
конст старост = 0;
конст дефаултАге = 25;
конст резултат_2 = старост?? дефаултАге;
конзола.лог (резултат_2); // 0

У горњем примеру, резултат_1 враћа „Јохн Дое“ јер је први операнд имао вредност од нула. резултат_2 враћа 0 јер, иако је лажна вредност, није ни једно ни друго нула нити недефинисан.

Коришћење логичких оператора у вашем коду

Логички оператори се обично користе за писање условних изјава, додељивање подразумеваних вредности или пребацивање логичких вредности на основу услова.

Користећи ове логичке операторе, можете написати сажетији и изражајнији код који обрађује различите сценарије засноване на истинитости или нетачности вредности.