אופרטורים ב-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 בערוץ היוטיוב שלנו. נא לבדוק גם את ערוץ היוטיוב.