1
00:00:00,700 --> 00:00:07,260
בואו נדבר על לולאות. יש לי פה לולאת while (או בעברית: לולאת ״כל עוד״), ועם כמה שורות קוד, אני יכולה לכתוב את ההודעה הזו לאורך כל המסך.

2
00:00:07,260 --> 00:00:10,335
אם אני אשנה את ההודעה ככה, בשביל לעשות אותה טובה יותר

3
00:00:10,335 --> 00:00:11,926
כל ההודעות משתנות.

4
00:00:11,926 --> 00:00:15,833
אז איך זה עובד? ובכן, נוכל להסתכל על הקוד הזה עוד רגע

5
00:00:15,833 --> 00:00:19,422
אבל קודם כל בואו ניקח צעד אחורה ונחשוב על איך היינו כותבים את התוכנית הזו

6
00:00:19,422 --> 00:00:22,471
בעזרת מה שאנחנו יודעים כרגע מבלי להשתמש בלולאות.

7
00:00:22,471 --> 00:00:26,751
בשביל לעשות את זה, היינו צריכים לכתוב המון פעמים את הטקסט הזה שוב ושוב ושוב נכון?

8
00:00:26,751 --> 00:00:32,590
היינו משתמשים בפונקציית text, כותבים הודעה, שמים את זה למעלה, ועכשיו פשוט חוזרים על זה

9
00:00:32,590 --> 00:00:36,336
מספיק פעמים כך שבסוף היינו מקבלים טקסט מלמעלה עד למטה.

10
00:00:36,336 --> 00:00:38,949
וזה ייקח המון עבודה נכון?

11
00:00:38,949 --> 00:00:42,753
מכיוון שהלמטה די רחוק, וזה אפילו גרוע יותר אם

12
00:00:42,753 --> 00:00:46,758
שזה לא 70, זה צריך להיות קרוב יותר, נגיד,

13
00:00:46,758 --> 00:00:50,709
60. ועכשיו זה משפיע על זה מכיוון שזה צריך להיות קטן יותר

14
00:00:50,709 --> 00:00:55,036
וכל אלו בהמשך, עוד קריאות שאנחנו צריכים לבצע.

15
00:00:55,036 --> 00:00:58,261
למעשה, בדרך הזו ייקח אפילו יותר זמן להגיע למטה.

16
00:00:58,261 --> 00:01:02,176
אז, זה די מעצבן, ולמזלנו יש לנו לולאות שיעזרו לנו

17
00:01:02,176 --> 00:01:06,210
מעתה והלאה, בכל זמן שאתם רואים קוד שחוזר על עצמו כך, המחשבה הראשונה שלכם תהיה

18
00:01:06,210 --> 00:01:10,087
״האם אני יכול להשתמש פה בלולאה?״ לולאה תאפשר לנו לחזור על הקוד שכתבנו שוב ושוב

19
00:01:10,087 --> 00:01:14,251
ושוב, תוך כדי שאנחנו עושים רק שינויים קטנים בכל פעם, וכך אנו

20
00:01:14,251 --> 00:01:17,868
היינו משכתבים את הקוד הזה עם לולאה. על מנת להתחיל, אנחנו צריכים להקליד ״while״,

21
00:01:17,868 --> 00:01:22,089
סוגריים, ואז סוגרים מסולסלים. אנחנו הולכים לקבל את ההודעה הזו אבל

22
00:01:22,089 --> 00:01:26,301
זה רק בגלל שלא סיימנו עדיין. אל תדאגו, היא תעלם כשנסיים.

23
00:01:26,301 --> 00:01:30,810
בכל פעם שאתם יוצרים לולאה אתם צריכים לענות על שלוש שאלות מפתח.

24
00:01:30,825 --> 00:01:33,370
והנה הן:

25
00:01:33,370 --> 00:01:37,371
השאלה הראשונה היא: ״על מה אני רוצה לחזור?״

26
00:01:37,371 --> 00:01:41,466
מה שאנחנו רוצים לחזור עליו צריך להיות בין הסוגריים המסולסלים.

27
00:01:41,466 --> 00:01:46,198
אנחנו רוצים לחזור על הקריאה לפונקציית text בשלב זה, אז נשים את זה פה.

28
00:01:46,198 --> 00:01:49,571
אבל זה מדי מטופש לא? מכיוון שכרגע אנחנו הולכים לחזור על

29
00:01:49,571 --> 00:01:53,477
קריאה לאותה פונקציית text שוב ושוב, שזה לא ממש טוב, כי אנחנו צריכים שמשהו יישתנה

30
00:01:53,477 --> 00:01:57,710
מה שמביא אותנו לשאלה השנייה, שהיא ״מה היינו רוצים שיישתנה בכל פעם?״

31
00:01:57,710 --> 00:02:01,423
אז היינו רוצים לשנות את מיקום ה-״y״ נכון? היינו רוצים שהוא יהפוך ל-60 ואז היינו

32
00:02:01,423 --> 00:02:05,503
רוצים שהוא יהפוך ל-80. אז בואו נכניס את זה למשתנה במקום

33
00:02:05,503 --> 00:02:09,476
שנקרא y, מכיוון שזהו מיקום ה-y. אז בואו נגדיר משתנה חדש

34
00:02:09,476 --> 00:02:13,376
כאן למעלה. אני אאתחל אותו עם הערך 40. ועכשיו, אנחנו רק צריכים

35
00:02:13,376 --> 00:02:17,205
לשנות את y. אנחנו יכולים לעשות את זה כאן למטה, נוכל להגיד ש-y מקבל את y + 20

36
00:02:17,205 --> 00:02:21,088
ואז הוא ייגדל בכל פעם. ולמעשה, אנחנו יכולים להשתמש

37
00:02:21,088 --> 00:02:24,745
במה שלמדנו בשיעור קיצור קוד כאן. אנחנו יכול להשתמש

38
00:02:24,745 --> 00:02:29,092
בקיצור. מעולה, ואנחנו רק

39
00:02:29,092 --> 00:02:32,705
צריכים לענות על שאלה מספר שלוש עכשיו, שהיא ״לכמה זמן היינו רוצים לחזור על הפעולה הזו?״

40
00:02:32,705 --> 00:02:36,531
אנחנו הרי רוצים לעשות זאת שוב ושוב ושוב, אבל אנחנו לא באמת רוצים לעשות את זה לנצח נכון?

41
00:02:36,531 --> 00:02:41,252
אם נעשה את זה לנצח, קודם כל, זה הרבה זמן, דבר שני, יש סיכוי שזה יקריס את הדפדפן שלכם.

42
00:02:41,252 --> 00:02:44,471
אבל בתקווה שלא. אז באמת, אנחנו רק רוצים לעשות

43
00:02:44,471 --> 00:02:48,371
את זה עד שנגיע לתחתית הדף נכון? מה שאומר שאנחנו רוצים לעשות את זה

44
00:02:48,371 --> 00:02:52,469
כל עוד y קטן מ-400. אז פשוט נשים את זה פה, ופה

45
00:02:52,469 --> 00:02:56,426
ויש לנו את זה! ההודעה נרשמת לכל אורך המסך.

46
00:02:56,426 --> 00:02:59,920
ואתם רואים שזה הרבה יותר פשוט מהגישה הקודמת שלנו,

47
00:02:59,920 --> 00:03:04,175
שאומנם לקח לנו אותה זמן לממש אותה, אבל היינו רק ברבע הדרך לסיים.

48
00:03:04,175 --> 00:03:08,090
אז נוכל להיפטר מזה, והנה התוכנית שלנו.

49
00:03:08,090 --> 00:03:11,711
עכשיו, בוא ננסה להבין יותר לעומק מה עשינו. בשביל לעשות את זה,

50
00:03:11,711 --> 00:03:15,634
אני הולכת להדפיס את y בכל פעם. אני הולכת להגיד ״y הוא עכשיו:״ ואז כאן למטה

51
00:03:15,634 --> 00:03:19,410
אני פשוט אצמיד את y לסוף ההודעה כך שנוכל לראות אותו.

52
00:03:19,410 --> 00:03:23,343
אז כרגע, הערך משתנה ב-20, ואנחנו יכולים לשנות את זה

53
00:03:23,343 --> 00:03:27,257
על ידי שינוי פשוט של המשתנה הזה כאן. או שאפשר לעשות את זה נגיד

54
00:03:27,257 --> 00:03:31,426
50. ועכשיו הרווחים משתנים ב-50. בצורה דומה,

55
00:03:31,426 --> 00:03:35,578
תוכלו לשנות ולשחק עם שאר הערכים האלו ולשנות אותם.

56
00:03:35,578 --> 00:03:39,201
תוכלו לראות כיצד זה משפיע על עצירת התוכנה.

57
00:03:39,201 --> 00:03:44,007
על מנת להבין את זה תוכלו לחשוב על זה כמו

58
00:03:44,007 --> 00:03:47,342
הצהרת if. יש לנו את הביטוי הבוליאני שלנו כאן,

59
00:03:47,342 --> 00:03:52,009
בדיוק כפי שלמדתם. ואז, יש לנו את גוף ההצהרה שאותו נבצע,

60
00:03:52,009 --> 00:03:55,469
החלק הזה, רק אם הבוליאני נכון (אמת). אחרת, נקפוץ ישר לסוף

61
00:03:55,469 --> 00:03:59,093
אבל מה שמעניין הוא שעם לולאת while יש לנו למעשה

62
00:03:59,093 --> 00:04:03,864
את הדבר הסודי הזה שנמצא למטה ואומר ״תחזור בחזרה להתחלה של הלולאה״.

63
00:04:03,864 --> 00:04:07,202
ומה שאומרת ההוראה הסודית הזו היא שבמקום

64
00:04:07,202 --> 00:04:11,071
לעזוב ולהמשיך פשוט קדימה כמו עם הצהרת if,

65
00:04:11,071 --> 00:04:15,032
בכל פעם שאנחנו עושים את הלולאה, אנחנו הולכים לחזור אחורה

66
00:04:15,032 --> 00:04:19,204
ולבדוק אם התנאי עדיין נכון. ואם הוא עדיין נכון, אנחנו הולכים לחזור על הפעולה שוב.

67
00:04:19,204 --> 00:04:23,238
ובדיוק כמו שאתם מנחשים, בפעם השנייה, אנחנו הולכים לעשות את אותו הדבר...

68
00:04:23,238 --> 00:04:27,086
אנחנו הולכים לבדוק ולחזור להתחלה. האם y עדיין קטן מ-279?

69
00:04:27,086 --> 00:04:31,565
אם כן, אז נחזור פעם נוספת ונבדוק שוב.

70
00:04:31,565 --> 00:04:34,591
ואם לא, נחזור להתחלה כאן, ולבסוף

71
00:04:34,591 --> 00:04:38,478
נצא מהלולאה ונמשיך עם התוכנית שלנו.

72
00:04:38,478 --> 00:04:42,703
יש עוד הרבה דרכים מעניינות להשתמש בלולאות עליהן נלמד בקרוב,

73
00:04:42,703 --> 00:04:46,703
אבל לעת עתה, זו אחלה התחלה. בהצלחה!