`truthy` og `falsy` i TypeScript

I denne artikkelen skal vi forklare truthy og falsy i TypeScript.

YouTube Video

truthy og falsy i TypeScript

Konseptene truthy og falsy i TypeScript spiller en svært viktig rolle i programbetingede uttalelser. Her vil vi forklare disse konseptene i detalj og hvordan de faktisk brukes. Videre gir vi spesifikke TypeScript-eksempler for å forstå hvordan truthy og falsy verdier håndteres.

Hva er truthy og falsy?

I JavaScript og TypeScript evalueres enhver verdi som sann (true) eller falsk (false) i en betinget uttrykk. Disse verdiene er logisk klassifisert som truthy eller falsy.

• truthy refererer til verdier som evalueres som true i betingede uttrykk.
• falsy refererer til verdier som evalueres som false i betingede uttrykk.

I TypeScript behandles følgende verdier som falsy:.

2. Tallet 0
3. "" (tom streng)

Alle andre verdier behandles som truthy.

Spesifikke eksempler på truthy og falsy

 1// Examples of falsy values
 2console.log("0 is", Boolean(0) ? "truthy" : "falsy");
 3console.log('"" is', Boolean("") ? "truthy" : "falsy");
 4console.log("null is", Boolean(null) ? "truthy" : "falsy");
 5console.log("undefined is", Boolean(undefined) ? "truthy" : "falsy");
 6console.log("NaN is", Boolean(NaN) ? "truthy" : "falsy");
 7
 8// Examples of truthy values
 9console.log("1 is", Boolean(1) ? "truthy" : "falsy");
10console.log('"hello" is', Boolean("hello") ? "truthy" : "falsy");
11console.log("[] is", Boolean([]) ? "truthy" : "falsy");
12console.log('" " (space) is', Boolean(" ") ? "truthy" : "falsy");

Betingelser ved bruk av truthy og falsy

Konseptene truthy og falsy brukes ofte i betingelser og løkker. For eksempel, i if-setninger eller while-løkker, kan du bruke disse verdiene direkte for enkle betingede evalueringer.

 1// Checking if the length of the array is 0
 2let items: string[] = [];
 3
 4if (items.length) {
 5    console.log("The array is not empty");
 6} else {
 7    console.log("The array is empty");
 8}
 9
10// Checking if the input value is empty
11let input = "";
12
13if (input) {
14    console.log("Input has value");
15} else {
16    console.log("Input is empty"); // This will be executed
17}

Håndtering av falsy-verdier med ?? (nullsammenslåing) og || (logisk ELLER)

I TypeScript finnes det flere operatorer som er nyttige når man arbeider med falsy verdier. Spesielt Nullish Coalescing Operator (??) og logisk ELLER-operatør (||) er ofte brukt.

|| (Logisk ELLER)

Den logiske ELLER-operatøren brukes til å erstatte falsy verdier med en standardverdi. Imidlertid er alle verdier som anses som falsy (ikke bare null og undefined, men også 0 og tomme strenger "") også inkludert.

1let username = "";
2let displayName = username || "Guest";
3// Since username is empty, "Guest" is assigned
4
5console.log(displayName); // "Guest"

??（Nullish Coalescing）

Den nullish sammenslåingsoperatoren bruker standardverdien kun på null eller undefined, og behandler andre falsy verdier som 0 eller tomme strenger "" som de er.

1let username2 = "";
2let displayName2 = username2 ?? "Guest";
3// The empty string is retained
4// since username2 is not null or undefined
5
6console.log(displayName2); // ""

Fallgruver knyttet til truthy og falsy

Et viktig punkt å være oppmerksom på når man forstår truthy og falsy er at utilsiktede verdier kan bli behandlet som falsy. For eksempel er 0 og tomme strenger "" gyldige verdier, men de regnes som falsy i betingede utsagn, noe som kan føre til feil evalueringer.

1let score = 0;
2
3if (score) {
4    console.log("You have a score!"); // This will not be executed
5} else {
6    console.log("No score available"); // This will be executed
7}

I slike tilfeller lar bruk av strenge sammenligningsoperatører deg nøyaktig skille mellom verdier som 0 og false.

1let score = 0;
2
3if (score === 0) {
4    console.log("Score is zero"); // Correctly evaluated
5}

Fallgruver relatert til falsy og NaN

NaN krever spesiell behandling fordi det ikke er lik noen verdi, inkludert seg selv, når man bruker sammenligningsoperatører.

1console.log("NaN === NaN:", NaN === NaN); // false

Derfor er det tryggere å bruke Number.isNaN() for å nøyaktig oppdage NaN.

 1// Bad Example
 2let value = parseInt("0");
 3if (!value) {
 4    console.log("Value is NaN(Incorrect)"); // Incorrectly treats 0 as NaN
 5}
 6
 7// Good Example
 8let value2 = parseInt("hello");
 9if (Number.isNaN(value2)) {
10    console.log("Value is NaN(Correct)"); // Correctly identifies NaN
11}

Som sådan er NaN ikke engang lik seg selv, så sammenligninger med NaN returnerer alltid false. Ved å bruke Number.isNaN() i stedet kan du utføre mer pålitelige kontroller.

Konklusjon

Konseptene truthy og falsy i TypeScript er veldig praktiske, men du må være forsiktig med visse verdier, spesielt 0 og tomme strenger. Når du bruker disse verdiene i betingede sjekker, kan bruk av streng sammenligning (===) eller Nullish Coalescing Operator (??) i stedet for løs sammenligning (==) bidra til å unngå uventet atferd.

Du kan følge med på artikkelen ovenfor ved å bruke Visual Studio Code på vår YouTube-kanal. Vennligst sjekk ut YouTube-kanalen.

YouTube Video