Logische operatoren gebruiken in JavaScript

Met logische operatoren kunt u logische bewerkingen uitvoeren op booleaanse waarden. Ze laten u Booleaanse waarden combineren, ontkennen of vergelijken en logische beslissingen nemen in uw code op basis van het resultaat.

Verken de verschillende logische operatoren die JavaScript ondersteunt, waaronder de ES6 Nullish-coalescentieoperator.

De logische AND (&&) operator

De AND (&&) operator is een logische operator die terugkomt WAAR als beide operanden resulteren in WAAR En vals anders.

Dit is de syntaxis van de AND-operator:

een && b

Hier is een voorbeeld van de AND-operator die wordt gebruikt:

const een = 5;
const b = 10;
const c = 15;
const resultaat_1 = (a < b) && (b < c);
troosten.log (resultaat_1); // WAAR
const resultaat_2 = (a > b) && (b < c);
troosten.log (resultaat_2); // vals

In dit voorbeeld resultaat_1 evalueert naar WAAR omdat de twee operanden in de expressie resulteren in

WAAR. Echter, resultaat_2 evalueert naar vals omdat de eerste operand (een > b) geeft terug vals.

Als beide operanden geen booleans zijn, JavaScript zal proberen ze te converteren in booleaanse waarden voordat u de uitdrukking evalueert. Om ze om te zetten in booleans, evalueert JavaScript eerst of de waarden waar of onwaar zijn.

JavaScript beschouwt elke waarde die niet expliciet vals is, als een waarheidsgetrouwe waarde. Wanneer ze worden geconverteerd, evalueren ze naar een Booleaanse waarde WAAR.

Echter, bepaalde waarden en gegevenstypen in JavaScript zijn vals, dus wanneer JavaScript ze converteert, evalueren ze naar een boolean vals.

De valse waarden in JavaScript zijn:

• vals
• nul
• ongedefinieerd
• NaN (Geen nummer)
• 0
• BigInt (0n)
• Lege tekenreeks ("" of '' of ``)
• ongedefinieerd

Wanneer u de AND-operator gebruikt om niet-booleaanse waarden te evalueren, retourneert de uitdrukking onmiddellijk de waarde van de eerste operand als de operand onwaar is, zonder de tweede te evalueren. Dit gedrag staat bekend als kortsluiting en u kunt het gebruiken om te schrijven voorwaardelijke verklaringen in JavaScript.

Als de eerste operand echter waar is, gaat de uitdrukking verder met het evalueren van de tweede operand. Als de tweede operand waar is, wordt deze geretourneerd.

Bijvoorbeeld:

const een = 5;
const b = 'Hallo';
const c = nul;
const resultaat_1 = een && b;
troosten.log (resultaat_1); // "Hallo"
const resultaat_2 = c && b;
troosten.log (resultaat_2); // nul

In dit voorbeeld resultaat_1 resulteert in "Hallo" omdat beide operanden in de uitdrukking waarheidsgetrouw zijn. Echter, resultaat_2 kortsluitingen en retouren nul zonder de tweede operand te evalueren.

Merk op dat als er meer operanden zijn, de AND-operator ze zal blijven evalueren totdat hij een valse waarde tegenkomt. Als het geen valse waarde tegenkomt, retourneert het de laatste waarheidswaarde die het tegenkomt.

De logische OR-operator (||).

De OR-operator (||) is een logische operator die terugkeert WAAR als en slechts als een of meer van zijn operanden dat is WAAR. Het keert alleen maar terug vals wanneer beide operanden zijn vals.

Dit is de syntaxis van de OR-operator:

een || B

Hier is een voorbeeld van de gebruikte OR-operator:

const een = 5;
const b = 10;
const c = 15;
const resultaat_1 = (a < b) || (b < c);
troosten.log (resultaat_1); // WAAR
const resultaat_2 = (a > b) || (b < c);
troosten.log (resultaat_2); // WAAR
const resultaat_3 = (a > b) || (b > c);
troosten.log (resultaat_3); // vals

In het bovenstaande voorbeeld resultaat_1 evalueert naar WAAR omdat beide operanden in de expressie resulteren in WAAR. resultaat_2 evalueert naar WAAR omdat de tweede operand resulteert in WAAR. resultaat_3 evalueert naar vals omdat de twee operanden in de expressie resulteren in vals.

Wanneer u de OR-operator gebruikt in niet-booleaanse contexten, probeert JavaScript om te zetten in booleaanse waarden voordat de uitdrukking wordt geëvalueerd.

Wanneer de uitdrukking wordt geëvalueerd en de eerste operand waar is, maakt de operator kortsluiting en retourneert deze. Als het echter vals is, gaat het verder met het evalueren van de volgende operand totdat het een waarheidsgetrouwe operand tegenkomt. Als er geen waarheidsoperanden in de uitdrukking staan, retourneert deze de laatste onjuiste waarde die wordt aangetroffen.

Bijvoorbeeld:

const een = 5;
const b = 'Hallo';
const c = nul;
const resultaat_1 = een || B;
troosten.log (resultaat_1); // 5
const resultaat_2 = c || B;
troosten.log (resultaat_2); // "Hallo"
const resultaat_3 = c || " ";
troosten.log (resultaat_3); // " "

In het bovenstaande voorbeeld resultaat_1 kortsluitingen en retouren 5 omdat het een waarheidsgetrouwe waarde is. resultaat_2 retourneert "Hallo" omdat dit de eerste waarheidswaarde is die in de uitdrukking wordt aangetroffen. resultaat_3 geeft een lege tekenreeks terug omdat dit de laatste foutieve waarde in de uitdrukking is.

De logische NOT (!) operator

De logische operator NOT (!) is een unaire operator die de tegengestelde booleaanse waarde van zijn operand retourneert.

Dit is de syntaxis van de NOT-operator:

!X

Waar X is een boolean of een waarheids- of valse waarde.

Hier is een voorbeeld van de NOT-operator die wordt gebruikt:

const een = 5;
const b = '';
const c = WAAR;
const resultaat_1 = !a;
troosten.log (resultaat_1); // vals
const resultaat_2 = !b;
troosten.log (resultaat_2); // WAAR
const resultaat_3 = !c;
troosten.log (resultaat_3); // vals

In het bovenstaande voorbeeld retourneert de NOT-operator de inverse waarde van de booleaanse operanden. Wanneer u de NOT-operator gebruikt in niet-booleaanse contexten (resultaat_1 & resultaat_2), converteert het waarheidswaarden naar de inverse waarde van WAAR en converteert de valse waarden naar de inverse waarde van vals.

De Nullish Coalescerende (??) Operator

De nullish-coalescerende operator is een logische operator die twee operanden evalueert en de eerste operand retourneert als dat niet het geval is nul of ongedefinieerd. Anders wordt de tweede operand geretourneerd.

Op het eerste gezicht lijkt de nullish-coalescentie-operator identiek aan de logische OR-operator (||), maar dat is niet het geval. Het belangrijkste verschil is dat de OR-operator de operand aan de rechterkant retourneert als de linker operand "elke" foutieve waarde is, niet alleen nul of ongedefinieerd.

Het biedt een beknopte manier om een ​​standaardwaarde te kiezen bij het tegenkomen nul of ongedefinieerd waarden.

Dit is de syntaxis voor de nullish-coalescentie-operator:

X?? j

Hier is een voorbeeld van de nullish-coalescentie-operator die wordt gebruikt:

const naam = nul;
const standaardNaam = "John Doe";
const resultaat_1 = naam?? standaardNaam;
troosten.log (resultaat_1); // "John Doe"
const leeftijd = 0;
const standaardLeeftijd = 25;
const resultaat_2 = leeftijd?? standaardLeeftijd;
troosten.log (resultaat_2); // 0

In het bovenstaande voorbeeld resultaat_1 geeft "John Doe" terug omdat de eerste operand de waarde had van nul. resultaat_2 geeft terug 0 want hoewel het een valse waarde is, is het geen van beide nul noch ongedefinieerd.

Logische operatoren gebruiken in uw code

Logische operatoren worden vaak gebruikt om voorwaardelijke verklaringen te schrijven, standaardwaarden toe te wijzen of booleaanse waarden in te schakelen op basis van voorwaarden.

Door deze logische operatoren te gebruiken, kunt u beknoptere en expressievere code schrijven die verschillende scenario's afhandelt op basis van de juistheid of onjuistheid van waarden.