[עמוד ראשי]   [נושא קודם]
ביטויים ואופרטורים


בפרק זה נסביר כיצד ביטויים ואופרטורים עובדים ב- JS. הנושא זהה בשפות C, ++C, ו- JAVA.
1. ביטויים
Expression - ביטוי, אשר המפענח יכול להעריך על מנת לייצר ערך.
הביטויים הפשוטים ביותר הינם מילוליים (literals) או שמות משתנים, כגון:
נומרי
3.6
ערך
[2,5,7,18,24]
מחרוזת
"Hello"
פונקציה
function(x){ return x*x; }
בוליאני
true
משתנה
i
אובייקט
{ x:2, y:3 }
ליטרל
null
הערך של ביטוי קבוע הוא הקבוע עצמו. הערך של ביטוי משתנה הוא הערך שהמשתנה מתייחס אליו.
ביטויים מורכבים יותר יכולים להיווצר על ידי מיזוג ביטויים פשוטים, לדוגמא, חיבור שני הביטויים שראינו קודם 1.7 + i הוא גם כן ביטוי.
ה- + בביטוי הוא אופרטור המשמש לחיבור שני ביטויים לביטוי מורכב יותר.
אופרטור נוסף הוא – שנועד על מנת לחסר ביטויים, לדוגמא :
(i + 1.7) – sum 
2. אופרטורים
הטבלה הבאה מציגה את כל האופרטורים הקיימים ב- JS.
העמודה P – מייצגת את קדימות האופרטור בין האחרים.
העמודה A – מייצגת את אסוציאטיביות האופרטור.
(L (left to right – סדר הפעולות הוא משמאל לימין.
(R (right to left – סדר הפעולות הוא מימין לשמאל.
P A Operator Operator Type Operation Performed
15 L . object, property Property access
  L [ ] array, integer Array index
  L ( ) function, arguments Function call
  R ++ number Pre-or-post increment (unary)
  R - - number Pre-or-post decrement (unary)
  R - number Unary minus (negation)
  R ~ integer Bitwise complement (unary)
  R ! boolean Logical complement (unary)
  R delete variable Undefine a property (unary)
  R new constructor call Create new object (unary)
  R typeof any Return data type (unary)
  R void any Return undefined value (unary)
  L * , / , % numbers Multiplication, division, remainder
12 L + , - numbers Addition, subtraction
  L + strings String concatenation
11 L << integers Left shift
  L >> integers Right shift with sign-extension
  L >>> integers Right shift with zero-extension
10 L < , <= number of strings Less than, less than or equal
  L > , >= number of strings Greater than, greater than or equal
9 L = = any Test for equality
  L ! = any Test for inequality
  L = = = b any Test for identity
  L ! = = b any Test for non-identity
8 L & integers Bitwise AND
7 L ^ integers Bitwise XOR
6 L | integers Bitwise OR
5 L & & booleans Logical AND
4 L | | booleans Logical OR
3 R ? : booleans ,any,any Conditional (ternary) operator
2 R = variable,any Assignment
  R *=, /=, %=, +=, -=, <<=, >>=, >>>=, &=, ^= variable,any Assignment with operation
1 L , any Multiple evaluation


באופן כללי, ישנם שלושה סוגי אופרטורים:
אופרטורים בינריים, המשלבים בין שני ביטויים לאחד, פועלים על שני אופרנדים (+ חיבור).
אופרטורים אונריים, אשר הופכים ביטוי פשוט ואחיד לביטוי אחד מורכב יותר (-3 שלילה).
אופרטורים טרינריים, אשר משלבים את ערכם של שלושה ביטויים לאחד (: ?).
סוגי אופרנדים
כאשר בונים ביטויים, עלינו לשים לב לטיפוסי המידע שמועברים לאופרטורים ואשר מוחזרים.
אופרטורים שונים מצפים מהאופרנדים/ ביטויים שלהם להיות מחושבים כערכים מסוג טיפוס מידע מסויים
לדוגמא, זה בלתי אפשרי לכפול מחרוזות, כך שהביטוי "a" * "b" אינו חוקי ב- JS.
נשים לב כי JS מנסה להפוך ביטויים לסוג הנכון של הטיפוס כך שהביטוי "3" * "5" הוא חוקי, ההערך שלו הוא המספר 15 ולא המחרוזת "15".
בנוסף על כך, אופרטורים מסוימים מתנהגים באופן שונה בהתאם לסוג האופרנד.
האופרטור + בדרך כלל מחבר בין אופרנדים נומריים, אך גם משרשר מחרוזות.
בנוסף, במקרה שאופרנד אחד הוא מחרוזת ואחר הוא מספר, הוא הופך את המספר למחרוזת ומשרשר את המחרוזות, לדוגמא: 0 + "1" ¬ מתקבלת המחרוזת "10".
אופרטורים לא תמיד מחזירים ערך כערכם של האופרנדים.
אופרטורי השוואה מחזירים ערך בוליאני בהתאם לתוצאה, לדוגמא, הביטוי a < 3 מחזיר אמת / שקר בהתאם לתשובה.
סדר קדימות אופרטורים
על פי הטבלה שהוצגה, סדר הקדימויות של האופרטורים נראה בעמודה P.
ניתן דוגמא: w = x + y*2;
אופרטור כפל הוא בעל סדר קדימות גבוה יותר מאופרטור החיבור, ואופרטור ההשמה ( = ) הוא בעל סדר הקדימות הנמוך ביותר, לכן, קודם תתבצע פעולת הכפל, אחריה פעולת החיבור ולבסוף פעולת ההשמה.
3. אופרטורים אריתמטיים
חיבור ( + )
האופרטור מחבר בין אופרנדים נומריים או משרשר מחרוזות. במידה ואופרנד אחד הוא מספר ואחר הוא מחרוזת, המספר הופך למחרוזת ומתבצע שרשור ביניהם. אופרנדים מסוג אובייקטים מומרים למספר (על ידי המתודה ( )valueOf), או למחרוזות (על ידי המתודה ( )toString) ואז מתבצע החיבור / השרשור.
חיסור ( - )
חיסור ערכו של האופרנד השני מהראשון.
כפל ( * )
כפל בין שני האופרנדים.
חילוק ( / )
האופרנד הראשון מחולק על ידי האופרנד השני, התוצאה היא מספר עשרוני, חלוקה ב-0 היא אינסוף שלילי / חיובי, תוצאת החלוקה 0 / 0 היא הערך NaN.
מודולו ( % ) – שארית חלוקה
שארית החלוקה של האופרנד הראשון בשני. דוגמא: 2 5% ¬ 1 כאשר סימן התוצאה הוא כסימנו של האופרנד הראשון.
שלילה ( - )
הפיכת ערך שלילי לחיובי וחיובי לשלילי.
הוספה ( ++ )
האופרטור מוסיף 1 לאופרנד, שחייב להיות משתנה, אלמנט של מערך או תכונה של אובייקט.
כאשר האופרטור מופיע לפני האופרנד מתבצעת קודם פעולת ההוספה, לדוגמא :
 i = 1;  j = ++i; 
ערכם של i ו- j שניהם הוא 2.
כאשר האופרטור מופיע לאחר האופרנד, פעולת ההוספה מתבצעת לאחר פעולה אחרת, לדוגמא :
 i = 1;  j = i++; 
ערכו של i = 2, אך ערכו של j הוא 1.
החסרה ( - - )
מתפקד בדיוק כמו אופרטור של הוספה, רק מחסר אחד.

בכל האופרטורים, מלבד החיבור, כאשר האופרנדים אינם מספרים נומריים, ישנו קודם כל ניסיון להמירם לכאלה.
4. אופרטורי שוויון וזהות
אופרטורים אלו בודקים שוויון וזהות בין אופרנדים ומחזירים ערך בוליאני אמת / שקר בהתאם לתוצאת ההשוואה.
שוויון ( == )
האופרטור מחזיר אמת כאשר שני האופרנדים שווים, ולהיפך.
האופרנדים יכולים להיות מכל טיפוס שהוא, וההגדרה של השוויון תלויה בטיפוס.
מספרים, מחרוזות וערכים בוליאניים מושווים על פי הערך (by value).
מצד שני, אובייקטים, מערכים ופונקציות מושווים על פי מצביע (by reference).
משמע, שני משתנים הם שווים אם הם מתייחסים לאותו האובייקט.
שני מערכים שונים, לעולם אינם שווים על פי ההגדרה של ( = = ) למרות היותם בעלי אלמנטים זהים.
במידה ונרצה להשוות את ערכיהם של שני אובייקטים / מערכים, עלינו להשוות את תכונותיהם, אלמנטיהם בעצמינו.
מספר חוקים:
כאשר שני ערכים הם מאותו טיפוס, נשווה ביניהם ונראה אם הם שווים.
כאשר שניהם מחרוזות זהות אז הן שוות.
כאשר שניהם אותו המספר אז הם שווים.
כאשר אחד מהם NaN / שניהם בעלי ערך, אינם שווים.
כאשר שניהם בעלי ערך בוליאני אמת אז הם שווים, כנ"ל לגבי שקר.
כאשר שניהם מתייחסים לאותו אובייקט, מערך או פונקציה הם שווים.
כאשר אינם מתייחסים לאותו אובייקט, מערך או פונקציה, למרות שתוכנם שווה, אינם שווים.
כאשר שניהם בעלי ערך null אז הם שווים, כנ"ל לגבי undefined
כאשר אחד הוא null והשני undefined אז הם שווים.
כאשר שני הערכים הם מטיפוסים שונים, ננסה להמיר אותם לאותו סוג ולהשוות ביניהם על פי הכללים הבאים:
כאשר אחד הוא מספר והאחר מחרוזת, נמיר את המחרוזת למספר ונשווה.
כאשר אחד הערכים הוא true נמירו ל - 1 ונבצע השוואה.
כאשר אחד הערכים הוא false נמירו ל - 0 ונבצע השוואה.
כאשר אחד הערכים הוא אובייקט והשני מחרוזת / מספר נמיר את האובייקט לטיפוס פרימיטיבי ונשווה.
כל קומבינציה אחרת של סוגי טיפוסים אינם שווים.
אי שוויון ( =! )
הערך המוחזר הוא אמת כאשר האופרנדים אינם שווים וההפך.
זהות ( === )
אופרטור זה בודק שוויון קפדני ומחמיר יותר מהשוויון הנ"ל. הערך המוחזר הוא אמת אך ורק במקרה בו האופרנדים הם בעלי ערך זהה ללא שום המרה. נשים לב גם, כי אופרטור זה אינו מחשיב את הערכים undefined ו- null כשווים.
5. אופרטורי השוואה
אופרטורים אלה מחזירים ערך אמת כאשר:

( > ) a < b כאשר a קטן מ- b
( >= ) a <= b כאשר a קטן או שווה ל- b
( >= ) a <= b כאשר a קטן או שווה ל- b
( <= ) a >= b כאשר a גדול או שווה ל- b

השוואה יכולה להערך רק בין מספרים או מחרוזות, טיפוסים אחרים מומרים למספרים / מחרוזות. במידה ולא ניתן להמיר אחד מהאופרנדים למספר / מחרוזת, תוצאת ההשוואה היא "שקר".
6. אופרטורי מחרוזות
אופרטור + בין מחרוזות מבצע שרשור שלהן :
דוגמאות :
"hello" + " " + "there";       // "hello there"            
c = a + b ; a = "2" ; b = "2" ; // "22" 
במקרים של אופרטורי השוואה בין מחרוזות, ההשוואה מתבצעת על פי סדר אלפבתי כאשר אותיות גדולות באות לפני אותיות קטנות ולכן ערכן נמוך יותר,
דוגמאות :
"Zoo" < "aardvark"    ?  true
1 + 2 חיבור, התוצאה היא 3
"1" + "2" שרשור, התוצאה היא "12"
"1" + 2 שרשור, 2 מומר ל-"2" ,התוצאה היא "12"
11 < 3 השוואה נומרית , התוצאה היא שקר
"11" < "3" השוואת מחרוזות , התוצאה היא אמת
"11" < 3 השוואה נומרית, "11" מומר ל- 11 התוצאה היא שקר
"eleven" < 3 שגיאה, "eleven" לא יכול להיות מומר למס'
7. אופרטורים לוגיים
השימוש באופרטורים הלוגיים אופייני עבור "אלגברה בוליאנית".
הם לעיתים קרובות משמשים בצירופים עם השוואת אופרטורים על מנת לבטא השוואות מסובכות ומורכבות אשר מערבות יותר ממשתנה אחד.
וגם לוגי (&&)
פעולת החיבור הלוגי מחזירה אמת אך ורק במקרה ששני האופרנדים כל אחד לחוד ערכו הוא אמת.
או לוגי (| |)
פעולת החיסור הלוגי מחזירה אמת במקרה ששני האופרנדים או אם רק אחד מהם, ערכו הוא אמת.
שלילה לוגית (!)
זהו אופרטור אונרי, מטרתו להפוך את ערכו הבוליאני של האופרנד. לדוגמא, במידה והמשתנה a הוא בעל ערך אמת a! הוא בעל ערך שקר.
8. אופרטורי השמה
האופרטור = משמש כאופרטור השמה ב- JS.
לדוגמא 0 = i, המשתנה i אותחל בערך 0.
אופרטור זה מצפה מהאופרנד שמשמאלו להיות משתנה, איבר במערך או תכונה של אובייקט, מהאופרנד שמימינו להיות ערך שרירותי מכל טיפוס שהוא.
בשל היותו אופרטור, ניתן לכלול אותו בביטויים מורכבים יותר, לדוגמא, ניתן לאתחל ולבדוק ערך באותו הביטוי:
(a = b) == 0
אופרטור זה הוא בעל אסוציאטיביות R – מימין לשמאל ולכן ניתן לבצע כך:
i = j = k = 0
כל אופרנד מקבל את ערכו מהערך שלימינו.
השמה משולבת עם פעולות
ניתן לשלב בהשמה פעולות נוספות, אשר מספקות קיצור דרך באמצעות השילוב בין השתיים.
לדוגמא :
חיבור + השמה :
total += sales_tax   
שווה ל :
total = total + sales_tax  

האופרטור עובד גם עבור מספר מחרוזות. עבור אופרנדים נומריים מתבצע חיבור נומרי / השמה ועבור מחרוזות מתבצע שרשור / השמה.
אופרטורי השמה :
Operator Example Equivalent
+= a += b a = a + b
- = a -= b a = a –b
*= a *= b a = a * b
/ a /= b a = a / b
%= a %= b a = a % b
<<= a <<= b a = a << b
>>= a >>= b a = a >> b
&= a &= b a = a & b
|= a |= b a = a | b
^= a ^= b a = a ^ b
>>>= a >>>= b a = a >>> b

התחביר ברב המקרים הוא:
a operator = b
שווה ל:
a = a operator b
9. אופרטורים נוספים
אופרטור תנאי
אופרנד ג' : אופרנד ב' ? אופרנד א
אופרטור טרנרי (עבור שלושה אופרנדים).
לדוגמא :
x > 0 ? x * y : -x * y                           
אופרנד א' חייב להיות בעל ערך בוליאני, בדרך כלל זאת תוצאת השוואה. אופרנדים ב' ו-ג' הם בעלי ערך מסויים.
הערך המוחזר על ידי אופרטור התנאי תלוי בערכו הבוליאני של אופרנד א'. אם ערכו הוא אמת, מוחזר ערכו של אופרנד ב'. אם ערכו הוא שקר, מוחזר ערכו של אופרנד ג'.
greeting = "hello " + ( ( username != null ) ? username : "there");
שווה ל-
greeting = "hello ";
if ( username != null )     
     greeting += username;

else
     greeting += "there";
אופרטור typeOf
אופרטור אונרי, המיוצג על ידי מילת המפתח typeOf הממוקמת לפני האופרנד. הערך המוחזר הוא מחרוזת המעידה על טיפוס / סוג האופרנד.
לדוגמא :
typeof   i 
( typeof value == "string" ) ? "’" + value + "’" : value

ניתן להשתמש גם בצורה זו: (typeOf(i
אופרטור void (נתמך בגרסה 1.1 ומעלה).
מקום בו נרצה להשתמש בכך ב- JS הוא בכתובת URL. אם נרצה להעריך ביטוי לשם השפעות / תוצאות צדדיות אך לא נרצה כי הדפדפן יציג את הערך המוערך עצמו, נשתמש באופרטור זה בתוך תג HTML בצורה זו:
<a href ="javascript:void window.open();">Open New Window</a> 

שימוש נוסף הוא כאשר נרצה לבדוק אם אופרנד הוא בעל הערך undefined. נבצע זאת כך:
if(form.greeting === (void 0)) form.greeting = "Hello World!";