אופרטורים ב-JavaScript

אופרטורים ב-JavaScript

במאמר זה, נסביר על האופרטורים ב-JavaScript.

YouTube Video

אופרטורים ב-JavaScript

אופרטורים ב-JavaScript הם סמלים או מילות מפתח המשמשות לביצוע חישובים או השוואות על מספרים ומשתנים. קיימים סוגים שונים של אופרטורים, שלכל אחד מהם יש פעולות שונות. להלן סיכום של כמה מהאופרטורים המרכזיים:.

אופרטורים אריתמטיים

האריתמטיים של JavaScript אופרטורים כוללים את הבאים:.

אופרטור תיאור דוגמה תוצאה
+ חיבור 5 + 2 7
- חיסור 5 - 2 3
* כפל 5 * 2 10
/ חילוק 5 / 2 2.5
% מודולוס (שארית) 5 % 2 1
++ אינקרמנט (הגדלה ב-1) let x = 5; x++ 6
-- דקרמנט (הפחתה ב-1) let x = 5; x-- 4
 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);

אופרטורים אריתמטיים מבצעים פעולות מתמטיות בסיסיות על מספרים. בנוסף לחיבור וחיסור, ניתן לבצע פעולות כמו מודולוס, אינקרמנט ודקרמנט. שימו לב שהערך המוחזר על ידי אינקרמנט או דקרמנט משתנה בהתאם למיקום האופרטור לפני או אחרי המשתנה.

אופרטורים של השמה

אופרטורי ההשמה של JavaScript כוללים את הבאים:.

אופרטור תיאור דוגמה תוצאה
= השמה x = 5 הערך 5 מוקצה ל-x
+= השמה עם חיבור x += 5 x = x + 5
-= השמה עם חיסור x -= 5 x = x - 5
*= השמה עם כפל x *= 5 x = x * 5
/= השמה עם חילוק x /= 5 x = x / 5
%= השמה עם אופרטור מודולוס x %= 5 x = x % 5
 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

אופרטורי השמה משמשים להקצות ערכים למשתנים או לעדכן את הערכים של משתנים. בנוסף להשמה רגילה, קיימים אופרטורי השמה לפעולות אריתמטיות כמו חיבור ומודולוס.

אופרטורי השוואה

אופרטורי השוואה של JavaScript כוללים את הבאים:.

אופרטור תיאור דוגמה תוצאה
== שווה 5 == "5" true
=== שווה לחלוטין (גם הסוג וגם הערך שווים) 5 === "5" false
!= לא שווה 5 != "5" false
!== לא שווה לחלוטין 5 !== "5" true
> גדול מ- 5 > 2 true
< קטן מ- 5 < 2 false
>= גדול או שווה ל- 5 >= 5 true
<= קטן או שווה ל- 5 <= 4 false
 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
  • אופרטורי השוואה משווים ערכים ומחזירים אמת או שקר.
  • אופרטור השוויון (==) ממיר סוגים שונים באופן אוטומטי במידת הצורך לפני ביצוע ההשוואה. אופרטור השוויון הקפדני (===) לא מבצע המרה של סוגים במהלך ההשוואה ומחזיר true רק אם לשני הערכים יש אותו סוג ואותה ערך. שימוש באופרטור השוויון הקפדני (===) מסייע במניעת באגים הנגרמים מהמרה בלתי צפויה של סוגים, ולכן מומלץ להשתמש בו בעדיפות.

אופרטורים לוגיים

אופרטורים לוגיים של JavaScript כוללים את הבאים:.

אופרטור תיאור דוגמה תוצאה
&& וגם (אמת אם שני התנאים הם אמת) true && false false
|| או (אמת אם אחד מהתנאים הוא אמת) true || false true
! שלילה (הופך אמת לשקר ושקר לאמת) !true false
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

אופרטורים לוגיים משמשים כאשר ישנם מספר תנאים, להערכת שילובים של תנאים.

סדר קדימויות של אופרטורים לוגיים

ב-JavaScript, אופרטורים לוגיים מוערכים בדרך כלל בסדר: NOT ראשון, ואחריו AND, ולבסוף OR.

NOT בעל קדימות גבוהה ביותר

NOT הוא אופרטור יונארי ומוערך עם הקדימות הגבוהה ביותר.

1console.log(!true || false);  // false
AND קודם ל-OR מבחינת סדר הקדימויות

AND הוא בעל קדימות גבוהה יותר מ-OR, ולכן ה-AND מוערך קודם.

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

בדרך זו, החלק של AND (&&) מוערך ראשון, והתוצאה שלו מועברת ל-OR (||).

AND ו-OR מבצעים הערכה מקוצרת

AND ו-OR של JavaScript מבצעים הערכה מקוצרת. אם ניתן לקבוע את התוצאה על פי הערך שבצד השמאלי, הביטוי שבצד הימני לא יוערך.

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

בכל מקרה, console.log() לא יבוצע.

קבעו סדר קדימויות מפורש

על ידי קיבוץ מפורש של ביטויים באמצעות סוגריים, ניתן למנוע אי הבנות בנוגע לסדר עדיפויות.

1console.log(true || (false && false));  // true
הבדלים בין שפה טבעית לפירוש על ידי תכנות

כאשר משתמשים באופרטורים לוגיים, חשוב להיות מודעים לאי-הבהירויות בשפה הטבעית. לדוגמה, כאשר אומרים 'כלב לבן או חתול,' זה עשוי להתפרש כ'כלב לבן או כל צבע של חתול' או 'כלב לבן או חתול לבן.'. בקוד, זה ייראה כך:.

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

מכיוון שלשפה טבעית יש אי-הבנה כמו זו, יש להיות זהירים בעת כתיבה או תכנון של קוד.

אופרטור טרינרי (אופרטור מותנה)

JavaScript כוללת אופרטור טרנרי (אופרטור מותנה).

אופרטור תיאור דוגמה תוצאה
? : אם התנאי הוא אמת, הצד השמאלי מבוצע, אחרת הצד הימני תנאי ? אם אמת : אם שקר תוצאה מבוססת על התנאי
1let age = 20;
2let message = age >= 18 ? "Adult" : "Minor";
3console.log(message);  // "Adult"

הוא נכתב בצורה זו: condition ? value if true : value if false.

אופרטורים ביטוויסיים

מפעילים ביטווייז ב-JavaScript כוללים את הבאים.

אופרטור תיאור דוגמה תוצאה
& AND 5 & 1 1
| OR 5 | 1 5
^ XOR 5 ^ 1 4
~ NOT ~5 -6
<< הזזה שמאלה 5 << 1 10
>> Shift ימינה 5 >> 1 2
 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)

אופרטורים על ביטים מבצעים חישובים על מספרים ברמת הביטים. בדרך כלל הם משמשים לעיבוד ברמה נמוכה.

אופרטורי סוג

מפעילי הסוג ב-JavaScript כוללים את הבאים.

אופרטור תיאור דוגמה תוצאה
typeof מחזיר את סוג המשתנה typeof 123 "number"
instanceof בודק אם אובייקט שייך למחלקה מסוימת arr instanceof Array true
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

אופרטורי סוג משמשים לבדיקה של סוג ערך או להמרתו לסוג מסוים.

המפעיל typeof מחזיר את סוג המשתנה.

המפעיל instanceof בודק אם אובייקט שייך למחלקה מסוימת.

סיכום

  • אופרטורים אריתמטיים מבצעים חישובים בסיסיים.
  • אופרטורי השמה מקצים או מעדכנים ערכים במשתנים.
  • אופרטורי השוואה משווים בין שני ערכים ומחזירים true או false.
  • אופרטורי לוגיקה מעריכים שילובים של תנאים.
  • אופרטורים טרנריים מאפשרים לכתוב תנאים בצורה מקוצרת יותר מif.
  • אופרטורי ביטים מבצעים חישובים ברמת הביטים.
  • אופרטורי סוג מאפשרים לבדוק את סוג הערך.

תוכלו לעקוב אחר המאמר שלמעלה באמצעות Visual Studio Code בערוץ היוטיוב שלנו. נא לבדוק גם את ערוץ היוטיוב.

YouTube Video