Mga Operator sa JavaScript

Sa artikulong ito, ipapaliwanag namin ang mga operator sa JavaScript.

YouTube Video

Mga Operator sa JavaScript

Ang mga operator sa JavaScript ay mga simbolo o keyword na ginagamit upang magsagawa ng mga kalkulasyon o paghahambing sa mga numero at variable. Mayroong iba't ibang uri ng mga operator, na bawat isa ay gumaganap ng magkaibang operasyon. Narito ang ilan sa mga pangunahing operator na buod:.

Arithmetic na Mga Operator

Kasama sa mga arithmetic operators ng JavaScript ang mga sumusunod:.

 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);

Ang mga arithmetic operator ay gumaganap ng mga pangunahing matematikal na operasyon sa mga numero. Bukod sa pagdaragdag at pagbabawas, maaari kang magsagawa ng mga operasyon tulad ng modulus, pagtaas, at pagbawas. Tandaan na ang halagang ibinalik ng pagtaas o pagbawas ay nagkakaiba depende kung ang operator ay inilagay bago o pagkatapos ng operand.

Mga Operator sa Pag-atas (Assignment Operators)

Kasama sa mga assignment operators ng JavaScript ang mga sumusunod:.

 1let x = 10;
 2
 3x += 5;  // x = x + 5, so x becomes 15
 4console.log('After x += 5 : ', x);  // 15
 5
 6x -= 10;
 7console.log('After x -= 10 : ', x);  // 5
 8
 9x *= 3;
10console.log('After x *= 3 : ', x);  // 15
11
12x /= 3;
13console.log('After x /= 3 : ', x);  // 5
14
15x %= 2;
16console.log('After x %= 2 : ', x);  // 1

Ang mga operator ng pag-assign ay ginagamit upang magtalaga ng mga halaga sa mga variable o i-update ang mga halaga ng mga variable. Bukod sa karaniwang pag-assign, may mga operator ng pag-assign para sa mga operasyon ng aritmetika tulad ng pagdaragdag at modulus.

Mga Operator ng Paghahambing

Kasama sa mga comparison operators ng JavaScript ang mga sumusunod:.

 1console.log("5 == '5' evaluates to:", 5 == "5");   // true (because the values are equal)
 2console.log("5 === '5' evaluates to:", 5 === "5"); // false (because the types are different)
 3console.log("5 != '5' evaluates to:", 5 != "5");   // false
 4console.log("5 !== '5' evaluates to:", 5 !== "5"); // true
 5console.log("5 > 2 evaluates to:", 5 > 2);         // true
 6console.log("5 < 2 evaluates to:", 5 < 2);         // false
 7console.log("5 >= 5 evaluates to:", 5 >= 5);       // true
 8console.log("5 <= 4 evaluates to:", 5 <= 4);       // false
 9console.log("5 >= '5' evaluates to:", 5 >= "5");   // true
10console.log("5 <= '5' evaluates to:", 5 <= "5");   // true

• Ang mga operator ng paghahambing ay naghahambing ng mga halaga at nagbabalik ng true o false.
• Ang equality operator (==) ay awtomatikong nagko-convert ng iba't ibang uri kung kinakailangan bago isagawa ang paghahambing. Ang strict equality operator (===) ay hindi nagsasagawa ng anumang conversion ng uri habang naghahambing at nagbabalik ng true lamang kung ang parehong mga halaga ay may parehong uri at parehong halaga. Ang paggamit ng strict equality operator (===) ay nakakatulong na maiwasan ang mga bug na dulot ng hindi sinasadyang conversion ng uri, kaya inirerekomenda na ito ang gamitin nang mas madalas.

Mga Operator na Lohikal

Kasama sa mga logical operators ng JavaScript ang mga sumusunod:.

1let a = true;
2let b = false;
3
4console.log("a && b evaluates to:", a && b);  // false
5console.log("a || b evaluates to:", a || b);  // true
6console.log("!a evaluates to:", !a);          // false

Ang mga operator na lohikal ay ginagamit kapag mayroong maraming kundisyon, upang suriin ang mga kumbinasyon ng kundisyon.

Prayoridad ng Logical Operators

Sa JavaScript, ang mga logical operators ay karaniwang sinusuri sa pagkakasunod-sunod na NOT muna, pagkatapos AND, at sa huli OR.

Ang NOT ang may pinakamataas na prayoridad

Ang NOT ay isang unary operator at sinusuri ito na may pinakamataas na prayoridad.

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

Ang AND ay may mas mataas na prayoridad kaysa OR

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

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

Sa ganitong paraan, ang bahagi ng AND (&&) ay sinusuri muna, at ang resulta nito ay ipinapasa sa OR (||).

Ang AND at OR ay gumagamit ng short-circuit evaluation

Ang AND at OR ng JavaScript ay gumagamit ng short-circuit evaluation. Kung ang resulta ay maaaring matukoy sa pamamagitan ng left-side value, ang right-side expression 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 alinmang kaso, ang console.log() ay hindi ito maipapatupad.

Itakda ang malinaw na prayoridad

Sa pamamagitan ng malinaw na paggrupo ng mga expression gamit ang panaklong, maiiwasan mo ang mga hindi pagkakaunawaan tungkol sa pagkakasunod-sunod ng priyoridad.

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

Pagkakaiba sa pagitan ng natural na wika at interpretasyon ng programa

Kapag gumagamit ng logical operators, mahalagang maunawaan ang mga kalabuan sa natural na wika. Halimbawa, kapag sinabi ang 'puting aso o pusa,' maaaring mangahulugan ito ng 'isang puting aso o anumang kulay ng pusa' o 'isang puting aso o isang puting pusa.'. Sa code, ganito ito magmumukha:.

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}
8
9console.log(true || (false && false));  // true

Dahil ang natural na wika ay naglalaman ng mga kalabuan tulad nito, kinakailangan ang pag-iingat sa pag-code o pagdidisenyo.

Ternary Operator (Operator na Kondisyunal)

Ang JavaScript ay may kasamang ternary operator (conditional operator).

1let age = 20;
2let message = age >= 18 ? "Adult" : "Minor";
3console.log(message);  // "Adult"

Ito ay isinusulat sa anyo ng condition ? value kung true : value kung false.

Mga Operator na Bitwise

Ang bitwise operators sa JavaScript ay kinabibilangan ng mga sumusunod.

 1let x = 0x0F & 0x0C;
 2console.log("0x0F & 0x0C evaluates to:", x, "(0x0C, 12)");  // 0x0C (12)
 3
 4x = 0x04 | 0x02;
 5console.log("0x04 | 0x02 evaluates to:", x, "(0x06, 6)");  // 0x06 (6)
 6
 7x = 0x0F ^ 0x0C;
 8console.log("0x0F ^ 0x0C evaluates to:", x, "(0x03, 3)");  // 0x03 (3)
 9
10// The inverted number is represented as a negative value
11// because JavaScript numbers are stored as signed 32-bit integers.
12x = ~0x0C;
13console.log("~0x0C evaluates to:", x, "(-13, 0xF3)");  // 0xF3 (-13)
14
15x = 0x04 << 1;
16console.log("0x04 << 1 evaluates to:", x, "(0x08, 8)");    // 0x08 (8)
17x = 0x04 >> 1;
18console.log("0x04 >> 1 evaluates to:", x, "(0x02, 2)");    // 0x02 (2)

Ang mga bit operator ay gumagawa ng kalkulasyon sa mga numero sa antas ng bit. Karaniwan silang ginagamit para sa mababang antas ng pagproseso.

Mga Operator ng Uri

Ang type operators sa JavaScript ay kinabibilangan ng mga sumusunod.

1console.log(typeof "Hello");  // "string"
2console.log(typeof 42);       // "number"
3
4let arr = [1, 2, 3];
5console.log("arr instanceof Array : ", arr instanceof Array); // true

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

Ang typeof operator ay nagbabalik ng uri ng isang variable.

Ang instanceof operator ay nagche-check kung ang isang object ay kabilang sa isang partikular na klase.

Buod

• Ang mga operator ng aritmetika ay gumagawa ng mga pangunahing kalkulasyon.
• Ang mga operator ng asignasyon ay nag-aasign o nag-uupdate ng mga halaga sa mga variable.
• Ang mga operator ng komparasyon ay naghahambing ng dalawang halaga at nagbabalik ng true o false.
• Ang mga operator ng lohikal ay sumusuri ng mga kombinasyon ng kondisyon.
• Ang mga ternary operator ay nagbibigay-daan sa iyo na magsulat ng mga conditional statement sa mas maikling anyo kaysa if.
• Ang mga bitwise operator ay gumagawa ng kalkulasyon sa antas ng bit.
• Ang mga operator ng uri ay nagpapahintulot sa iyo na suriin ang uri ng isang halaga.

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