פונקציות - Functions (חלק 1)
Main. גם קטעי קוד שחוזרים במקומות שונים עדיפים להוצאה לפונקציה אחת. בדוגמה הדפסת שורה של 10 כוכביות הופיעה כמה פעמים בתוכנית, ובמקום להעתיק את הקוד מוציאים אותו לפונקציה ופשוט קוראים לה.static, כי Main סטטית וקוראת לה משם. משמעות static בתכנות מונחה עצמים תילמד בקורס אחר.void. פונקציה שמדפיסה כוכביות לא מבצעת חישוב, ולכן אין לה תוצאה להחזיר.PrintStars.int num, והלולאה רצה עד num. בקריאה מעבירים את המספר בתוך הסוגריים, למשל PrintStars(30). קריאה בלי פרמטר נכשלת בקומפילציה.char, כך שהפונקציה מדפיסה כל תו שנרצה. הסרטון מראה כיצד לקלוט תו מהמשתמש בעזרת Console.Read(), שמחזירה את התו כמספר, ולכן צריך להמיר אותו ל-char.F10 (step over) מריץ את הפונקציה בלי להיכנס אליה, ו-F11 (step into) נכנס לתוכה. בתוך הפונקציה אפשר לראות את הערך שהתקבל בפרמטר.return, ולא להציג אותה על המסך. כך מי שקורא לה יכול להחליט מה לעשות בתוצאה: להציג, לשמור או להשתמש בה בחישוב נוסף.פרקי ההרצאה: פונקציות - Functions (חלק 1)
תמלול ההרצאה: פונקציות - Functions (חלק 1)
הטקסט המלא של הדקות הראשונות בהרצאה «פונקציות - Functions (חלק 1)» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
אנחנו עוברים לאחד הנושאים החשובים ביותר בעולם האלגוריתמיקה ופיתוח תוכנה. והנושא הזה נקרא פונקציה. פונקציה זה יחידה לוגית קטנה שאנחנו כותבים, שמבצעת פעולה מוגדרת כלשהי.
למה חשוב לנו לדעת את נושא הפונקציה? כאשר אנחנו מפתחים קוד עולם פיתוח התוכנה אנחנו הולכים לפתח קוד שהוא בסדרי גודל מאוד מאוד גדולים. בדרך כלל תוכנות בנויות מכמות עצומה של פקודות של שורות קודם וברגע שיש לכם כמות עצומה של פקודות אתם לא כותבים את כל הפקודות באזור הזה של המיין בין הפתיחה לסגירה זה פשוט לא יהיה ממשי
וזה too much במקום אחד בנוסף יכול להיות שאת אותן הפעולות בדיוק אני רוצה לבצע במקומות שונים במהלך התוכנית לכן לא הגיוני שאני פשוט אכתוב את הקוד הזה בצורה חוזרת.
לכן אנחנו יכולים לקחת קטעי קוד ולהוציא אותם למשהו שנקרא פונקציה, יחידה קטנה, ואז לקרוא לפונקציה והקטע קוד שלה יתבצע מתי שאנחנו קוראים לה.
אז בואו נראה איך זה מתבצע. ראשית אני אכתוב קטע שלא קשור לפונקציות. בוא נניח שאני רוצה עכשיו להדפיס שורה של כוכביות, בוא נניח 10 כוכביות על המסך.
אז כל מה שהייתי צריך לעשות זה להגדיר לולאה שרצה מאחד הדרך. 10 בוא נשים פה 1 קטן שווה 10 ואנחנו רוצים להדפיס כוכבית אחת ומיד אחר כך לרדת שורה בואו נריץ ונראה 10 כוכביות על המסך בואו נניח שלאחר מכן אני רוצה לבצע פעולה אחרת וכאן אני רוצה לבצע בדיוק את אותו הדבר זאת אומרת שהייתי צריך עכשיו לשכפל את הקוד לכאן וכמובן הייתי רואה 10 כוכביות doing
something עוד 10 כוכביות בואו נניח שאני הייתי רוצה מיד אחר כך לבצע משהו אחר doing something else, מדבר עם המשתמש, מבצע כל מיני פעולות, ועוד פעם היינו רוצים להדפיס 10 כוכביות, אין בעיה, העתקנו את הקוד ויש לנו שוב פעם הדפסה של 10 כוכביות.
אבל רגע, חזרנו פה על שורות קוד, מה קורה אם אנחנו רוצים לבצע עוד פעם ועוד פעם ועוד פעם את הקוד הזה בכל מיני מקומות שונים בתוכנית?
מה קורה אם הקוד הזה גם יכול להיות הרבה יותר מורכב? זאת אומרת שיש לנו פה כבר חזרה על המון שורות קוד.
במקום לחזור על כל קטעי הקוד האלה שוב ושוב, מה שאנחנו יכולים לעשות זה פשוט להוציא את הקטע קוד הזה למשהו שנקרא פונקציה. פונקציה זה פשוט מאוד אזור שנכתב מחוץ למיין, הוא נכתב כאן והוא מבצע איזושהי פעולה מוגברת אחת.
לאזור קוד הזה יש שם והוא בנוי בצורה מאוד ספציפית ואנחנו יכולים לאחר מכן להפעיל אותו. היתרון שאנחנו בונים את זה באזור הקוד החיצוני הזה זה שאנחנו כותבים את הקוד הזה רק פעם אחת ואחר כך מפעילים אותו בכל מקום שהקוד הזה דרוש.
איך בדיוק כותבים פונקציה? דבר ראשון אנחנו כותבים כרגע את המילה Static. המילה Static קשורה לעולם פיתוח תוכנה שנקרא Object Oriented Programming.
בעברית זה נקרא תכנות מונחה עצמים. Object Oriented Programming זה בעצם שיטה תכנותית שמדברת על חלוקה של המערכת למשהו שנקרא עצם ועצמים או אישויות.
אנחנו רואים כאן אישות אחת שנקראת פרוגרם. אנחנו לא הולכים להיכנס לעולם האובג'ט אוריינטד פרוגרמינג בקורס הזה, כי הוא שייך לעולם האלגוריתמיקה, רק כלים בסיסיים שקיימים כמעט בכל שפת תכנון בעולם, כמו תנאים, לולאות, קלט, פלט וכמובן פונקציות.
אבל בקורס אחר שקשור לעולם האובייקט אוריינטד אנחנו כמובן הולכים לדבר על המילה סטטי ולהבהיר מה בדיוק המשמעות שלה.
כרגע כל מה שאנחנו צריכים לדעת זה שאנחנו צריכים לכתוב את המילה סטטי מפני שאנחנו רוצים להשתמש בפונקציה שלנו מתוך המיין וגם המיין מוגדרת סטטי.
הדבר הבא שאנחנו צריכים לרשום זה איזשהו סוג נתונים שהפונקציה מחזירה. פונקציה מסוגלת להחזיר לנו מידע בכדי שנשתמש איתו. אם פונקציה מחזירה מידע, זה בדרך כלל יהיה תוצאה של חישוב שהפונקציה מבצעת.
אבל רגע, איזו תוצאת חישוב יש לנו עבור הצגה של 10 כוכביות? אז למעשה אין לנו פה שום תוצאת חישוב מפני שאנחנו לא מבצעים חישוב.
כל מה שאנחנו רוצים לעשות זה להדפיס 10 כוכביות על המסך. בגלל שהפונקציה לא אמורה לבצע שום חישוב, היא לא אמורה להחזיר לנו שום תוצאת חישוב.
ולכן אם פונקציה לא מחזירה כלום, אנחנו כותבים void, בדיוק מה שאנחנו רואים במיין. גם המיין במקרה הזה לא מחזירה שום דבר. ווייד באנגלית זה ריק, כלומר כלום.
הפונקציה לא מחזירה כלום. הדבר הבא שאנחנו כותבים זה שם משמעותי שאנחנו צריכים לתת לפונקציה. בדיוק כמו שאנחנו ממציאים שמות משמעותיים למשתנים, כך אנחנו אמורים להמציא שמות משמעותיים לפונקציה.
הדבר הנכון לעשות זה שהשם של פונקציה יהיה שם של פעולה. פונקציה עושה משהו. שם של משתנה אמור להיות שם של איזשהו עצם או יחידה שהיא מכילה מידע או משהו כזה.
פונקציה זה פעילות ולכן רוב רוב הפונקציות השמות שלהם זה שמות של פעילויות. מה אנחנו רוצים לעשות? אנחנו רוצים להדפיס 10 כוכביות ולכן נקרא לפונקציה נותן סטארט אוקיי לאחר מכן אנחנו כותבים פתיחה של סוגריים וסגירה של סוגריים ובלוק קוד של הפונקציה נכתב בין הפתיחה לבין הסדירה של הסוגריים המסולסלות.
עכשיו אנחנו יכולים לקחת את הקוד הזה, למחוק אותו מפה ולהדביק אותו כאן. וכעת הקוד הזה נחשב כקוד שקיים בתוך פונקציה שנקראת Printed Stars. הפונקציה מוכנה, כל מה שאנחנו צריכים לעשות זה לקרוא לה.
לכן בדיוק איפה שאני רוצה לבצע את הקוד שלה, אני קורא לה פשוט על ידי זה שאני רושם את השם שלה בסוגריים. אני עכשיו רוצה לעשות את הפעולה הזאת של קריאה לפונקציה גם כאן וגם כאן ושימו לב שהתוכן של הפונקציה הקוד כביכול המורכב שעושה את הפעולה ולמרות שכרגע הוא מאוד מאוד פשוט במציאות הוא יכול להיות
מאוד מאוד מורכב ולעשות דברים ממש מטורפים הקוד הזה נכתב פעם אחת בלבד לא שכפלתי אותו כל מה שאני עושה אני פשוט קורא לה זה נקרא קריאה לפונקציה calling the function קיבלנו את אותה התוצאה בדיוק מבלי לשכפל את הקוד.
זאת הפונקציה הראשונה שהצלחנו לכתוב ואנחנו הולכים לראות עכשיו עוד דברים בנוגע לפונקציות. הדבר הבא שאנחנו הולכים לראות בעולם הפונקציות זה צורה נכונה לכתוב פונקציה.
כאשר אנחנו הולכים לכתוב פונקציה יש שני כללים מרכזיים שחייבים להנחות אותנו. אם אנחנו נבין לגמרי את הכללים האלה נוכל לבנות פונקציות בצורה נכונה זה יקל עלינו בצורה משמעותית את כל התוכנית.
אז הכלל הראשון הוא פונקציה צריכה לבצע פעולה לוגית מוגדרת אחת, לא שתי פעולות או יותר. כאשר אני אומר פעולה לוגית אחת אני לא מתכוון לפקודה אחת.
פונקציה יכולה להכיל המון שורות קוד. אני מתכוון מבחינה רעיונית מה הפונקציה עושה. לדוגמה הפונקציה הזאת מדפיסה שורה של כוכביות, למעשה שורה של 10 כוכביות.
זה בעצם אפשר להחשיב את זה כפעולה אחת, הדפס לי 10 כוכביות על המסך. פונקציה הזאת לא הייתה טובה אם היא גם הייתה מדפיסה 10 כוכביות על המסך, וגם לדוגמה הייתה מציירת ריבוע על המסך.
אלה שתי פעולות לוגיות שונות ולכן היה רצוי לחלק את זה לשתי פונקציות שונות, אחת שמדפיסה 10 כוכביות ואחת שמדפיסה ריבוע. לא מערבבים אותם ביד, כנ"ל פונקציה שקולטת מידע מהמשתמש ומבצעת חישוב.
היינו יכולים להפריד את זה אחת קולטת אחת מבצעת את החישוב. פונקציה שמדפיסה חתול על המסך ופונקציה שמדפיסה כלב על המסך אלו יהיו שתי פונקציות שונות לא יהיו בפונקציה אחת שמדפיסה גם כלב וגם חתול.
אז אתם מבינים את הרעיון לכן הפונקציה הזאת עומדת בחוק הזה. החוק השני אומר שלמרות שהפונקציה מבצעת פעולה לוגית אחת היא צריכה להיות מספיק כללית בשביל לבצע וריאציות שונות של אותה פעולה.
מה זה אומר? הפונקציה הזאת מדפיסה סדרה של כוכביות על המסך, אבל היא מדפיסה רק 10 כוכביות על המסך. אוקיי, אז זאת אומרת שאם אנחנו קוראים לה אנחנו מקבלים 10 כוכביות מוצגות על המסך.
אבל האם זה באמת מספיק כללי? זאת אומרת, אם מי שהיה רוצה להשתמש בפונקציה היה רוצה להדפיס 11 כוכביות או 8 כוכביות או 27 כוכביות, האם הפונקציה הזאתי שעבדנו קשה בשביל לכתוב אותה הייתה פותרת לו את הסיטואציה הזאת?
התשובה כמובן לא, כי הפונקציה הזאת מציגה רק 10 כוכביות על המסך, ולכן היא לא עומדת בכלל השני ולכן היא לא מספיק טובה.
אם היינו עומדים בכלל השני, זה אומר שהפונקציה הזאת הייתה יכולה להדפיס כל מספר של כוכביות על המסך. אבל איך זה יכול להיות? הרי הפונקציה הזאת גם נקראת print 10 stars, אוקיי, המצאנו לה את השם, אנחנו יכולים להמציא לה שם אחר, וגם אנחנו רואים שבלולאה היא מתחילה מ-1 ורצה
עד 10, זאת אומרת שזה מה שהיא יודעת לעשות. הפונקציה הזאת כביכול לא יכולה להדפיס יותר מזה. אז הסיבה שהיא לא מדפיסה יותר מזה זה בגלל שלא כתבנו אותה נכון, ולא כתבנו אותה בצורה כזאת שהיא תהיה מספיק כללית בשביל להדפיס את אותה הפעולה הלוגית של הצגת מספר כוכביות על המסך
באופן מספיק כללי שיתפור את כל המקרים בעולם של הדפסת כוכביות על המסך. אז איך בעצם אנחנו יכולים לבנות אותה כך שהיא תהיה מספיק כללית?
זה מתבצע על ידי עוד עיקרון שקיים בפונקציות, וזה בעצם אפשרות של קבלת מידע לפונקציה על ידי מי שקורא לה. אותו אזור שקורא לפונקציה יכול להעביר לה מידע בכדי שהיא תשתמש עם המידע הזה.
לצורך כך אנחנו יכולים לקלוט משתנים בסוגריים של הפונקציה. זאת הסיבה שיש פה סוגריים. אם יש פה סוגריים ריקים, אז הפונקציה נחשבת ככזאת שהיא לא מקבלת משתנים ולכן היא לא מספיק כללית אבל אם אנחנו רוצים במקרה הזה שהיא תהיה מספיק כללית אנחנו יכולים לא לקבוע את המספר 10 פה אלא
לקבל איזשהו משתנה שמי שקורא לה מעביר לה כמה הוא רוצה כוכביות להדפיס על המסך. זה אומר שאנחנו יכולים לכתוב פה איזשהו אינטג'ר לדוגמה num ועכשיו אנחנו לא רצים עד 10 אלא עד num.
וכעת הפונקציה הזאת קיבלה מספר אינטג'רי כלשהו, רצה מ-1 עד המספר שהיא קיבלה והציגה כל פעם כוכבי. זאת אומרת שמה שהיא עושה היא מדפיסה נם כוכביות, וכעת היא באמת בנויה בצורה כללית כך שהיא גם עושה פעולה לוגית מוגדרת אחת ויחידה, זאת אומרת הצגת קו של כוכביות על המסך, וגם היא בנויה בצורה
מספיק כללית כך שהיא תוכל להציג כל קו שנרצה. עכשיו אנחנו כמובן רואים שיש פה שגיאה בקריאה לפונקציה והסיבה היא כי כאשר פונקציה מקבלת ערך אנחנו חייבים לשלוח לה את הערך מפני שבשביל לעבוד היא אומרת לנו אתם רוצים שאני אעבוד ואני אדפיס לכם num כוכביות?
אתם חייבים לספק לי את המספר הזה ופה בקריאה אני רואה שלא סיפקנו שום דבר אז בואו עכשיו נפתח סוגריים ונראה שוויז'ל סטודיו אומרת לנו שמה שהפונקציה מצפה לקבל זה מספר אינטג'רי שנקרא num בואו ניתן לה בפעם הראשונה 10 בפעם השנייה 20 בפעם השלישית בואו נניח 7. כעת אנחנו יכולים להריץ את זה
ולראות שיש לנו במספר מקומות הצגה של שורת כוכביות אותה הפונקציה בדיוק הצליחה לעשות את זה זאת אכן פעולה לוגית אחת ויחידה אבל היא מספיק כללית בכדי שהיא תוכל להציג כל מספר כוכביות שנרצה מבלי לחזור על הקוד הרי זה לא היה הגיוני שהיינו כותבים את הפונקציה הזאת שלוש פעמים או ארבעים פעם כל פעם בשביל להציג מספר אחר של כוכביות.
כך כתבנו אותה בצורה מספיק כללית שהיא יכולה להציג כל מספר של כוכביות, כל מה שהיא אומרת לנו זה תביאו לי בבקשה את המספר שאתם רוצים, אני כבר ירוץ אליו.
כמובן שהשם של הפונקציה כבר לא הגיוני שהוא יהיה print10stars אלא אנחנו יכולים לרשום printstars אם אנחנו משנים את השם של הפונקציה אנחנו רואים שיש לנו משהו שנקרא Smart Tag אתם רואים את הסימן האדום הזה אם אתם מרחפים עליו עם העכבר אתם יכולים לראות שנפתח לנו אפשרות שאנחנו יכולים להקליט
ו-To Rename Printed Stars to Printed Stars אם אנחנו לוחצים על זה אנחנו רואים שוויז'ל סטודיו הולכת ומיד משנה את כל המקומות של השם הקודם בשם החדש אפשרות לעשות את זה גם מהמקלדת אומרת דבר כזה בואו נחזיר את זה לצו הקודם ונשנה את זה שוב פעם.
נמחוק את ה-10, נקבל את הסמארט טאג האדום, קונטרול נקודה פותח לנו בדיוק את ה-Rename הזה ו-Enter משנה את זה. קונטרול נקודה באנגלית, Enter או קונטרול צדיק סופית בעברית באותו מקש.
בואו נריץ, נראה שהוא עובד כמו מקודם. בואו נקרא לפונקציה בצורה כזאת. נגיד למשתמש Enter a number, פרינט סטארס סאם נמבר ילדנו מהמשתמש סאם נמבר אנחנו יכולים עכשיו לקרוא לפונקציה פרינט סטארס ולשלוח לה את סאם נמבר כלומר את הערך שלו בואו נריץ נשים את זה פה בצד אנחנו רואים שהתוכנית
מבקשת מהמשתמש להכניס איזשהו מספר בואו נכניס את המספר 30 נלחץ על אנטר ונראה שיש לנו פה קו של 30 כוכביות בואו נריץ את זה עם מנגנון הדיבאגר שדיברנו עליו בעבר נדליק אותו, נתחיל את התוכנית ואנחנו רואים שאנחנו בעצם מגיעים לפקודה הראשונה.
והפקודה הראשונה היא פקודה בעצם שאומרת אני הולך לקפוץ לפונקציה print stars. עכשיו נקודה חשובה בנוגע למנגנון הדיבאגר שמאפשר לנו לראות את הקוד שורה שורה.
אנחנו רואים שורה צהובה. חוק אומר שורה צהובה שאתם רואים כרגע זו שורה שעדיין לא בוצעה וכאשר אנחנו בעזרת הסמן הזה או בעזרת המקש f10 במקלדת אנחנו אמורים רק אז לבצע את הפקודה אז אם אנחנו מסתכלים כרגע על הקונסול אנחנו רואים שאין לנו פה שום דבר מודפס על הקונסול מפני שהפקודה עוד
לא התבצעה אם אנחנו לוחצים f10 אנחנו רואים שהוא ביצע את הפונקציה הזאת וכעת אנחנו יכולים לראות על הקונסול 10 כוכביות אוקיי בואו נמשיך נבצע את הפקודה הבאה ונראה על על הקונסול את הפקודה, את השורה do something, doing something ועכשיו בואו נראה אפשרות אחרת עם מנגנון הדיבאגר אנחנו יכולים לקפוץ לפונקציה על ידי משהו
שנקרא f11, זה יהיה step into בניגוד לסטפ אובר שלנו מקודם, step into מה שהוא אומר ואני קופץ לתוך הפונקציה במקרה הקודם דילגנו מעל הפונקציה אבל המערכת כן ביצעה אותה, כעת אנחנו קופצים לתוך הפונקציה אנחנו עכשיו יכולים להמשיך לטייל בתוך הפונקציה ולראות איך היא פשוט מתבצעת בצורה כזאת, ויש לנו פה אפשרות to step one-hat of step
out והוא סיים את הפונקציה ויכול להמשיך הלאה אנחנו יכולים לראות עכשיו 20 כוכביות על המוסך. בסדר בואו נמשיך נדפיס עוד 7 כוכביות בעזרת step over נקבל מהמשתמש איזשהו מספר נניח את המספר 3 וכעת מה שרציתי להראות זה שב-sum בנאמבר קיים המספר 3. אם אנחנו נכנסים לתוך