פונקציות - עשה ואל תעשה

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

פונקציות - עשה ואל תעשה

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

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

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

2. כלל ראשון, שם משמעותי: שם הפונקציה חייב להיות משמעותי ואין לבצע קיצורים, כמו במשתנים, וחשוב שיהיה שם של פעולה ולא שם של עצם, וב-Java שמות פונקציות צריכים להיות בסגנון lower camel case כמו שמות משתנים.

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

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

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

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

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

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

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

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

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

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

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

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

סיכום:

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

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

פרקי ההרצאה: פונקציות - עשה ואל תעשה

תמלול ההרצאה: פונקציות - עשה ואל תעשה

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

00:02
אחרי שראינו איך אנחנו יכולים לבנות פונקציה, איך אנחנו יכולים לקרוא לה, לשלוח ארגומנטים, לקבל ערך מוחזר ועוד כל מיני טריקים לגבי פונקציות, בואו נראה כל מיני חוקים לגבי מה נכון לעשות ומה לא נכון לעשות כאשר בונים פונקציות.
00:23
חוקים לגבי בניית פונקציות. אז קודם כל ישנם מספר כללים כמו כללי אצבע כאלה של איך נכון לבנות פונקציות. אם אנחנו שומרים על הכללים האלה אנחנו מצליחים לבנות קוד שהוא נכון, הוא מכיל אפיון נכון ומאוד קל לשימוש ולתחזוקה.
00:47
אם אנחנו מתעלמים מהכללים האלה שכבר אנחנו נראה אז הקוד שלנו הופך להיות קוד גרוע, bad design מה שנקרא, bad coding. בואו נראה מה הכללים האלה אומרים.
00:59
דבר ראשון, שם הפונקציה חייב להיות משמעותי, זה הגיוני. אין לבצע קיצורים, קיצורים זה כמובן לא טוב, כמו במשתנים. חשוב ששם הפונקציה יהיה שם של פעולה ולא שיהיה שם של עצם, ברוב המקרים בוא נגיד, ובג'אווה שמות פונקציות צריכות להיות lower camel case, כמו שמות של משתנים.
01:23
אז בואו נראה מספר דוגמאות. האם הפונקציה הזאתי טובה? השם px? אז כמובן שלא. מה זה בדיוק px? זה בכלל לא שם משמעותי.
01:36
האם השם הזה טוב לשם של הפונקציה הזאת שמה שאנחנו רואים היא מציגה פה על המסך כל מיני פעולות שאפשר לעשות עם לדוגמה כספומט PRT. אז PRT זה נראה כמו קיצור של משהו של אולי פרינט לא שם טוב האם השם הזה טוב זה כבר מתחיל להיות שם יותר משמעותי אבל הייתי אומר שלא מפני שפרינט זה שם כללי מדי מה בדיוק הוא אמור להדפיס מי שקורא לפונקציה הזאת בעצם לא יודע מה היא אמורה כל כך להדפיס לפי
02:09
השם. האם היא אמורה להדפיס פרטים של משתמש, תפריט, אולי להדפיס חתול? האם השם הזה טוב?
02:18
זה כבר מתחיל להיות יותר שם שקשור למה היא עושה, אבל עדיין לא הכי טוב, מפני ששם מניו זה לא שם של פעולה, זה שם עצם.
02:30
אז יש לנו פה את פרינט מניו. האם השם הזה מספיק טוב? עדיין לא, כי זה לא לואור קאמל קייס. ולבסוף יש לנו את פרינט מניו בצורה כזאת, פי קטנה, אם גדולה, וזה כמובן שם נכון לפונקציה.
02:49
גם שם משמעותי, לא מקוצר, לואוור קאנל קייס, עובד. כלל מספר 2. פונקציה צריכה לבצע מטלה לוגית אחת ויחידה. האם הפונקציה הזאת טובה?
03:03
פרינט סקוויר אנד טריאנגל, ואנחנו רואים שהיא מציגה גם ריבוע וגם משולש. אז כמובן שלא. הפונקציה מבצעת שתי מטלות לוגיות.
03:14
האם הפונקציה הזאת בסדר, הפונקציות האלה בסדר? הראשונה Print Square, השנייה Print Triangle. אז כן, כל אחת מבצעת מטלה לוגית אחת.
03:27
כלל מספר שלוש, פונקציה צריכה להיות מספיק כללית בכדי לבצע וריאציות שונות של אותה המטלה הלוגית. בואו נראה. האם הפונקציה הזאת מספיק טובה?
03:41
Print Line of Stars? לא. היא מציגה רק 10 כוכביות. מה יקרה אם אני ארצה להציג 12 כוכביות? היא כבר לא טובה לי.
03:52
אז אנחנו משיגים את הדבר הזה על ידי שליחת פרמטרים לפונקציה. בואו נראה את הפונקציה הזאת. print line of stars שמקבלת int size. מעולה.
04:05
הפונקציה הזאת יכולה להציג כל קו של כוכביות, כל אורך קו. והפונקציה הזאת אפילו יותר טובה מפני שהיא מקבלת במקום כוכבית את ה-char להדפיס, כך היא יכולה להיות עוד יותר כללית ולהדפיס כל קו שאנחנו רוצים, לאו דווקא כוכביות.
04:25
אוקיי, בואו נראה את הדבר הבא. 4. פונקציה חישובית לא אמורה להציג את תוצאת החישוב, אלא היא צריכה להחזיר את תוצאת החישוב. האם הפונקציה הזאת בסדר?
04:40
Calc Average ומה שעושה המחשבת ממוצע ומציגה אותו. כמובן שלא, אנחנו לא נוכל להשתמש בה אם אנחנו נרצה לבצע חישוב ממוצע, ולא להציג אותו על המסך אז הפונקציה הזאת היא לא בסדר וחוץ מזה שהיא מפרה את הכלל של פונקציה לא מבצעת שתי פעולות לוגיות שונות כאן הפונקציה הזאת היא גם מחשבת וגם מציגה
05:05
בואו נראה את הפונקציה הזאת Calc Average מבצעת חישוב ומחזירה את החישוב נראית בסדר גמור 5 פונקציה לא אמורה לקבל ארגומנט שהיא לא משתמשת איתו האם הפונקציה הזאת בסדר היא מקבלת מערך היא מקבלת כותרת להצגה והיא מקבלת פוטר, כותרת תחתונה, אבל היא לא משתמשת עם הפוטר, אז כמובן שהיא לא בסדר.
05:34
היא לא מבצעת שימוש בפוטר, היא לא אמורה לקבל את הפוטר. האם הפונקציה הזאת בסדר? היא מקבלת רק את המערך ומקבלת את ההדר להצגה, מציגה את ההדר ומייד אחר כך מציגה את המערך.
05:47
נראה שהיא בסדר גמור, היא משתמשת בכל הארגומנטים שלה. האם הפונקציה הזאת בסדר? היא מקבלת מערך, ופוטר מציגה את ההדר, מציגה את המערך, מציגה את הפוטר, משתמשת בכל הארגומנטים שלה, אין איתה שום בעיה.