Mga Operator sa TypeScript

Ipinaliliwanag ng artikulong ito ang mga operator sa TypeScript.

YouTube Video

Mga Operator sa TypeScript

Ang mga operator sa TypeScript ay ginagamit para sa mga numerikal na kalkulasyon, paghahambing ng mga halaga, at lohikal na operasyon. Dahil gumagamit ang TypeScript ng mga operator na katulad ng sa JavaScript, madaling masanay dito, ngunit pinapayagan ng TypeScript ang mas mahigpit na mga operasyon gamit ang type safety.

Ang mga pangunahing operator ay ang mga sumusunod:.

Mga Aritmetikong Operator

Ang mga aritmetikong operator ay ginagamit para sa mga numerikal na kalkulasyon.

 1let a = 10; // Initialize variable 'a' with the value 10
 2let b = 3;  // Initialize variable 'b' with the value 3
 3
 4// Perform and display arithmetic operations between 'a' and 'b'
 5console.log("Addition (a + b):      ", a + b); // 13
 6console.log("Subtraction (a - b):   ", a - b); // 7
 7console.log("Multiplication (a * b):", a * b); // 30
 8console.log("Division (a / b):      ", a / b); // 3.333...
 9console.log("Modulus (a % b):       ", a % b); // 1
10
11// Demonstrate post-increment operation on 'a'
12// Output the current value of 'a' (10), then increment
13console.log("Post-increment (a++):  ", a++);
14// Display the incremented value of 'a' (11)
15console.log("Value of 'a' after increment:", a);
16
17// Demonstrate pre-increment operation on 'a'
18// Increment 'a' first (12) then output
19console.log("Pre-increment (++a):   ", ++a);
20
21// Demonstrate post-decrement operation on 'a'
22// Output the current value of 'a' (12), then decrement
23console.log("Post-decrement (a--):  ", a--);
24// Display the decremented value of 'a' (11)
25console.log("Value of 'a' after decrement:", a);
26
27// Demonstrate pre-decrement operation on 'a'
28// Decrement 'a' first (10) then output
29console.log("Pre-decrement (--a):   ", --a);

Mga Assignment Operator

Ang mga assignment operator ay nag-aatas ng halaga sa kanan papunta sa variable sa kaliwa.

1let z = 5;
2z += 3;
3console.log(z);  // Outputs: 8
4
5z *= 2;
6console.log(z);  // Outputs: 16

Mga Operator ng Paghahambing

Ang mga operator ng paghahambing ay naghahambing ng mga halaga at nagbabalik ng true o false.

1console.log('5 == "5"   :', 5 == "5");   // Outputs: true
2console.log('5 === "5"  :', 5 === "5");  // Outputs: false
3console.log('5 != "5"   :', 5 != "5");   // Outputs: false
4console.log('5 !== "5"  :', 5 !== "5");  // Outputs: true
5console.log('5 > 3      :', 5 > 3);      // Outputs: true
6console.log('5 < 3      :', 5 < 3);      // Outputs: false
7console.log('5 >= 5     :', 5 >= 5);     // Outputs: true
8console.log('5 <= 3     :', 5 <= 3);     // Outputs: false

Mga Operator ng Lohika

Ang mga operator ng lohika ay ginagamit upang pagsamahin ang mga lohikal na ekspresyon.

1console.log('true && false :', true && false);  // Outputs: false
2console.log('true || false :', true || false);  // Outputs: true
3console.log('!true         :', !true);          // Outputs: false

Precedence ng Mga Operator ng Lohika

Sa TypeScript, ang mga operator ng lohika ay karaniwang sinusuri sa pagkakasunod-sunod na NOT muna, kasunod ang AND, at sa huli ay OR.

Ang NOT ang May Pinakamataas na Precedence

Ang NOT ay isang unary operator at sinusuri gamit ang pinakamataas na precedence.

1console.log(!true || false);  // false

Ang AND ay Mas Mataas ang Precedence Kaysa sa OR

Ang AND ay may mas mataas na precedence kaysa OR, kaya ang bahagi ng AND ay sinusuri muna.

1console.log(true || false && false);  // true

Bilang resulta, ang bahagi ng AND (&&) ay kinakalkula muna, at ang resulta nito ay ipinapasa sa OR (||).

Ang AND at OR ay Nagsasagawa ng Short-Circuit Evaluation

Sa TypeScript, ang AND at OR ay nagsasagawa ng short-circuit evaluation. Kung ang resulta ay natutukoy na ng halaga sa kaliwa, ang expression sa kanan ay hindi na sinusuri.

1let a = false && console.log("This will not be printed");
2console.log(a);  // false
3
4let b = true || console.log("This will not be printed");
5console.log(b);  // true

Sa parehong kaso, ang console.log() ay hindi na isinasagawa.

Malinaw na Pagtatakda ng Precedence

Ang paggamit ng parentheses upang malinaw na i-grupo ang mga expression ay maaaring makaiwas sa hindi pagkakaintindihan tungkol sa precedence.

1console.log(true || (false && false));  // true

Mga Pagkakaiba sa pagitan ng Likas na Wika at Interpretasyon ng Programa

Kapag gumagamit ng mga operator ng lohika, mahalagang maging maingat sa mga kalabuan sa likas na wika. Halimbawa, sa pariralang 'isang puting aso o isang pusa,' maaari itong mangahulugan ng 'isang puting aso o anumang pusa' o 'isang puting aso o isang puting pusa.'. Sa code, maaari itong maisulat bilang sumusunod:.

1if (isWhite && isDog || isCat) {
2    console.log(' "A white dog" or "a cat of any color" ');
3}
4
5if (isWhite && (isDog || isCat)) {
6    console.log(' "A white dog" or "a white cat" ');
7}

Dahil ang likas na wika ay maaaring malabo, kinakailangan ang pag-iingat kapag nagsusulat ng code at nagdidisenyo ng mga sistema.

Mga Operator ng Bitwise

Ang mga operator ng bitwise ay nagma-manipula ng mga numero sa antas ng bit.

1console.log('5 & 1  :', 5 & 1);   // Outputs: 1  (AND operation)
2console.log('5 | 1  :', 5 | 1);   // Outputs: 5  (OR operation)
3console.log('5 ^ 1  :', 5 ^ 1);   // Outputs: 4  (XOR operation)
4console.log('~5     :', ~5);      // Outputs: -6 (NOT operation)
5console.log('5 << 1 :', 5 << 1);  // Outputs: 10 (Left shift operation)
6console.log('5 >> 1 :', 5 >> 1);  // Outputs: 2  (Right shift operation)
7console.log('5 >>> 1:', 5 >>> 1); // Outputs: 2  (Unsigned right shift operation)

Ternary Operator

Ang ternary operator ay nagbabalik ng iba't ibang halaga batay sa resulta ng isang kondisyonal na ekspresyon.

1let age = 20;
2let access = (age >= 18) ? "Allowed" : "Denied";
3console.log(access);  // Outputs: Allowed

Mga Uri ng Operator

Kasama sa mga uri ng operator ng TypeScript ang mga sumusunod:.

 1console.log(typeof "Hello");  // "string"
 2console.log(typeof 42);       // "number"
 3
 4let arr: number[] = [1, 2, 3];
 5console.log("arr instanceof Array : ", arr instanceof Array); // true
 6
 7// Example of Type Guard
 8function isString(value: any): value is string {
 9  return typeof value === "string";
10}
11
12let value: any = "Hello";
13if (isString(value)) {
14  console.log("Value is a string:", value);  // "Value is a string: Hello"
15}

Ang mga uri ng operator ay ginagamit upang suriin ang uri ng isang halaga o i-convert ito sa isang partikular na uri.

• Ang typeof na operator ay ibinabalik ang uri ng isang variable.
• Ang instanceof na operator ay sinusuri kung ang isang object ay kabilang sa isang partikular na klase.
• Ang is na operator ay ginagamit upang suriin kung ang isang halaga ay nasa isang partikular na uri. Ito ay bahagi ng mga type guard ng TypeScript.

Buod

• Arithmetic Operators: Gumagawa ng mga pangunahing kalkulasyon.
• Assignment Operators: Nagtatalaga ng mga halaga sa mga variable.
• Comparison Operators: Inihahambing ang mga halaga.
• Logical Operators: Pinagsasama ang mga lohikal na kondisyon.
• Bitwise Operators: Gumagawa ng mga operasyon sa antas ng bit.
• Ternary Operator: Nagbabalik ng mga halaga batay sa mga kondisyon.
• Maaaring suriin ng mga uri ng operator ang uri ng isang halaga.

Sa TypeScript, ang mga operator na ito ay maaaring gamitin upang magsulat ng mga kumplikadong kalkulasyon at kondisyonal na ekspresyon nang mahusay.

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