פרק 3: אופרטורים

 

·                     הקדמה

·                     אופרטורים לביצוע השמות של ערכים אל תוך משתנים

·                     אופרטורים לביצוע חישובים מתמטיים

·                     אופרטורים לביצוע השוואות בין ביטויים

·                     אופרטורים לביצוע פעולות על ביטים

·                     אופרטורים לביצוע פעולות על מחרוזות תווים

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

·                     האופרטור this

·                     האופרטור tyoeof

·                     אופרטור התנאי הטרנרי

·                     האופרטור void

·                     האופרטורים new  ו- delete

·                     כללי הקדימויות של אופרטורים

·                     תרגילים

 

 

 

הקדמה

 

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

 

ביטוי הוא כל מה שיש לו ערך יחיד. הערך יכול להיות ערך מספרי, ערך בוליאני או אפילו ערך מחרוזתי (מחרוזת של תווים). ב-JavaScript, בדומה לשפות אחרות, כל ביטוי נחשב גם למשפט.

 

אופרנד הוא קבוע או משתנה.

 

כעת ניתן להסביר מהו אופרטור.

אופרטור הוא כל סימן גרפי שפועל על אופרנד/ביטוי אחד, שניים או שלושה. כך למשל, סימן החיבור + הוא אופרטור מתימטי אשר פועל על שני אופרנדים.

לדוגמא:

בביטוי: num + 6 ניתן לראות את האופרטור המתימטי + פועל על שני אופרנדים. האופרנד הראשון הוא משתנה ששמו num, והאופרנד השני הוא הקבוע המספרי, 6.

 

ביטוי יכול להיות ביטוי פשוט (משתנה, קבוע...) או ביטוי מורכב (הרכב של משתנים/קבועים ואופרטורים ששווה לערך אחד ויחיד).

 

כפי שהוסבר, ניתן לזהות, לפיכך, שלושה סוגים של ביטויים ב- JavaScript:

1.       ביטוי מתימטי. זהו ביטוי שערכו הוא ערך מספרי (שלם או ממשי).

2.       ביטוי לוגי. זהו ביטוי שערכו true או false.

3.       ביטוי מחרוזתי. זהו ביטוי שערכו שווה למחרוזת תווים מסויימת.

 

דוגמאות:

הביטוי:+ 4  3   הוא ביטוי מספרי שערכו 7.

הביטוי: num = 4 + 6  הוא ביטוי מספרי שערכו 10. ב-JavaScript, בדומה ל- C\C++, ובדומה ל- JAVA, משפט השמה נחשב גם לביטוי שערכו הוא הערך המושם. במקרה זה מוצג משפט השמה שבו הערך 10 מוכנס אל תוך המשתנה num. לפיכך הערך המושם הוא 10 , וזהו גם ערכו של הביטוי.

הביטוי: “TIN”+”TIN” הוא ביטוי מחרוזתי שערכו הוא המחרוזת “TINTIN”.

הביטוי: 100>4 הוא ביטוי לוגי שערכו הוא true.

 

את האופרטורים שקיימים ב-JavaScript ניתן לחלק לשתי קבוצות:

אופרטורים בינריים. אלה הם האופרטורים שפועלים על שני אופרנדים/ביטויים.

לדוגמא: אופרטור החיבור החשבוני, + , הוא אופרטור בינרי שפועל על שני האופרנדים/הביטויים  שנמצאים מימינו ומשמאלו.

אופרטורים אונריים. אלה הם אופרטורים שפועלים על אופרנד/ביטוי אחד.

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

 

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

 

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

 

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

 

 

 

 

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

 

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

 

אופרטור ההשמה הבסיסי ביותר הוא האופרטור =. אופרטור זה גורם להיכנסותו של הערך שנמצא מימינו אל תוך המשתנה ששמו מצויין משמאלו.

לדוגמא:

num = 34 + 5   בביטוי זה מוכנס אל תוך המשתנה num הערך  7.

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

 

אופרטורי ההשמה האחרים מהווים, למעשה, קיצור של מספר פעולות.

 

הטבלה הבאה מפרטת את אופרטורי ההשמה האחרים, ואת המשמעות של כל אחד מהם. X הוא שם של משתנה ו-Y הוא ביטוי.

 

המשמעות המלאה

דוגמא

אופרטור ההשמה

X=X+Y

X+=Y

=+

X=X-Y

X-=Y

-=

X=X*Y

X*=Y

*=

X=X/Y

X/=Y

/=

X=X%Y

X%=Y

%=

X=X<<Y

X<<=Y

<<=

X=X>>Y

X>>=Y

>>=

X=X>>>Y

X>>>=Y

>>>=

X=X&Y

X&=Y

&=

X=X^Y

X^=Y

^=

X=X|Y

X|=Y

|=

 

הסברים לאופרטורים שטרם הוסברו יובאו בהמשך.

 

 

אופרטורים לביצוע חישובים מתימטיים

 

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

 

האופרטורים המתימטיים הבינריים הם:

+

-

*

/

%

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

מסיבה זו, בעוד שבשפות כגון C\C++ ו-JAVA הערך של ביטוי כגון 1/2 היא 0, ב-JavaScript הערך של הביטוי הזה הוא 0.5.

 

האופרטורים המתמטיים האונריים הם:

++

--

-

אופרטורים אלה פועלים ב-JavaScript בדיוק כמו ב-JAVA וב- C\C++. המשמעות השונה שיש למיקום האופרטורים ++ ו – לפני או אחרי שם המשתנה מתקיימת ב-JavaScript בדיוק כמו ב-C\C++  וב- JAVA.

 

 

 

אופרטורים לביצוע השוואות בין ביטויים

 

קבוצה זו כוללת אופרטורים שמבצעים השוואה בין שני ביטויים ומחזירים true או false בהתאם להיותה של ההשוואה נכונה או לא. האופרנדים(או הביטויים) שעליהם פועלים אופרטורים אלה יכולים להיות מכל סוג שהוא. אלה יכולים להיות ביטויים שערכם מספרי, ואלה יכולים להיות ביטויים שערכם מחרוזתי. כאשר ההשוואה מתבצעת בין מחרוזות תווים נעשה תרגום של המחרוזת לערכי ה-Unicode של התווים שמרכיבים אותה, ובדרך זו מתבצעת ההשוואה. הטבלה הבאה מסכמת את האופרטורים שקיימים בקבוצה זו. בכל מקום שבו כתוב בטבלה "אופרנד" הכוונה היא גם לביטוי.

 

דוגמא

תיאור

האופרטור

num1 == num2

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

==

num1 != num2

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

!=

num1>result

מחזיר true אם האופרנד השמאלי גדול מהאופרנד הימני.

>

num1<result

מחזיר true אם האופרנד השמאלי קטן מהאופרנד הימני.

<

num1>=result

מחזיר true אם האופרנד השמאלי גדול או שווה מהאופרנד הימני.

>=

num1<=result

מחזיר true אם האופרנד השמאלי קטן או שווה מהאופרנד הימני.

<=

 

 

אופרטורים לביצוע פעולות על ביטים

 

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

 

האופרטור AND, &

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

 

התכנית הבאה מדגימה את פעולתו של אופרטור זה.

 

<!—file name : BitwiseAnd.html à

<!—2000© Zindell Publishing House Ltd. à

 

<! DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0//EN”>

 

<HTML>

 

  <HEAD>

    <TITLE>BitwiseAnd.html</TITLE>

      <SCRIPT LANGUAGE=”JavaScript1.3”>

        var num1 = 9;  //00000000 00000000 00000000 00001001

        var num2 = 12; //00000000 00000000 00000000 00001100

        var num3 = num1 & num2;

                                document.write(“num3 = “ + num3);

                                //should be :    00000000 00000000 00000000 00001000

                                //which means 8

      </SCRIPT> 

   </HEAD>

 

  <BODY>

  </BODY>

 

</HTML>

 

 

כדאי לשים לב, כבר עתה, לאופן שילובן של ההערות בתוך התכניות שכתובות ב-JavaScript (כמו ב- C++ וכמו ב-JAVA). הסימן // מסמן את תחילתה של הערה בגוף התכנית אשר נמשכת עד לסוף השורה שבה היא התחילה.

 

 

 

האופרטור OR, |

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

 

התכנית הבאה מדגימה את פעולתו של אופרטור זה.

 

<!—file name : BitwiseOr.html à

<!—2000© Zindell Publishing House Ltd. à

 

<! DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0//EN”>

 

<HTML>

 

  <HEAD>

    <TITLE>BitwiseOr.html</TITLE>

      <SCRIPT LANGUAGE=”JavaScript1.3”>

        var num1 = 9;  //00000000 00000000 00000000 00001001

        var num2 = 12; //00000000 00000000 00000000 00001100

        var num3 = num1 | num2;

                                document.write(“num3 = “ + num3);

                                //should be :    00000000 00000000 00000000 00001101

                                //which means 13

      </SCRIPT> 

   </HEAD>

 

  <BODY>

  </BODY>

 

</HTML>

האופרטור XOR,^

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

 

התכנית הבאה מדגימה את פעולתו של אופרטור זה.

 

<!—file name : BitwiseXor.html à

<!—2000© Zindell Publishing House Ltd. à

 

<! DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0//EN”>

 

<HTML>

 

  <HEAD>

    <TITLE>BitwiseXor.html</TITLE>

      <SCRIPT LANGUAGE=”JavaScript1.3”>

        var num1 = 9;  //00000000 00000000 00000000 00001001

        var num2 = 12; //00000000 00000000 00000000 00001100

        var num3 = num1 ^ num2;

                                document.write(“num3 = “ + num3);

                                //should be :    00000000 00000000 00000000 00000101

                                //which means 5

      </SCRIPT> 

   </HEAD>

 

  <BODY>

  </BODY>

 

</HTML>

 

 

 

האופרטור  NOT, ~

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

 

התכנית הבאה מדגימה את פעולתו של אופרטור זה.

 

<!—file name : BitwiseNot.html à

<!—2000© Zindell Publishing House Ltd. à

 

<! DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0//EN”>

 

<HTML>

 

  <HEAD>

    <TITLE>BitwiseNot.html</TITLE>

      <SCRIPT LANGUAGE=”JavaScript1.3”>

        var result = 0;       //00000000 00000000 00000000 00000000

        result = ~result;     //11111111 11111111 11111111 11111111

        result = result – 4;  //11111111 11111111 11111111 11111011

        var temp = 12;        //00000000 00000000 00000000 00001100

        result &= temp;       //00000000 00000000 00000000 00001000

        document.write(“result = “ + result);

        //should be :    00000000 00000000 00000000 00001000

        //which means 8

      </SCRIPT> 

   </HEAD>

 

  <BODY>

  </BODY>

 

</HTML>

 

האופרטור Left shift, >>

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

 

התכנית הבאה מדגימה את פעולתו של אופרטור זה.

 

<!—file name : BitwiseLeftShift.html à

<!—2000© Zindell Publishing House Ltd. à

 

<! DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0//EN”>

 

<HTML>

 

  <HEAD>

    <TITLE>BitwiseLeftShift.html</TITLE>

      <SCRIPT LANGUAGE=”JavaScript1.3”>

        var result = 4;       //00000000 00000000 00000000 00000100

        result = result << 2; //00000000 00000000 00000000 00010000

        document.write(“result = “ + result);

        //should be :    00000000 00000000 00000000 00010000

        //which means 16

      </SCRIPT> 

   </HEAD>

 

  <BODY>

  </BODY>

 

</HTML>

 

האופרטור Sign-propagating right shift, >>

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

 

התכנית הבאה מדגימה את פעולתו של אופרטור זה.

 

<!—file name : BitwiseSignRightShift.html à

<!—2000© Zindell Publishing House Ltd. à

 

<! DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0//EN”>

 

<HTML>

 

  <HEAD>

    <TITLE>BitwiseSignRightShift.html</TITLE>

      <SCRIPT LANGUAGE=”JavaScript1.3”>

        var result1 = 20;       //00000000 00000000 00000000 00010100

        result1 = result1 >> 2; //00000000 00000000 00000000 00000101

        document.write(“result1 = “ + result1);

        //should be :    00000000 00000000 00000000 00000101

        //which means 5

        var result2 = -4;       //11111111 11111111 11111111 11111100

        result2 = result2 >> 1; //11111111 11111111 11111111 11111110

        document.write(“<BR>result2 = “ + result2);

        //should be :    11111111 11111111 11111111 11111110

        //which means –2

      </SCRIPT> 

   </HEAD>

 

  <BODY>

  </BODY>

 

</HTML>

 

האופרטור Zero-fill right shift, <<<

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

התכנית הבאה מדגימה את פעולתו של אופרטור זה.

 

<!—file name : BitwiseZeroFillRightShift.html à

<!—2000© Zindell Publishing House Ltd. à

 

<! DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0//EN”>

 

<HTML>

 

  <HEAD>

    <TITLE>BitwiseZeroFillRightShift.html</TITLE>

      <SCRIPT LANGUAGE=”JavaScript1.3”>

        var result1 = 20;        //00000000 00000000 00000000 00010100

        result1 = result1 >>> 2; //00000000 00000000 00000000 00000101

        document.write(“result1 = “ + result1);

        //should be :    00000000 00000000 00000000 00000101

        //which means 5

        var result2 = -4;        //11111111 11111111 11111111 11111100

        result2 = result2 >>> 31; //00000000 00000000 00000000 00000001

        document.write(“<BR>result2 = “ + result2);

        //should be :    00000000 00000000 00000000 00000001

        //which means 1

      </SCRIPT> 

   </HEAD>

 

  <BODY>

  </BODY>

 

</HTML>

 

 

אופרטורים לביצוע פעולות על מחרוזות תווים

 

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

 

כך למשל, התוצאה של הביטוי הבא:

“Hello “ + “Israel”

היא המחרוזת: “Hello Israel”

 

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

כך למשל, התוצ אה של המשפט הבא:

str  = "Tel"

str += "Aviv"

היא שבתוך המשתנה str נמצאת המחרוזת: “Tel-Aviv”

 

 

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

 

האופרטורים הלוגיים פועלים, בדרך כלל, על ערכים בוליאנים (true או false), ומחזירים כתוצאה ערך בוליאני חדש. אופרטורים אלה כוללים את האופרטורים הלוגיים המוכרים: AND,  OR ו- NOT. כל אחד משני האופרטורים הראשונים (OR ו- AND) מחזיר את אחד משני הערכים שעליהם הוא פעל. מסיבה זו, כאשר כל אחד משני אופרטורים אלה פועל על ערך/ערכים שאינם בוליאנים הוא עשוי להחזיר כתוצאה של פעולתו ערך שאיננו בוליאני.

 

האופרטור AND, &&

אופרטור זה פועל על שני אופרנדים:   expression1 && expression2

אופרטור זה מחזיר את ערכו של הביטוי הראשון, expression1, אם הוא false או שניתן לבצע לו casting ל-false. בכל מקרה אחר מוחזר ערכו של הביטוי השני. בדרך זו, אם האופרטור הזה פועל על שני ביטויים בוליאנים אז הוא מחזיר true אך ורק אם שניהם true.

 

התכנית הבאה מדגימה את אופן פעולתו של אופרטור זה.

 

<!—file name : BooleanAnd.html à

<!—2000© Zindell Publishing House Ltd. à

 

<! DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0//EN”>

 

<HTML>

 

  <HEAD>

    <TITLE>BooleanAnd.html</TITLE>

      <SCRIPT LANGUAGE=”JavaScript1.3”>

                                num1 = true;

                                num2 = true;

                                if (num1 && num2)

                                  document.write(“true && true ß this is true”);

                                else

                                  document.write(“true && true ß this is false”);

        document.write(“<BR>”);

                                num1 = false;

                                num2 = false;

                                if (num1 && num2)

                                  document.write(“false && false ß this is true”);

                                else

                                  document.write(“false && false ß this is false”);

        document.write(“<BR>”);

                                num1 = false;

                                num2 = true;

                                if (num1 && num2)

                                  document.write(“false && true ß this is true”);

                                else

                                  document.write(“false && true ß this is false”);

        document.write(“<BR>”);

                                num1 = true;

                                num2 = false;

                                if (num1 && num2)

                                  document.write(“true && false ß this is true”);

                                else

                                  document.write(“true && false ß this is false”);

        document.write(“<BR>”);

                                num1 = “abc”;

                                num2 = “def”;

                                if (num1 && num2)

                                  document.write(“\”abc\” && \”def\” ß this is true”);

                                else

                                  document.write(“\”abc\” && \”def\” ß this is false”);

        document.write(“<BR>”);

        num1 = null;

                                num2 = 12;

                                if (num1 && num2)

                                  document.write(“null && 12 ß this is true”);

                                else

                                  document.write(“null && 12 ß this is false”);

      </SCRIPT> 

   </HEAD>

 

  <BODY>

  </BODY>

 

</HTML>

 

האופרטור OR, ||

אופרטור זה פועל על שני אופרנדים:   expression1 || expression2

אופרטור זה מחזיר את ערכו של הביטוי הראשון, expression1, אם הוא true או שניתן לבצע לו casting ל-true. בכל מקרה אחר מוחזר ערכו של הביטוי השני. בדרך זו, אם האופרטור הזה פועל על שני ביטויים בוליאנים אז הוא מחזיר true  אם לפחות אחד משניהם true, ואם שניהם false אז הוא מחזיר false.

 

התכנית הבאה מדגימה את אופן פעולתו של אופרטור זה.

 

<!—file name : BooleanOr.html à

<!—2000© Zindell Publishing House Ltd. à

 

<! DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0//EN”>

 

<HTML>

 

  <HEAD>

    <TITLE>BooleanOr.html</TITLE>

      <SCRIPT LANGUAGE=”JavaScript1.3”>

                                num1 = true;

                                num2 = true;

                                if (num1 || num2)

                                ");  “true || true ß this is true” document.write(

                                else

                                  document.write(“true || true ß this is false”);

        document.write(“<BR>”);

                                num1 = false;

                                num2 = false;

                                if (num1 || num2)

                                  document.write(“false || false ß this is true”);

                                else

                                  document.write(“false || false ß this is false”);

        document.write(“<BR>”);

                                num1 = false;

                                num2 = true;

                                if (num1 || num2)

                                  document.write(“false || true ß this is true”);

                                else

                                  document.write(“false || true ß this is false”);

        document.write(“<BR>”);

                                num1 = true;

                                num2 = false;

                                if (num1 || num2)

                                  document.write(“true || false ß this is true”);

                                else

                                  document.write(“true || false ß this is false”);

        document.write(“<BR>”);

                                num1 = “abc”;

                                num2 = “def”;

                                if (num1 || num2)

                                  document.write(“\”abc\” || \”def\” ß this is true”);

                                else

                                  document.write(“\”abc\” || \”def\” ß this is false”);

        document.write(“<BR>”);

        num1 = null;

                                num2 = 12;

                                if (num1 || num2)

                                  document.write(“null || 12 ß this is true”);

                                else

                                  document.write(“null || 12 ß this is false”);

      </SCRIPT> 

   </HEAD>

 

  <BODY>

  </BODY>

 

</HTML>

 

 

האופרטור NOT, !

אופרטור זה פועל על אופרנד אחד:   !expression

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

 

התכנית הבאה מדגימה את אופן פעולתו של אופרטור זה.

 

<!—file name : BooleanNot.html à

<!—2000© Zindell Publishing House Ltd. à

 

<! DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0//EN”>

 

<HTML>

 

  <HEAD>

    <TITLE>BooleanNot.html</TITLE>

      <SCRIPT LANGUAGE=”JavaScript1.3”>

        value = null;

        document.write(“<BR>”);

                                if (!value)

                                  document.write(“!null ß returns true”);

                                else

                                  document.write(“!null ß returns false”);

        value = true;

        document.write(“<BR>”);

                                if (!value)

                                  document.write(“!true ß returns true”);

                                else

                                  document.write(“!true ß returns false”);

        value = “”;

        document.write(“<BR>”);

                                if (!value)

                                  document.write(“!\”\” ß returns true”);

                                else

                                  document.write(“!\”\” ß returns false”);

        value = 0;

        document.write(“<BR>”);

                                if (!value)

                                  document.write(“!0 ß returns true”);

                                else

                                  document.write(“!0 ß returns false”);

        value = false;

        document.write(“<BR>”);

                                if (!value)

                                  document.write(“!false ß returns true”);

                                else

                                  document.write(“!false ß returns false”);

        value = 12;

        document.write(“<BR>”);

                                if (!value)

                                  document.write(“!12 ß returns true”);

                                else

                                  document.write(“!12 ß returns false”);

        value = “abc”;

        document.write(“<BR>”);

                                if (!value)

                                  document.write(“!\”abc\” ß returns true”);

                                else

                                  document.write(“!\”abc\” ß returns false”);

        value = ‘a’;

        document.write(“<BR>”);

                                if (!value)

                                  document.write(“!\’a\’ ß returns true”);

                                else

                                  document.write(“!\’a\’ ß returns false”);

      </SCRIPT> 

   </HEAD>

 

  <BODY>

  </BODY>

 

</HTML>

 

בפעולת האופרטורים AND ו- OR, לא כל הביטוי בהכרח מחושב. ביטויים שערכם נקבע על פי האופרטור AND או האופרטור OR מחושבים משמאל לימין וכאשר מתברר (במהלך החישוב) ערכו הסופי של הביטוי תהליך החישוב מופסק.

 

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

False && ...

 

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

True || ...

 

 

 

האופרטור this

 

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

 

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

 

 

האופרטור typeof

 

אופרטור זה  מחזיר מחרוזת תווים אשר מתארת את הטיפוס של אופרנד נתון (גם אם ערכו טרם חושב). מחרוזת התווים שאופרטור זה מחזיר יכולה להיות כל אחת מהמחרוזות הבאות:

string

object

number

undefined

 

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

 

התכנית הבאה מדגימה את השימוש באופרטור זה.

 

                                <!—file name : typeofDemo.html à

<!—2000© Zindell Publishing House Ltd. à

 

<! DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0//EN”>

 

<HTML>

 

  <HEAD>

    <TITLE>typeofDemo.html</TITLE>

      <SCRIPT LANGUAGE=”JavaScript1.3”>

        var myTV = {size: 26, channels: 99, price: 7000};

                                var myStr = “Israel”;

                                var myNum = 234;

                                document.write(“<BR>The type of myTV is “ + typeof(myTV));

                                document.write(“<BR>The type of myStr is “ + typeof(myStr));

                                document.write(“<BR>The type of myNum is “ + typeof(myNum));

                                document.write(“<BR>The type of myNum + myStr is “ + typeof(myNum+myStr));

                                document.write(“<BR>The type of kalmar is “ + typeof(kalmar));                               

        document.write(“<BR>The type of null is “ + typeof(null));

        document.write(“<BR>The type of true is “ + typeof(true));

        document.write(“<BR>The type of false is “ + typeof(false));                             

        document.write(“<BR>The type of parseInt is “ + typeof(parseInt));                

        document.write(“<BR>The type of Date is “ + typeof(Date));                                                             

      </SCRIPT> 

   </HEAD>

 

  <BODY>

  </BODY>

 

</HTML>

 

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

 

כמו כן, ניתן לראות ששם הטיפוס שניתן ל true וגם ל false הוא boolean, ושם הטיפוס שניתן ל null הוא object.

 

 

אופרטור התנאי הטרנרי

 

אופרטור זה הוא האופרטור היחידי ב-JavaScript אשר פועל על שלושה ביטויים. פעולתו דומה לאופרטור התנאי הטרנרי שקיים ב-JAVA, ולאופרטור התנאי הטרנרי שקיים ב-C\C++.

 

כללי התחביר בכתיבתו הינם:

condition ? value1 : value2

 

אם התנאי שמופיע לפני סימן השאלה true אז הערך של כל הביטוי כולו יהיה value1, ואם ערכו של התנאי שמופיע לפני סימן השאלה false אז הערך של כל הביטוי כולו יהיה value2. יש להקפיד על סימן הנקודותיים בין שני הערכים האפשריים. התנאי הוא הביטוי הראשון מבין השלושה.

 

התכנית הבאה מדגימה את השימוש באופרטור התנאי הטרנרי.

 

<!—file name : TrenarDemo.html à

<!—2000© Zindell Publishing House Ltd. à

 

<! DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0//EN”>

 

<HTML>

 

  <HEAD>

    <TITLE>TrenarDemo.html</TITLE>

      <SCRIPT LANGUAGE=”JavaScript1.3”>

        var num1 = 1000;

                                var num2 = 2000;

                                var str;

                                str = (num1>num2)?”one millenium”:”two millenium”;

                                document.write(“<BR>str = “ + str);

      </SCRIPT> 

   </HEAD>

 

  <BODY>

  </BODY>

 

</HTML>

 

 

האופרטור void

 

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

 

בהמשך הספר יובא הסבר נוסף בנוגע לאופרטור זה.

 

 

האופרטור פסיק

 

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

 

אופרטור זה שימושי במיוחד בלולאת for.

 

התכנית הבאה מדגימה את השימוש באופרטור זה.

 

<!-- file name : CommaDemo.html -->

<!-- 2000(c) Zindell Publishing House Ltd. -->

 

<! DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">

 

<HTML>

 

  <HEAD>

    <TITLE>CommaDemo.html</TITLE>

      <SCRIPT LANGUAGE="JavaScript1.3">

        var i;

                                var n;

                                var m;

                                for (i=0, n=0, m=1; i<10; i++, m=m+n, n=m-n)

                                  document.write("<BR>"+m);

      </SCRIPT> 

   </HEAD>

 

  <BODY>

  </BODY>

 

</HTML>

 

 

האופרטורים new ו- delete

 

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

 

האופרטור new משמש ליצירתו של אובייקט חדש.

 

הסברים מפורטים בנוגע לשני אופרטורים אלה (בצירוף דוגמאות) יובאו בהמשך.

 

 

כללי הקדימויות של אופרטורים

 

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

 

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

 

 

1.       ,

2.       =  =+  =-  =*  =/  =%  =>>  =<<  =<<<  =&  =^  =| 

3.       ?    האופרטור הטרנרי

4.       | |    logical or

5.       &&   logical and

6.       |      bitwise-or

7.       ^     bitwise-xor

8.       &    bitwise-and

9.       ==   !=

10.   <   <=   >   >=

11.   <<   >>   >>>

12.   +   -

13.   *   /   %

14.   !   ~   -   +   ++   --   typeof   void   delete

15.   (  )   סוגריים של קריאה לפונקציה

16.   new

17.   [ ]   .

 

 

תרגילים

 

1.       כתוב/כתבי תכנית אשר תדגים את השימוש באופרטורים הבאים: =+ , =- , =*, =/ , =%.

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

3.       מה ההבדל בין פעולתו של אופרטור החילוק / ב-JavaScript לעומת שפות התיכנות C\C++ ו- Java ? כתוב/כתבי תכנית שמדגימה זאת.

4.       מה ההבדל בין האופרטור =! ו- ==! ? כתוב/כתבי תכנית שמדגימה זאת.

5.       כתוב/כתבי תכנית שמחשבת את התוצאה של העלאת המספר 2 בחזקת 1, 2, 3, 4 ו- 5 באמצעות האופרטורים שפועלים ברמת הביטים.

 

 

 

 

 

2000 © All the rights reserved to Haim Michael & Zindell Publishing House Ltd.

 

No parts of the contents of this paper may be reproduced or transmitted in any form by any means

without the written permission of the publisher !  This book can be used for personal use only !!!

 

 

Brought to you by Zindell 

(http://www.zindell.com)

 

 

 

 

 

 

לנוחיותך, להלן תוכן העניינים של הספר:

 

פרק 1 : הבסיס
פרק 2 : ערכים בסיסיים
פרק 3 : אופרטורים
פרק 4 : משפטי בקרה ולולאות
פרק 5 : פונקציות
פרק 6 : אובייקטים
פרק 7 : אובייקטים מובנים בשפה
פרק 8 : אופן פעולת האובייקטים
פרק 9 : תבניות טקסט
פרק 10 : שילוב של JavaScript ו- HTML
פרק 11 : טיפול באירועים
פרק 12 : האובייקטים שנוצרים בדפדפן
פרק 13 : האובייקט Navigator
פרק 14 : האובייקט Window
פרק 15 : האובייקט Document
פרק 16 : האובייקט Location
פרק 17 : האובייקט History
פרק 18 : יצירת cookies
פרק 19 : האובייקטים Link ו- Anchor
פרק 20 : האובייקט Image
פרק 21 : יצירת Image Map
פרק 22 : האובייקט Form
פרק 23 : טכנולוגית ה- LiveConnect