לולאות - for - while
for (int i = 0; i < 5; i++) מגדיר משתנה מונה שמאותחל ל-0. התנאי נבדק לפני כל איטרציה, ובסוף כל איטרציה i מקודם באמצעות i++.while בודקת תנאי בוליאני לפני כל כניסה, ואם התנאי שגוי מההתחלה, היא לא רצה בכלל. לולאת do מבצעת את הקוד לפחות פעם אחת, כי התנאי נבדק רק בסוף.פרקי ההרצאה: לולאות - for - while
תמלול ההרצאה: לולאות - for - while
הטקסט המלא של הדקות הראשונות בהרצאה «לולאות - for - while» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
לולאות יש לנו שלושה סוגים יש לנו שלושה סוגים כאן יש לנו סוג אחד ועוד שני סוגים שהם מאוד מאוד דומים שתמיד מלמדים אבל לי אישית 20 שנה פיתחתי קוד לא יצא לי להשתמש בשלישי אבל צריך ללמוד אז הדוגמה הראשונה או יותר נכון סוג לולאה הראשון נקרא לולאה תפור אז תפור שימו לב מילה שמורה כמו if אני כותב את זה בתוך סוגריים ואני משתמש בזה כאשר אני יודע כמה פעמים אני הולך לרוץ בתוך
הלולאה גם אם זה יהיה דינמי עדיין אני יודע מראש מתי אני אצטרך להפסיק אז אם אני רוצה להריץ משהו חמש פעמים אז בדיוק דיברנו על נושא של הכרת משתנים איפה שהם מוגדרים אז אני יכול להגדיר משתנה שהוא רק ללולאה והרבה פעמים הוא ייקרא פשוט I גם מוסכמה כזאת I יש יש כאלה שיגידו זה קיצור של אינדקס,
יש כאלה שיגידו שזה איטרטור, משהו שאחראי על חזרות של דברים. אז הגדרתי for int i שווה 0, נקודה פסיק, i קטן מ-5, i פלוס פלוס וכרגיל סוגריים מסולסלות.
גם פה אני יכול בלי סוגריים לעשות פקודה אחת, אבל אני תמיד משתמש בסוגריים מסולסלות. מה שקורה פה זה ככה, בהתחלה הוא יוצר את I ומגדיר אותו ומאתחל אותו כאפס.
אחר כך הוא בודק ואת הקטע קוד שרץ, את הקטע קוד שמוגדר פה בתוך לולה התפור, הוא מריץ כל עוד זה true, כל עוד הביטוי הזה מחזיר true. ובסופו של התהליך, בסופה של כל איתרציה, כל פעם שלולה הרץ הזה נקרא איתרציה, הוא עושה את הפקודה שיש פה שזה I++. זה הסינטקס הנפוץ ביותר
ללולאה עד 4. למה אנחנו מתחילים מ-0? קודם כל גם עניין של מוסכמה אבל בעיקר כשנגיע לדבר על מערכים אנחנו נבין את זה יותר אבל רק לצורך ההסבר מערכים זה בעצם אם אני מגדיר מערך של אינטג'רים זה למעשה כמה משתנים עם אותו שם ויש להם אינדקס שונה.
יכול להגדיר מערך של חמישה מספרים, חמישה אינטג'רים. אני יכול גם להגדיר מערך של חמישה אויבים לצורך העניין במשחק. אז מערך זה מבנה נתונים מאוד בסיסי שנגיע לדבר עליו, ואם ניחשתם או לא ניחשתם, האינדקס מתחיל מאפס.
כלומר, האינדקס של המשתנים במערך מתחיל מאפס. יש לי את, נניח שאני אגדיר dummy int, טוב, אני אגדיר את זה מחדש פה, int הרי, כן, פה למעשה יצרתי מערך, ושוב, אני גולש פה מעבר למה שהתכוונתי, אבל יצרתי פה מערך של חמישה אינטג'ר.
כאשר אני רוצה להתייחס למספר הראשון במערך הזה, אני צריך לרשום אם תראה 0 שווה 5 אוקיי אז האינדקס של התא הראשון הוא 0 ויהיה לנו אם יש לנו 5 אז יהיה לנו מ-0 עד 4 ולכן גם הרבה פעמים לופים יתחילו מ-0 אם אני הרבה פעמים לופים ירוצו על מערך ויעשו עדכון לכל האובייקטים במערך בין אם זה אינטג'ר בין אם זה משהו אחר לכן הרבה פעמים הלופים יתחילו מאפס
עד שהם יהיו קטנים מאורך ה... כל עוד הם קטנים מגודל המערך כי אם אני מנסה לגשת ל-int array 5 הוא לא קיים ואני אקבל הודעת שגיאה ואז אני יכול פה לעשות פרינט ו-i שהוגדר בתוך הלופ זמין לי פה וכמובן אם אני אעשה פה פרינט i מחוץ ללופ הוא יגיד לי לא מכיר את i.
אז אני רק פשוט אנפיס פה print done ואני עכשיו רוצה את כל הפרינטים הקודמים שלי להעיף אני יכול פשוט את זה למחוק ועכשיו אני אריץ למה יש לי עדיין true אוקיי יש לי פה את פרינטים האלה אני מוחק ורגע אוקיי אז יש לי פה כמו שאתם רואים 0 1 2 3 4 done הוא רץ 5 פעמים כאשר i שווה באיטרציה הראשונה הוא שווה 0 באיתרציה האחרונה הוא שווה 4, כל איתרציה הוא מדפיס,
הוא מבצע את הקוד שכתוב פה והוא מקדם את i באמצעות i++. זוהי לולאת 4, כאשר כמובן במקום ה-5 יכול להופיע לי פה גם משהו כמו משתנה, שאם אני לא יודע מראש, אמרתי אני יודע מראש, אני יודע כשאני נכנס ללולאה כמה פעמים אני אריץ אותה, יכול להיות עדיין דינמי ומשתנה פעם לפעם אבל נניח שיש לי מערך של רשימה של
אויבים ואני רוצה לעשות משהו לכל האויבים אז אני ארוץ בלולאה על כל האויבים לפי האינדקס שלהם וגם אם מספר האויבים משתנה עדיין כשאני מגיע ללולאה אני יודע כמה פעמים אני אצטרך כמה איתרציות יהיו לי.
סוג הלולאה הנוסף שקיים הוא לולאת while והוא פשוט while בתוך הסוגריים יהיה לי ביטוי בוליאני while עכשיו אני אשתמש פה גם באריתמטיקה כי אין לי כרגע דוגמא לתת אז פשוט ארשום dummy int 2 שהוא 3 while הוא גדול מ-0 ואני אעשה פה dummy int 2 קודם כל נדפיס אותו print dummy int 2 ו-dummy int 2 מינוס מינוס אוקיי מה
מה שיקרה זה כל עוד דמי אינט 2 הוא גדול מאפס הוא ייכנס ללולאה ומה שהוא עושה פה וזה ההבדל שוב הייתי משתמש פה בגדול בלולאת 4 כן הייתי משתמש פה בפור אינט i שווה דמי אינט ובסוף הלולאה הייתי רושם i מינוס מינוס גם אופציה אבל כי אין לי דוגמה לתת לווייל ותכף גם אני אסביר למה אז אני עושה פה את ההחזרה הזאת.
עכשיו אני אשמור ואני אריץ, עדיין יש לי את ההדפסות מקודם של 0, 1, 2, 3, 4, ועכשיו 3, 2, 1, done. זה כבר שייך ללולאה השנייה. טוב, לצורך ההבדלה אני ארשום פה after first loop, אוקיי?
אוקיי, זה after first loop, ואחרי זה אני מדפיס 3, 2, 1, ו-done, אוקיי? אז זאת הלולאת while, הלולאה השלישית כמעט לגמרי כמו לולאת while, הבדל קטן מאוד לולאת do וכאן אני כותב פה את קטע הקוד print in do לופ ופה אני כותב while וכאן יהיה לי ביטוי בוליאני עכשיו נשתמש בטוב נתחיל את dummy