1
00:00:01,383 --> 00:00:05,750
עכשיו בואו נדבר על משהו שאתם משתמשים
בו כל הזמן: פונקציות.

2
00:00:05,750 --> 00:00:10,750
בכל פעם שאתם משתמשים בפקודה
כמו ()rect או ()fill או ()text

3
00:00:10,750 --> 00:00:14,001
אתם בעצם קוראים לפונקציות, והפונקציות
האלו מציירות מה שאמרתם להן לצייר.

4
00:00:14,539 --> 00:00:20,640
מהי פונקציה בעצם? זהו אוסף של קוד שאנחנו
מקבצים יחד ונתנו לו שם מכיוון שאנחנו רוצים

5
00:00:20,640 --> 00:00:23,640
להשתמש בפונקציונאליות של הקוד הזה
פעמים נוספות בהמשך.

6
00:00:23,640 --> 00:00:28,584
תחשבו על ()rect, מה בעצם ()rect עושה?
היא בסך הכל מצייאת ארבעה קווים נכון?

7
00:00:28,584 --> 00:00:31,584
אנחנו יכולים פשוט לעשות את זה עם
פונקציית ()line נכון?

8
00:00:31,584 --> 00:00:40,971
וכאן יש לנו משהו שנראה כמו מלבן.
אבל אנחנו מבינים שאנחנו בעצם רוצים
לשרטט ריבוע כמה פעמים, וזה יהיה מאוד מעצבן

9
00:00:40,584 --> 00:00:44,971
לעשות את המתמטיקה כל פעם כדי להבין איך
לצייר קו מפינה אחת לשנייה וכן הלאה.

10
00:00:44,971 --> 00:00:54,971
במקום, אנחנו פשוט משתמשים בפונקצייה ()rect,
והפונקציה הזו יודעת לעשות בדיוק את מה שארבעת
שורות הקוד האלו עושות, אבל בהרבה פחות קוד.

11
00:00:54,971 --> 00:01:02,750
אז זה די מגניב, ו-()rect היא אחת מהפונקציות
האלו שנעשה בהן שימוש בכל התוכניות שלנו
כאן באקדמיית קאהן.

12
00:01:02,750 --> 00:01:07,531
אבל - אתם יכולים לעשות גם פונקציות משלכם
על מנת להשתמש בהן בתוכניות.

13
00:01:07,531 --> 00:01:13,980
לדוגמא, בואו נגיד שאנחנו עושים תוכנית ואנחנו
רוצים לצייר את צ׳רצ׳יל הברווזון מספר פעמים -

14
00:01:13,980 --> 00:01:20,780
אולי בגלל שאנחנו הולכים לספר את סיפור חייו
של צ׳רצ׳יל ורוצים להראות אותו בכל גיל בחייו.

15
00:01:20,780 --> 00:01:24,243
אז, הנה איך שהקוד שלנו שמצייר את צ׳רצ׳יל
אמור להתחיל:

16
00:01:24,243 --> 00:01:32,768
יש לנו את המשתנים faceX ו-faceY על מנת
לאחסן את אמצע הפרצוף, ואז אחנו מציירים את
העיניים והפה ביחס למשתנים האלו.

17
00:01:32,768 --> 00:01:39,705
נכון לעכשיו התוכנה רואה את הקוד, והוא לא בתוך
פונקציה מסויימת - הוא פשוט רץ (מבוצע) והוא רץ
רק פעם אחת.

18
00:01:39,705 --> 00:01:43,336
אוקיי, בואי נהפוך את זה לפונקציה.

19
00:01:43,336 --> 00:01:49,336
אנחנו עושים את זה בצורה דומה מאוד לצורה
שבה אנחנו מסתכלים על משתנים, מכיוון שזה
בדיוק מה שאנחנו עושים.

20
00:01:49,336 --> 00:01:58,955
אז אנחנו אומרים ש"var drawWinston״ -
ניתן לזה שם יפה, מאוד תיאורי - ואז ״=״, אבל כאן,
במקום לכתוב מספר או טקסט, אנחנו הולכים

21
00:01:58,955 --> 00:02:10,955
לכתוב את המילה פונקציה באנגלית ״function״
(וודאו שאתם מאייתים נכונה) ואז סוגריים ריקים ״()״
ואז נפתח ונסגור סוגריים מסולסלים וכמובן נקודה פסיק.

22
00:02:10,955 --> 00:02:16,791
אז מה שאנחנו צריכים לעשות זה לשים את כל מה
שאנחנו רוצים שיהיה בתוך הפונקציה שלנו בתוך

23
00:02:16,791 --> 00:02:26,791
הסוגריים המסולסלים. אז אחנו הולכים לקחת
את כל הקוד הזה, לשים אותו בתוך הפונקציה
(ליישר אותו כראוי), והנה!

24
00:02:26,791 --> 00:02:33,500
עכשיו מה שיש לנו בעצם זה משתנה שמאחסן
פונקציה - כך שבעצם נתנו שם לבלוק הקוד הזה

25
00:02:33,500 --> 00:02:43,964
כך שנוכל להגיד לתוכנית שלנו בכל נקודת
זמן, היי תריץ את הקוד הזה עם השם שאמרתי לך!.
אז אנחנו עושים זאת לטובת שימוש חוזר.

26
00:02:43,964 --> 00:02:48,769
שימו לב אבל, שאין לנו את ווינסטון יותר!
איבדנו את ווינסטון! לאן הוא הלך?

27
00:02:48,769 --> 00:02:54,200
אוקיי, מה שקרה הוא שברגע שלקחנו את הפונקציה
הזו והעברנו אותה למקום אחר, אמרנו לתוכנית שלנו

28
00:02:54,200 --> 00:03:01,069
״היי, יש פה מלא קוד שאנחנו רוצים שירוץ
אחר כך, אבל רק כשאני אומר לך להריץ אותו״

29
00:03:01,069 --> 00:03:09,403
אז אנחנו חייבים להגיד לו להריץ את הקוד, מה שאומר
שאנחנו חייבים לקרוא לפונקציה - בדיוק כפי שאנחנו
עושים עם ()eclipse או ()rect או ()line.

30
00:03:09,403 --> 00:03:21,070
אז אנחנו פושטים כותבים את שם
הפונקציה 'drawWinston') ואחריה הסוגריים
שלנו ונקודה פסיק והופה! יש לנו את ווינסטון!

31
00:03:21,070 --> 00:03:29,673
אוקיי! אני חושבת שזה מגניב, אבל אתם אולי לא
תחשבו שזה מגניב מכיוון שכל מה שעשינו הוא לגרום
לתוכנית לעבוד בדיוק כמו מקודם, קצת מטופש לא?

32
00:03:29,673 --> 00:03:37,105
כל הטעם מאחורי פונקציות הוא שאנחנו יכולים
להשתמש בהם שוב. אז בואו נעשה את זה עכשיו.
אנחנו יכולים פשוט לשכפל את הקריאה לפונקציה

33
00:03:37,105 --> 00:03:50,905
ולשכפל שוב ושוב. אבל זה נראה אותו הדבר.
זה עובד, זה מצייר את ווינסטון מספר פעמים,
אבל הבעיה היא שהוא תמיד באותו המקום.

34
00:03:50,905 --> 00:03:59,632
אם היה לנו ראיית רנטגן אז היינו יכולים לראת את
ווינסטון, אבל אין לנו!

35
00:03:59,632 --> 00:04:04,837
אבל, אנחנו יכולים לעשות שינוי קטן לפונקציה
שלנו שאולי כן ייגרום להפרדה כלשהי.

36
00:04:04,837 --> 00:04:12,933
אז אתם רואים את faceX ו-faceY - הם
תמיד 202 ו-208? אנחנו יכולים לשנות אותם בעזרת
הפונקציה ()random. בוא ניקח random

37
00:04:12,933 --> 00:04:18,533
מ-50 עד 350 וזה ייצר מספר בין שני אלה -
ואנחנו יכולים לעשות את אותו הדבר כאן -

38
00:04:18,533 --> 00:04:30,133
וכך כל פעם שהפונקציה נקראת, היא מייצרת
מספר רנדומלי חדש. אם נעשה ריסטרט,
נוכל להמשיך לקבל מספרים אקראיים.

39
00:04:30,133 --> 00:04:38,403
אם כן, אז אני חושבת שזה מגניב בגלל שזה היה
יכול להיות הרבה שורות קוד לכתוב אם לא היה
לנו את זה בפונקציה - וזה גם היה כנראה פי 3 קוד.

40
00:04:38,403 --> 00:04:47,238
אבל זה עדיין לא הכי עוזר כמו שזה יכל היה להיות.
מכיוון שאנחנו כנראה לא רוצים ווינסטון רנדומלי,
אנחנו כנראה רוצים להיות מסוגלים למקם
את ווינסטון במקום ספציפי במסך.

41
00:04:47,238 --> 00:04:55,438
תישארו איתנו! הסרט הבא מדבר על פונקציות
שמקבלות סטרינגים טקסטואלים
ועושות איתם מגוון דברים