Logik är grunden för alla program, så du vill behärska logiska operatorer för att strukturera din kod effektivt.

Med logiska operatorer kan du utföra logiska operationer på booleska värden. De låter dig kombinera, negera eller jämföra booleska värden och fatta logiska beslut i din kod baserat på resultatet.

Utforska de olika logiska operatorerna som JavaScript stöder, inklusive ES6 Nullish koalescerande operator.

Den logiska OCH (&&)-operatören

AND (&&) operatorn är en logisk operator som returnerar Sann om båda operanderna evaluerar till Sann och falsk annat.

Här är syntaxen för AND-operatorn:

a && b

Här är ett exempel på AND-operatorn som används:

konst a = 5;
konst b = 10;
konst c = 15;
konst result_1 = (a < b) && (b < c);
trösta.log (resultat_1); // Sann
konst result_2 = (a > b) && (b < c);
trösta.log (resultat_2); // falskt

I det här exemplet, resultat_1 utvärderar till Sann eftersom de två operanderna i uttrycket evaluerar till Sann. Dock, resultat_2 utvärderar till falsk eftersom den första operanden (a > b) returnerar falsk.

instagram viewer

Om båda operanderna inte är booleska, JavaScript kommer att försöka konvertera dem till booleska värden innan uttrycket utvärderas. För att konvertera dem till booleaner utvärderar JavaScript först om värdena är sanna eller falska.

JavaScript betraktar alla värden som inte är explicit falska, som ett sanningsvärde. När de konverteras utvärderas de till ett booleskt värde Sann.

Men vissa värden och datatyper i JavaScript är falska, så när JavaScript konverterar dem utvärderas de till ett booleskt värde falsk.

De falska värdena i JavaScript är:

  • falsk
  • null
  • odefinierad
  • NaN (Inte ett nummer)
  • 0
  • BigInt (0n)
  • Tom sträng ("" eller '' eller ``)
  • odefinierad

När du använder AND-operatorn för att utvärdera icke-booleska värden, returnerar uttrycket omedelbart den första operandens värde om operanden är falsk utan att utvärdera den andra. Detta beteende är känt som kortslutning, och du kan använda det för att skriva villkorliga uttalanden i JavaScript.

Men om den första operanden är sann, fortsätter uttrycket att utvärdera den andra operanden. Om den andra operanden är sann, returnerar den den.

Till exempel:

konst a = 5;
konst b = 'Hallå';
konst c = null;
konst resultat_1 = a && b;
trösta.log (resultat_1); // "Hallå"
konst resultat_2 = c && b;
trösta.log (resultat_2); // null

I det här exemplet, resultat_1 utvärderas till "Hej" eftersom båda operanderna i uttrycket är sanna. Dock, resultat_2 kortslutningar och returer null utan att utvärdera den andra operanden.

Observera att om det finns fler operander kommer AND-operatorn att fortsätta att utvärdera dem tills den stöter på ett falskt värde. Om den inte stöter på ett falskt värde returnerar den det sista sanningsvärdet den stöter på.

Den logiska ELLER-operatören (||).

Operatorn OR (||) är en logisk operator som returnerar Sann om och bara om en eller flera av dess operander är det Sann. Den återkommer bara falsk när båda operanderna är det falsk.

Här är syntaxen för OR-operatorn:

en || b

Här är ett exempel på OR-operatorn som används:

konst a = 5;
konst b = 10;
konst c = 15;
konst resultat_1 = (a < b) || (b < c);
trösta.log (resultat_1); // Sann


konst resultat_2 = (a > b) || (b < c);
trösta.log (resultat_2); // Sann
konst resultat_3 = (a > b) || (b > c);
trösta.log (resultat_3); // falskt

I exemplet ovan, resultat_1 utvärderar till Sann eftersom båda operanderna i uttrycket evaluerar till Sann. resultat_2 utvärderar till Sann eftersom den andra operanden utvärderar till Sann. resultat_3 utvärderar till falsk eftersom de två operanderna i uttrycket evaluerar till falsk.

När du använder OR-operatorn i icke-booleska sammanhang, försöker JavaScript konvertera till booleska värden innan uttrycket utvärderas.

När uttrycket utvärderas, om den första operanden är sann, kortsluter operatören och returnerar den. Men om den är falsk fortsätter den att utvärdera nästa operand tills den stöter på en sann operand. Om det inte finns några sanningsoperander i uttrycket returnerar det det senaste falska värdet det stöter på.

Till exempel:

konst a = 5;
konst b = 'Hallå';
konst c = null;
konst resultat_1 = en || b;
trösta.log (resultat_1); // 5


konst resultat_2 = c || b;
trösta.log (resultat_2); // "Hallå"
konst resultat_3 = c || " ";
trösta.log (resultat_3); // " "

I exemplet ovan, resultat_1 kortslutningar och returer 5 eftersom det är ett sanningsvärde. resultat_2 returnerar "Hej" eftersom det är det första sanningsvärdet det möter i uttrycket. resultat_3 returnerar en tom sträng eftersom det är det sista falska värdet i uttrycket.

Den logiska INTE (!) Operatören

Den logiska NOT (!) operatorn är en unär operator som returnerar det motsatta booleska värdet på sin operand.

Här är syntaxen för NOT-operatorn:

!x

Var x är ett booleskt eller ett sant eller falskt värde.

Här är ett exempel på NOT-operatorn som används:

konst a = 5;
konst b = '';
konst c = Sann;
konst resultat_1 = !a;
trösta.log (resultat_1); // falskt


konst resultat_2 = !b;
trösta.log (resultat_2); // Sann
konst resultat_3 = !c;
trösta.log (resultat_3); // falskt

I exemplet ovan returnerar NOT-operatorn det omvända värdet av de booleska operanderna. När du använder NOT-operatorn i icke-booleska sammanhang (resultat_1 & resultat_2), konverterar den sanna värden till det omvända värdet av Sann och konverterar de falska värdena till det omvända värdet av falsk.

The Nullish Coalescing (??) Operatör

Den nulliska koalescerande operatorn är en logisk operator som utvärderar två operander och returnerar den första operanden om den inte är det null eller odefinierad. Annars returnerar den den andra operanden.

Vid ett ögonkast kan den nulliska koalescerande operatorn verka identisk med den logiska OR (||) operatorn, men så är inte fallet. Den viktigaste skillnaden är att ELLER-operatören returnerar den högra operanden om den vänstra operanden är "vilket som helst" falskt värde, inte bara null eller odefinierad.

Det ger ett kortfattat sätt att välja ett standardvärde när du stöter på null eller odefinierad värden.

Här är syntaxen för den nullish koalescerande operatorn:

x?? y

Här är ett exempel på den nullish koalescerande operatören som används:

konst namn = null;
konst defaultName = "John Doe";
konst resultat_1 = namn?? defaultName;
trösta.log (resultat_1); // "John Doe"


konst ålder = 0;
konst defaultAge = 25;
konst resultat_2 = ålder?? defaultAge;
trösta.log (resultat_2); // 0

I exemplet ovan, resultat_1 returnerar "John Doe" eftersom den första operanden hade ett värde på null. resultat_2 returnerar 0 för även om det är ett falskt värde, är det ingetdera null inte heller odefinierad.

Använda logiska operatorer i din kod

Logiska operatorer används vanligtvis för att skriva villkorliga uttalanden, tilldela standardvärden eller växla booleska värden baserat på villkor.

Genom att använda dessa logiska operatorer kan du skriva mer koncis och uttrycksfull kod som hanterar olika scenarier baserat på sanning eller falskhet i värderingar.