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

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

YouTube Video