WEBVTT

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

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

00:00:10.335 --> 00:00:11.926
כל ההודעות משתנות.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

00:01:30.825 --> 00:01:33.370
והנה הן:

00:01:33.370 --> 00:01:37.371
השאלה הראשונה היא: ״על מה אני רוצה לחזור?״

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

00:03:31.426 --> 00:03:35.578
תוכלו לשנות ולשחק עם שאר הערכים האלו ולשנות אותם.

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

00:03:39.201 --> 00:03:44.007
על מנת להבין את זה תוכלו לחשוב על זה כמו

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

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

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

00:03:55.469 --> 00:03:59.093
אבל מה שמעניין הוא שעם לולאת while יש לנו למעשה

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

00:04:03.864 --> 00:04:07.202
ומה שאומרת ההוראה הסודית הזו היא שבמקום

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

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

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

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

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

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

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

00:04:34.591 --> 00:04:38.478
נצא מהלולאה ונמשיך עם התוכנית שלנו.

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

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