`truthy` dan `falsy` dalam TypeScript

Dalam artikel ini, kami akan menerangkan truthy dan falsy dalam TypeScript.

YouTube Video

truthy dan falsy dalam TypeScript

Konsep truthy dan falsy dalam TypeScript memainkan peranan penting dalam pernyataan bersyarat dalam program. Di sini, kami akan menerangkan konsep ini secara terperinci dan bagaimana ia sebenarnya digunakan. Selain itu, kami menyediakan contoh kod TypeScript khusus untuk memahami bagaimana nilai truthy dan falsy ditangani.

Apa itu truthy dan falsy?

Dalam JavaScript dan TypeScript, sebarang nilai dinilai sebagai benar (true) atau palsu (false) dalam ungkapan bersyarat. Nilai-nilai ini secara logik dikelaskan sebagai truthy atau falsy.

• truthy merujuk kepada nilai yang dinilai sebagai true dalam ungkapan bersyarat.
• falsy merujuk kepada nilai yang dinilai sebagai false dalam ungkapan bersyarat.

Dalam TypeScript, nilai-nilai berikut dianggap sebagai falsy:.

2. Nombor 0
3. "" (rentetan kosong)

Semua nilai lain dianggap sebagai truthy.

Contoh Khusus bagi truthy dan 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");

Kondisional yang menggunakan truthy dan falsy

Konsep truthy dan falsy sering digunakan dalam pernyataan bersyarat dan gelung. Sebagai contoh, dalam pernyataan if atau gelung while, anda boleh menggunakan nilai-nilai ini secara langsung untuk penilaian bersyarat ringkas.

 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}

Mengendalikan Nilai falsy dengan ?? (Penggabungan Nullish) dan || (OR Logik)

Dalam TypeScript, terdapat beberapa operator yang berguna ketika berurusan dengan nilai falsy. Khususnya, Operator Nullish Coalescing (??) dan operator logik OR (||) sering digunakan.

|| (Logical OR)

Operator logik OR digunakan untuk menggantikan nilai falsy dengan nilai lalai. Namun, semua nilai falsy (bukan hanya null atau undefined, tetapi juga 0, "", dll.) menjadi sasaran.

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

??（Nullish Coalescing）

Operator Nullish Coalescing hanya mengenakan nilai lalai kepada null atau undefined, dan membiarkan nilai falsy lain (seperti 0 atau "") tidak berubah.

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

Perangkap Berkaitan dengan truthy dan falsy

Satu perkara penting yang perlu diberi perhatian ketika memahami truthy dan falsy ialah nilai-nilai yang tidak disengajakan mungkin dianggap sebagai falsy. Contohnya, 0 dan rentetan kosong "" adalah nilai-nilai yang sah, tetapi ia dianggap sebagai falsy dalam pernyataan bersyarat, yang mungkin menyebabkan penilaian yang salah.

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}

Dalam situasi seperti ini, menggunakan operator perbandingan ketat membolehkan anda membezakan nilai seperti 0 dan false dengan tepat.

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

Perangkap yang berkaitan dengan falsy dan NaN

NaN memerlukan pengendalian khas kerana ia tidak sama dengan mana-mana nilai, termasuk dirinya sendiri, apabila menggunakan operator perbandingan.

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

Oleh itu, lebih selamat menggunakan Number.isNaN() untuk mengesan NaN dengan tepat.

 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}

Oleh itu, NaN tidak sama dengan dirinya sendiri, jadi perbandingan dengan NaN sentiasa menghasilkan false. Dengan menggunakan Number.isNaN() sebaliknya, anda boleh melakukan pemeriksaan yang lebih dipercayai.

Kesimpulan

Konsep truthy dan falsy dalam TypeScript sangat berguna, tetapi anda perlu berhati-hati dengan nilai-nilai tertentu, terutamanya 0 dan rentetan kosong. Apabila menggunakan nilai-nilai ini dalam pemeriksaan bersyarat, menggunakan perbandingan ketat (===) atau Operator Nullish Coalescing (??) dan bukannya perbandingan longgar (==) dapat membantu mengelakkan tingkah laku yang tidak dijangka.

Anda boleh mengikuti artikel di atas menggunakan Visual Studio Code di saluran YouTube kami. Sila lihat juga saluran YouTube kami.

YouTube Video