שימוש בדיבאגר בג'אווה

בלי כתוביותעם כתוביות

שימוש בדיבאגר בג'אווה

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

נושאי הסיכום המוצגים בשיעור:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

סיכום:

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

בשיעור הבא נעסוק בנושא תרגול של רקורסיה בג'אווה.

פרקי ההרצאה: שימוש בדיבאגר בג'אווה

תמלול ההרצאה: שימוש בדיבאגר בג'אווה

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

00:02
אנחנו מגיעים לנושא חשוב מאוד וזה נושא השימוש בדיבאגר. הדיבאגר זהו מנגנון שמאפשר לנו לבדוק את הקוד שלנו.
00:15
המנגנון הזה מאפשר לנו להריץ את הקוד שורה שורה ולצפות במשתנים שאנחנו מתעסקים איתם ולראות האם בעצם אנחנו כותבים קוד נכון, האם התוכנית עושה מה שעושה תוך כדי הריצה של התוכנית ממש שורה אחר שורה.
00:35
אז איך אנחנו בדיוק משתמשים במנגנון הזה? לצורך כך בואו נייצר כאן איזושהי פונקציה והאמת בואו נחזיר איזה אינטג'ר נקרא לה פונקציה getSam נקבל איזשהו מערך לתוך הפונקציה יש לנו פה איזשהו משתנה בואו נקרא לו summary נכניס לתוכו 0 נרוץ בלולאת 4 למרות שאנחנו יכולים forEach נשתמש פה לצורך הדוגמה ב-4 i שווה 0 כי אנחנו מערך i קטן מ-arrayLength ובואו נניח שתוך כדי הכתיבה בטעות
01:20
רשמנו length מינוס 1 i++. אוקיי, זאת כמובן שגיאה לוגית כי הערך שיוחזר הוא לא באמת הסכום של כל איברי המערך. בואו ניקח את ה-summary ונבצע פלוס שווה ל-array במיקום i ולבסוף נחזיר את ה-summary.
01:42
אז יש לנו כאן פונקציה שאמורה לחשב ולהחזיר את הערך המקסימלי, סליחה, את הסכום של איברי המערך, והיא לא תבצע את זה, היא כמובן תחזיר שגיאה, ואנחנו רוצים כמובן קודם כל לבדוק אם היא עובדת.
01:59
ניקח כאן מערך Numbers ונייצר איזשהו מערך בצורה כזאת, 10, 20, 30. נקרא לפונקציה ונחזיר את הסכום, סם, נשלח את המערך numbers ובואו נציג כאן את הסכום.
02:25
נריץ ונראה שהוא אומר לנו שהסכום זה 30, שזה כמובן לא נכון, הסכום לא 30, הסכום הוא 60. ובמקרה הזה יכול להיות שאנחנו נגיע לעצמנו, רגע, יש פה איזשהו באג, אני רוצה לברר בדיוק מה הבאג, אני יכול לרפרף בפונקציה ולנסות לאתר את הבאג במהירות ואם אני לא מצליח אז אני מכניס לשימוש את הדיבאגר.
02:48
מנגנון הדיבאגר אומר דבר כזה אני מסוגל לרוץ שורה שורה תגיד לי איפה אתה רוצה שאני אעצור בואו נעצור ממש בשורה הראשונה איך עושים את זה הולכים לאזור הזה ופשוט לוחצים דאבל קליק ויש לנו מעין נקודה כחולה קטנה דאבל קליק נוסף מעלים אותה הנקודה הזאת נקראת ברייק פוינט נקודת עצירה ברגע שאנחנו נריץ את מנגנון הדיבאגר
03:11
והוא ייתקל בברייק פוינט הוא יעצור ויאפשר לנו להתבונן בכל המשתנים בשלב הזה אנחנו יכולים לשים איפה שאנחנו רוצים ברייק פוינט. בואו נשים גם פה ברייק פוינט, בואו נשים גם פה ברייק פוינט.
03:22
ובכל פעם שאנחנו נריץ את התוכנית אז הוא יעצור בברייק פוינט. אנחנו יכולים לעצור בברייק פוינטים ואנחנו יכולים לרוץ שורה שורה.
03:31
איך אנחנו מריצים את התוכנית במצב דיבאגר? אם אנחנו נריץ קונטרול F11 כמו תמיד אנחנו לא נקבל עצירות בברייק פוינטים. אנחנו צריכים ללחוץ על הג'וק הזה, בואו נלחץ עליו אז התוכנית עוברת למצב די-באגר, נגיד לסוויץ', והנה אנחנו רואים שהתוכנית עוצרת לנו ממש כאן
03:55
בברייק פוינט הראשון. אם אנחנו נגיד לתוכנית לרוץ, ריזיום, אנחנו נראה שהיא עוצרת לנו בברייק פוינט השני. אם אנחנו נריץ, אנחנו נראה, טוב, זה בגלל שזה לולאה אז הוא ממשיך לעצור שם, אבל הנה הוא עוצר לנו בברייק פוינט השלישי.
04:11
אז קודם כל, בואו נמשיך ונסיים את התוכנית. קודם כל אנחנו רואים שאנחנו יכולים לעצור בכל מיני מקומות בתוכנית. דבר נוסף, בואו נריץ רגע שוב פעם את התוכנית על ידי הג'וק, הבאג הזה שיש פה.
04:26
אנחנו יכולים לראות כאן את רשימת הברייק פוינטים ששמנו ולבטל ברייק פוינט או להחזיר אותו. אתם רואים שאני כרגע מבטל את הברייק פוינט השלישי, כאן אני מבטל את השני, כאן אני מבטל את הראשון.
04:40
אז אנחנו יכולים לשלוט על איזה ברייק פוינטים אנחנו רוצים או לא רוצים להשתמש בהם. בואו רגע נעצור את התוכנית, נוריד רגע את הברייק פוינט השני והשלישי ונישאר רק עם הברייק פוינט הראשון.
04:55
כאן נריץ את התוכנית עם הבאג הזה, הג'וק הזה שמתאר באג, ואנחנו נמצאים עכשיו בשורה הראשונה. אנחנו רואים אותה צבועה בירוק. מה אנחנו רואים?
05:10
אנחנו רואים כאן variables. variables זה כל המשתנים שכרגע נפתחו בתוכנית. בינתיים רק הארגס הזה נפתח. אם אנחנו נעבור לשורה הבאה ויש לנו את שני החבר'ה האלה שמסוגלים לקפוץ לשורה הבאה, תכף נראה מה ההבדל ביניהם.
05:28
כרגע נשתמש בזה, בסטפ-אובר. אז אנחנו רואים שהוא גם עכשיו פתח לנו את ה-numbers ואנחנו יכולים לפתוח את ה-numbers ולהסתכל על כל הערכים שלו.
05:38
10, 20, 30. אנחנו רואים פה את ה-sum. אם אנחנו שוב פעם לוחצים על step-over אנחנו רואים שהוא התקדם הלאה והנה אנחנו רואים שיש לנו גם את ה-sum שהוא 30.
05:50
אז מה זה step over? step over זה בעצם קפוץ לפקודה הבאה, אבל אל תיכנס לפונקציות, אלא רק תבצע אותן. אנחנו רואים שיש לנו פה את ה-get sum, שלא באמת נכנסנו ודיבגנו את הפונקציה, אבל כן ביצענו אותה והיא החזירה לנו 30. אז זה בעצם step over.
06:13
החבר שלו זה step into. step into אומר, אם אתה מסמן פונקציה, סטפ אינטו ייכנס לתוך הפונקציה שורה שורה וידבק גם אותה.
06:24
גם את זה אנחנו רוצים לראות. אז בואו בשלב הזה נעצור ונריץ שוב פעם. אנחנו עוצרים בנקודת עצירה והפעם אנחנו לוחצים על סטפ אינטו.
06:40
סטפ אינטו במקרה הזה לא ייכנס לשום פונקציה מפני שאין לנו פונקציה כאן. אז אנחנו פשוט נעבור לשלב הבא. אבל כאן step into יגרום לכניסה לתוך getSum.
06:55
בואו נלחץ על step into ונראה שקפצנו מיידית לתוך getSum. כאן ה-variables הם אחרים. כל ה-variables הקודמים שהיו לנו נעלמו. היו לנו מקודם args ו-numbers, הם נעלמו.
07:11
נשאר לנו עכשיו ARR כי אנחנו נמצאים בסקופ