0:00:00.700,0:00:07.260
בואו נדבר על לולאות. יש לי פה לולאת while (או בעברית: לולאת ״כל עוד״), ועם כמה שורות קוד, אני יכולה לכתוב את ההודעה הזו לאורך כל המסך.

0:00:07.260,0:00:10.335
אם אני אשנה את ההודעה ככה, בשביל לעשות אותה טובה יותר

0:00:10.335,0:00:11.926
כל ההודעות משתנות.

0:00:11.926,0:00:15.833
אז איך זה עובד? ובכן, נוכל להסתכל על הקוד הזה עוד רגע

0:00:15.833,0:00:19.422
אבל קודם כל בואו ניקח צעד אחורה ונחשוב על איך היינו כותבים את התוכנית הזו

0:00:19.422,0:00:22.471
בעזרת מה שאנחנו יודעים כרגע מבלי להשתמש בלולאות.

0:00:22.471,0:00:26.751
בשביל לעשות את זה, היינו צריכים לכתוב המון פעמים את הטקסט הזה שוב ושוב ושוב נכון?

0:00:26.751,0:00:32.590
היינו משתמשים בפונקציית text, כותבים הודעה, שמים את זה למעלה, ועכשיו פשוט חוזרים על זה

0:00:32.590,0:00:36.336
מספיק פעמים כך שבסוף היינו מקבלים טקסט מלמעלה עד למטה.

0:00:36.336,0:00:38.949
וזה ייקח המון עבודה נכון?

0:00:38.949,0:00:42.753
מכיוון שהלמטה די רחוק, וזה אפילו גרוע יותר אם

0:00:42.753,0:00:46.758
שזה לא 70, זה צריך להיות קרוב יותר, נגיד,

0:00:46.758,0:00:50.709
60. ועכשיו זה משפיע על זה מכיוון שזה צריך להיות קטן יותר

0:00:50.709,0:00:55.036
וכל אלו בהמשך, עוד קריאות שאנחנו צריכים לבצע.

0:00:55.036,0:00:58.261
למעשה, בדרך הזו ייקח אפילו יותר זמן להגיע למטה.

0:00:58.261,0:01:02.176
אז, זה די מעצבן, ולמזלנו יש לנו לולאות שיעזרו לנו

0:01:02.176,0:01:06.210
מעתה והלאה, בכל זמן שאתם רואים קוד שחוזר על עצמו כך, המחשבה הראשונה שלכם תהיה

0:01:06.210,0:01:10.087
״האם אני יכול להשתמש פה בלולאה?״ לולאה תאפשר לנו לחזור על הקוד שכתבנו שוב ושוב

0:01:10.087,0:01:14.251
ושוב, תוך כדי שאנחנו עושים רק שינויים קטנים בכל פעם, וכך אנו

0:01:14.251,0:01:17.868
היינו משכתבים את הקוד הזה עם לולאה. על מנת להתחיל, אנחנו צריכים להקליד ״while״,

0:01:17.868,0:01:22.089
סוגריים, ואז סוגרים מסולסלים. אנחנו הולכים לקבל את ההודעה הזו אבל

0:01:22.089,0:01:26.301
זה רק בגלל שלא סיימנו עדיין. אל תדאגו, היא תעלם כשנסיים.

0:01:26.301,0:01:30.810
בכל פעם שאתם יוצרים לולאה אתם צריכים לענות על שלוש שאלות מפתח.

0:01:30.825,0:01:33.370
והנה הן:

0:01:33.370,0:01:37.371
השאלה הראשונה היא: ״על מה אני רוצה לחזור?״

0:01:37.371,0:01:41.466
מה שאנחנו רוצים לחזור עליו צריך להיות בין הסוגריים המסולסלים.

0:01:41.466,0:01:46.198
אנחנו רוצים לחזור על הקריאה לפונקציית text בשלב זה, אז נשים את זה פה.

0:01:46.198,0:01:49.571
אבל זה מדי מטופש לא? מכיוון שכרגע אנחנו הולכים לחזור על

0:01:49.571,0:01:53.477
קריאה לאותה פונקציית text שוב ושוב, שזה לא ממש טוב, כי אנחנו צריכים שמשהו יישתנה

0:01:53.477,0:01:57.710
מה שמביא אותנו לשאלה השנייה, שהיא ״מה היינו רוצים שיישתנה בכל פעם?״

0:01:57.710,0:02:01.423
אז היינו רוצים לשנות את מיקום ה-״y״ נכון? היינו רוצים שהוא יהפוך ל-60 ואז היינו

0:02:01.423,0:02:05.503
רוצים שהוא יהפוך ל-80. אז בואו נכניס את זה למשתנה במקום

0:02:05.503,0:02:09.476
שנקרא y, מכיוון שזהו מיקום ה-y. אז בואו נגדיר משתנה חדש

0:02:09.476,0:02:13.376
כאן למעלה. אני אאתחל אותו עם הערך 40. ועכשיו, אנחנו רק צריכים

0:02:13.376,0:02:17.205
לשנות את y. אנחנו יכולים לעשות את זה כאן למטה, נוכל להגיד ש-y מקבל את y + 20

0:02:17.205,0:02:21.088
ואז הוא ייגדל בכל פעם. ולמעשה, אנחנו יכולים להשתמש

0:02:21.088,0:02:24.745
במה שלמדנו בשיעור קיצור קוד כאן. אנחנו יכול להשתמש

0:02:24.745,0:02:29.092
בקיצור. מעולה, ואנחנו רק

0:02:29.092,0:02:32.705
צריכים לענות על שאלה מספר שלוש עכשיו, שהיא ״לכמה זמן היינו רוצים לחזור על הפעולה הזו?״

0:02:32.705,0:02:36.531
אנחנו הרי רוצים לעשות זאת שוב ושוב ושוב, אבל אנחנו לא באמת רוצים לעשות את זה לנצח נכון?

0:02:36.531,0:02:41.252
אם נעשה את זה לנצח, קודם כל, זה הרבה זמן, דבר שני, יש סיכוי שזה יקריס את הדפדפן שלכם.

0:02:41.252,0:02:44.471
אבל בתקווה שלא. אז באמת, אנחנו רק רוצים לעשות

0:02:44.471,0:02:48.371
את זה עד שנגיע לתחתית הדף נכון? מה שאומר שאנחנו רוצים לעשות את זה

0:02:48.371,0:02:52.469
כל עוד y קטן מ-400. אז פשוט נשים את זה פה, ופה

0:02:52.469,0:02:56.426
ויש לנו את זה! ההודעה נרשמת לכל אורך המסך.

0:02:56.426,0:02:59.920
ואתם רואים שזה הרבה יותר פשוט מהגישה הקודמת שלנו,

0:02:59.920,0:03:04.175
שאומנם לקח לנו אותה זמן לממש אותה, אבל היינו רק ברבע הדרך לסיים.

0:03:04.175,0:03:08.090
אז נוכל להיפטר מזה, והנה התוכנית שלנו.

0:03:08.090,0:03:11.711
עכשיו, בוא ננסה להבין יותר לעומק מה עשינו. בשביל לעשות את זה,

0:03:11.711,0:03:15.634
אני הולכת להדפיס את y בכל פעם. אני הולכת להגיד ״y הוא עכשיו:״ ואז כאן למטה

0:03:15.634,0:03:19.410
אני פשוט אצמיד את y לסוף ההודעה כך שנוכל לראות אותו.

0:03:19.410,0:03:23.343
אז כרגע, הערך משתנה ב-20, ואנחנו יכולים לשנות את זה

0:03:23.343,0:03:27.257
על ידי שינוי פשוט של המשתנה הזה כאן. או שאפשר לעשות את זה נגיד

0:03:27.257,0:03:31.426
50. ועכשיו הרווחים משתנים ב-50. בצורה דומה,

0:03:31.426,0:03:35.578
תוכלו לשנות ולשחק עם שאר הערכים האלו ולשנות אותם.

0:03:35.578,0:03:39.201
תוכלו לראות כיצד זה משפיע על עצירת התוכנה.

0:03:39.201,0:03:44.007
על מנת להבין את זה תוכלו לחשוב על זה כמו

0:03:44.007,0:03:47.342
הצהרת if. יש לנו את הביטוי הבוליאני שלנו כאן,

0:03:47.342,0:03:52.009
בדיוק כפי שלמדתם. ואז, יש לנו את גוף ההצהרה שאותו נבצע,

0:03:52.009,0:03:55.469
החלק הזה, רק אם הבוליאני נכון (אמת). אחרת, נקפוץ ישר לסוף

0:03:55.469,0:03:59.093
אבל מה שמעניין הוא שעם לולאת while יש לנו למעשה

0:03:59.093,0:04:03.864
את הדבר הסודי הזה שנמצא למטה ואומר ״תחזור בחזרה להתחלה של הלולאה״.

0:04:03.864,0:04:07.202
ומה שאומרת ההוראה הסודית הזו היא שבמקום

0:04:07.202,0:04:11.071
לעזוב ולהמשיך פשוט קדימה כמו עם הצהרת if,

0:04:11.071,0:04:15.032
בכל פעם שאנחנו עושים את הלולאה, אנחנו הולכים לחזור אחורה

0:04:15.032,0:04:19.204
ולבדוק אם התנאי עדיין נכון. ואם הוא עדיין נכון, אנחנו הולכים לחזור על הפעולה שוב.

0:04:19.204,0:04:23.238
ובדיוק כמו שאתם מנחשים, בפעם השנייה, אנחנו הולכים לעשות את אותו הדבר...

0:04:23.238,0:04:27.086
אנחנו הולכים לבדוק ולחזור להתחלה. האם y עדיין קטן מ-279?

0:04:27.086,0:04:31.565
אם כן, אז נחזור פעם נוספת ונבדוק שוב.

0:04:31.565,0:04:34.591
ואם לא, נחזור להתחלה כאן, ולבסוף

0:04:34.591,0:04:38.478
נצא מהלולאה ונמשיך עם התוכנית שלנו.

0:04:38.478,0:04:42.703
יש עוד הרבה דרכים מעניינות להשתמש בלולאות עליהן נלמד בקרוב,

0:04:42.703,0:04:46.703
אבל לעת עתה, זו אחלה התחלה. בהצלחה!