עכשיו בואו נדבר על משהו שאתם משתמשים
בו כל הזמן: פונקציות.

בכל פעם שאתם משתמשים בפקודה
כמו ()rect או ()fill או ()text

אתם בעצם קוראים לפונקציות, והפונקציות
האלו מציירות מה שאמרתם להן לצייר.

מהי פונקציה בעצם? זהו אוסף של קוד שאנחנו
מקבצים יחד ונתנו לו שם מכיוון שאנחנו רוצים

להשתמש בפונקציונאליות של הקוד הזה
פעמים נוספות בהמשך.

תחשבו על ()rect, מה בעצם ()rect עושה?
היא בסך הכל מצייאת ארבעה קווים נכון?

אנחנו יכולים פשוט לעשות את זה עם
פונקציית ()line נכון?

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

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

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

אז זה די מגניב, ו-()rect היא אחת מהפונקציות
האלו שנעשה בהן שימוש בכל התוכניות שלנו
כאן באקדמיית קאהן.

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

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

אולי בגלל שאנחנו הולכים לספר את סיפור חייו
של צ׳רצ׳יל ורוצים להראות אותו בכל גיל בחייו.

אז, הנה איך שהקוד שלנו שמצייר את צ׳רצ׳יל
אמור להתחיל:

יש לנו את המשתנים faceX ו-faceY על מנת
לאחסן את אמצע הפרצוף, ואז אחנו מציירים את
העיניים והפה ביחס למשתנים האלו.

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

אוקיי, בואי נהפוך את זה לפונקציה.

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

אז אנחנו אומרים ש"var drawWinston״ -
ניתן לזה שם יפה, מאוד תיאורי - ואז ״=״, אבל כאן,
במקום לכתוב מספר או טקסט, אנחנו הולכים

לכתוב את המילה פונקציה באנגלית ״function״
(וודאו שאתם מאייתים נכונה) ואז סוגריים ריקים ״()״
ואז נפתח ונסגור סוגריים מסולסלים וכמובן נקודה פסיק.

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

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

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

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

שימו לב אבל, שאין לנו את ווינסטון יותר!
איבדנו את ווינסטון! לאן הוא הלך?

אוקיי, מה שקרה הוא שברגע שלקחנו את הפונקציה
הזו והעברנו אותה למקום אחר, אמרנו לתוכנית שלנו

״היי, יש פה מלא קוד שאנחנו רוצים שירוץ
אחר כך, אבל רק כשאני אומר לך להריץ אותו״

אז אנחנו חייבים להגיד לו להריץ את הקוד, מה שאומר
שאנחנו חייבים לקרוא לפונקציה - בדיוק כפי שאנחנו
עושים עם ()eclipse או ()rect או ()line.

אז אנחנו פושטים כותבים את שם
הפונקציה 'drawWinston') ואחריה הסוגריים
שלנו ונקודה פסיק והופה! יש לנו את ווינסטון!

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

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

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

אם היה לנו ראיית רנטגן אז היינו יכולים לראת את
ווינסטון, אבל אין לנו!

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

אז אתם רואים את faceX ו-faceY - הם
תמיד 202 ו-208? אנחנו יכולים לשנות אותם בעזרת
הפונקציה ()random. בוא ניקח random

מ-50 עד 350 וזה ייצר מספר בין שני אלה -
ואנחנו יכולים לעשות את אותו הדבר כאן -

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

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

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

תישארו איתנו! הסרט הבא מדבר על פונקציות
שמקבלות סטרינגים טקסטואלים
ועושות איתם מגוון דברים