`truthy` at `falsy` sa TypeScript

Sa artikulong ito, ipapaliwanag namin ang truthy at falsy sa TypeScript.

YouTube Video

truthy at falsy sa TypeScript

Ang mga konsepto ng truthy at falsy sa TypeScript ay may napakahalagang papel sa mga kondisyonal na pahayag sa programa. Dito, ipapaliwanag namin ang mga konseptong ito nang detalyado at kung paano sila talaga ginagamit. Bukod pa rito, magbibigay kami ng mga partikular na halimbawa ng code sa TypeScript upang maunawaan kung paano pinapamahalaan ang mga truthy at falsy na halaga.

Ano ang truthy at falsy?

Sa JavaScript at TypeScript, ang anumang halaga ay sinusuri bilang true (true) o false (false) sa isang kondisyonal na pahayag. Ang mga halagang ito ay lohikal na ikinategorya bilang truthy o falsy.

• truthy ay tumutukoy sa mga halaga na itinuturing na true sa mga ekspresyong may kondisyon.
• falsy ay tumutukoy sa mga halaga na itinuturing na false sa mga ekspresyong may kondisyon.

Sa TypeScript, ang mga sumusunod na halaga ay itinuturing na falsy:.

2. Ang numerong 0
3. "" (walang laman na string)

Ang lahat ng iba pang mga halaga ay itinuturing bilang truthy.

Mga Espesipikong Halimbawa ng truthy at 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");

Mga Kondisyon na Ginagamit ang truthy at falsy

Ang mga konsepto ng truthy at falsy ay madalas na ginagamit sa mga kondisyon at loop. Halimbawa, sa mga pahayag na if o while loop, maaari mong direktang gamitin ang mga halagang ito para sa mga simpleng kondisyonal na pagsusuri.

 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}

Paghawak sa mga falsy na Halaga gamit ang ?? (Nullish Coalescing) at || (Logical OR)

Sa TypeScript, may ilang mga operator na kapaki-pakinabang kapag humaharap sa mga falsy na halaga. Partikular, ang Nullish Coalescing Operator (??) at ang logical OR operator (||) ay karaniwang ginagamit.

|| (Logical OR)

Ang logical OR operator ay ginagamit upang palitan ang mga falsy na halaga ng default na halaga. Gayunpaman, lahat ng mga falsy na halaga (hindi lamang null o undefined, kundi pati na rin ang 0, "", atbp.) ay saklaw.

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

??（Nullish Coalescing）

Ang Nullish Coalescing Operator ay nag-aaplay ng default na halaga lamang sa null o undefined, at iniiwan ang ibang mga falsy na halaga (gaya ng 0 o "") na hindi binabago.

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

Mga Pagkakamali Kaugnay sa truthy at falsy

Isang mahalagang punto na dapat pag-ingatan kapag nauunawaan ang truthy at falsy ay ang hindi inaasahang mga halaga ay maaaring ituring na falsy. Halimbawa, ang 0 at ang walang laman na mga string "" ay mga wastong halaga, ngunit itinuturing silang falsy sa mga conditional na pahayag, na maaaring magresulta sa mga maling pagsusuri.

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}

Sa mga ganitong kaso, ang paggamit ng mahigpit na paghahambing na operator ay nagbibigay-daan sa iyo na tumpak na maiba ang mga halaga tulad ng 0 at false.

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

Mga panganib na may kaugnayan sa falsy at NaN

Ang NaN ay nangangailangan ng espesyal na paghawak dahil hindi ito katumbas ng anumang halaga, kasama na ang sarili nito, kapag gumagamit ng mga operator na paghahambing.

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

Samakatuwid, mas ligtas na gamitin ang Number.isNaN() upang tumpak na matukoy ang NaN.

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

Dahil dito, ang NaN ay hindi pantay sa sarili nito, kaya ang mga paghahambing gamit ang NaN ay laging nagbabalik ng false. Sa halip, sa paggamit ng Number.isNaN(), maaari kang magsagawa ng mas maaasahang mga pagsusuri.

Konklusyon

Ang mga konsepto ng truthy at falsy sa TypeScript ay napaka-kombinyente, ngunit kailangan mong mag-ingat sa ilang partikular na halaga, lalo na ang 0 at walang laman na mga string. Kapag ginagamit ang mga halagang ito sa mga pagsusuri ng kondisyon, ang paggamit ng mahigpit na paghahambing (===) o ng Nullish Coalescing Operator (??) sa halip na maluwag na paghahambing (==) ay makakatulong na maiwasan ang hindi inaasahang pag-uugali.

Maaari mong sundan ang artikulo sa itaas gamit ang Visual Studio Code sa aming YouTube channel. Paki-check din ang aming YouTube channel.

YouTube Video