אופרטורים ב-TypeScript
מאמר זה מסביר את האופרטורים ב-TypeScript.
YouTube Video
אופרטורים ב-TypeScript
אופרטורים ב-TypeScript משמשים לביצוע חישובים נומריים, השוואות ערכים ופונקציות לוגיות. מכיוון ש-TypeScript משתמשת באופרטורים דומים ל-JavaScript, קל להתרגל אליהם, אך TypeScript מאפשרת פעולות מחמירות יותר באמצעות אבטחת טיפוסים.
האופרטורים העיקריים הם כדלקמן:.
אופרטורים אריתמטיים
אופרטורים אריתמטיים משמשים לחישובים נומריים.
אופרטור | תיאור | דוגמה | תוצאה |
---|---|---|---|
+ |
חיבור | 5 + 3 |
8 |
- |
חיסור | 5 - 3 |
2 |
* |
כפל | 5 * 3 |
15 |
/ |
חילוק | 5 / 2 |
2.5 |
% |
שארית | 5 % 2 |
1 |
++ |
הוספה (קידומת) | let x = 5; ++x |
6 |
-- |
הפחתה (קידומת) | 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);
אופרטורי השמה
אופרטורי השמה מייחסים את הערך בצד ימין למשתנה שבצד שמאל.
אופרטור | תיאור | דוגמה | תוצאה |
---|---|---|---|
= |
השמה | x = 10 |
x = 10 |
+= |
הוסף וישם | x += 5 |
x = 15 |
-= |
חיסור וישם | x -= 5 |
x = 5 |
*= |
כפל וישם | x *= 2 |
x = 20 |
/= |
חילוק וישם | x /= 2 |
x = 5 |
%= |
שארית וישם | x %= 3 |
x = 1 |
1let z = 5;
2z += 3;
3console.log(z); // Outputs: 8
4
5z *= 2;
6console.log(z); // Outputs: 16
אופרטורים להשוואה
אופרטורים להשוואה משווים ערכים ומחזירים true
או false
.
אופרטור | תיאור | דוגמה | תוצאה |
---|---|---|---|
== |
שווה (השוואה ללא בדיקת סוג) | 5 == "5" |
true |
=== |
שווה באופן מוחלט (כולל סוג) | 5 === "5" |
false |
!= |
לא שווה (השוואה ללא בדיקת סוג) | 5 != "5" |
false |
!== |
לא שווה באופן מוחלט (כולל סוג) | 5 !== "5" |
true |
> |
גדול מ- | 5 > 3 |
true |
< |
קטן מ- | 5 < 3 |
false |
>= |
גדול או שווה ל- | 5 >= 5 |
true |
<= |
קטן או שווה ל- | 5 <= 3 |
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
אופרטורים לוגיים
אופרטורים לוגיים משמשים לשילוב ביטויים לוגיים.
אופרטור | תיאור | דוגמה | תוצאה |
---|---|---|---|
&& |
וג לוגי (AND) | true && false |
false |
|| |
או לוגי (OR) | true || false |
true |
! |
נגציה (NOT) | !true |
false |
1console.log('true && false :', true && false); // Outputs: false
2console.log('true || false :', true || false); // Outputs: true
3console.log('!true :', !true); // Outputs: false
קדימות של אופרטורים לוגיים
ב-TypeScript, האופרטורים הלוגיים בדרך כלל מוערכים בסדר: 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
מבצעים הערכה מקוצרת
ב-TypeScript, AND
ו-OR
מבצעים הערכה מקוצרת. אם התוצאה נקבעת על ידי הערך השמאלי, הביטוי הימני אינו מוערך.
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}
מכיוון ששפה טבעית עלולה להיות עמומה, נדרשת זהירות בעת כתיבת קוד ותכנון מערכות.
אופרטורים סיביים
אופרטורים סיביים מבצעים פעולות על מספרים ברמת הסיבית.
אופרטור | תיאור | דוגמה | תוצאה |
---|---|---|---|
& |
וג לוגי (AND) | 5 & 1 |
1 |
` | ` | או לוגי (OR) | 5 | 1 |
^ |
או בלעדי (XOR) | 5 ^ 1 |
4 |
~ |
נגציה (NOT) | ~5 |
-6 |
<< |
הזזה שמאלה | 5 << 1 |
10 |
>> |
הזזה ימינה (Signed) | 5 >> 1 |
2 |
>>> |
הזזה ימינה (Unsigned) | 5 >>> 1 |
2 |
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)
אופרטור טרנארי
האופרטור הטרנארי מחזיר ערכים שונים בהתבסס על תוצאה של ביטוי מותנה.
1let age = 20;
2let access = (age >= 18) ? "Allowed" : "Denied";
3console.log(access); // Outputs: Allowed
אופרטורים של סוג
האופרטורים של סוג ב-TypeScript כוללים את הבאים:.
אופרטור | תיאור | דוגמה | תוצאה |
---|---|---|---|
typeof |
מחזיר את הסוג של משתנה | typeof 123 |
"number" |
instanceof |
בודק אם אובייקט שייך למחלקה מסוימת | arr instanceof Array |
true |
is |
כאמצעי אבטחת סוג, בודק אם ערך הוא מסוג מסוים | value is string |
true or false |
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}
אופרטורים של סוגים משמשים לבדוק את הסוג של ערך או להמיר אותו לסוג מסוים.
- האופרטור
typeof
מחזיר את הסוג של משתנה. - האופרטור
instanceof
בודק אם אובייקט שייך למחלקה מסוימת. - האופרטור
is
משמש לבדוק אם ערך הוא מסוג מסוים. האופרטור הוא חלק ממנגנוני אבטחת הסוגים של TypeScript.
סיכום
- אופרטורים אריתמטיים: מבצעים חישובים בסיסיים.
- אופרטורים להשמה: מקצים ערכים למשתנים.
- אופרטורים להשוואה: משווים ערכים.
- אופרטורים לוגיים: מחברים תנאים לוגיים.
- אופרטורים על סיביות: מבצעים פעולות ברמת הסיביות.
- אופרטור טרנארי: מחזיר ערכים בהתבסס על תנאים.
- אופרטורים של סוג יכולים לבדוק את הסוג של ערך.
ב-TypeScript ניתן להשתמש באופרטורים אלו לכתיבת חישובים מורכבים וביטויים מותנים בצורה יעילה.
תוכלו לעקוב אחר המאמר שלמעלה באמצעות Visual Studio Code בערוץ היוטיוב שלנו. נא לבדוק גם את ערוץ היוטיוב.