>> דאג LLOYD: בסדר, כל כך בואו נדבר על לולאות.
אז לולאות הן סוג של מגניבים משום שהם מאפשרים התכנית שלך
לבצע שורות קוד שוב ושוב ושוב.
שוב ושוב, מבלי להעתיק ולהדביק או אחר לחזור עליהם.
ישנם שלוש גדולים סוגים של לולאות תראו.
בטח יש לך הזדמנות להשתמש כל אחד כפי שאתה התקדמות דרך CS50.
חלק מהלולאות הללו הם די מוכר לך מהתחלה,
אז שוב, כפי שעשינו עם תנאי, אנחנו הכנסנו אותם זה לצד זה
אם יש אנלוגיה אנחנו יכולים לצייר.
>> הראשון הוא לנצח מהתחלה, אשר משווה לזמן (אמיתי).
זה מה שאנחנו קוראים ללולאה אינסופית.
שורות קוד בין מתולתל פלטה, כמו חלקי פאזל
נכון שבתוך C של לחסום לנצח,
יבצע שוב ושוב מלמעלה למטה, שוב ושוב ושוב,
לנצח.
אחרי הכל, אם אתה זוכר שלנו דיון בביטויים בוליאנית,
אמיתי הוא תמיד נכון.
אז אם אנחנו עושים משהו כל כך ארוך כמו אמיתי
הוא true-- זה נראה קצת silly-- אמיתי תמיד נכון, כך שזה תמיד ירוץ.
זה ירוץ לנצח ו לנצח נצחים עד ש
למצוא דרך לפרוץ אותו עם הצהרת הפסקה, ששוב,
ראינו לפני קצת בזמן שאנחנו דיברו על מתג.
>> או בדרך אחרת פשוט להורגנו תכנית, שדרך אגב,
אם אי פעם אתה מוצא את עצמך ב מצב עם לולאה אינסופית
ואתה לא יודע איך להפסיק התכנית שלך מלפעול.
רק פגע שליטה ו- C ו שיהרוג את התכנית שלך בשבילך.
אבל זה, שוב, הוא נקרא לולאה אינסופית.
זה לולאה שתפעל לנצח.
עכשיו, בזמן שלולאות אינן תמיד אינסופי, כי גם
אנחנו יכולים להחליף את וליאנית ביטוי עם משהו
קצת יותר שימושי מאשר רק אמיתי.
אז הנה דוגמא נוספת.
בעוד וכמה בוליאנית ביטוי ופלטה אז מתולתלת.
זה פחות או יותר דומה לחזור עד, מהתחלה.
למרות בשני, אני להסביר את ההבדל.
>> אז ב- C, אם ביטוי בוליאני בתוך בעוד הלולאה
מעריך לנכון, הקווים קוד בין הסוגריים המסולסלים
יבצע שוב ושוב שוב ושוב ושוב, עד ביטוי בוליאני
מעריך שווא.
אז לדוגמא, ייתכן ש יש סוג מסוים של דלפק.
אז אומר לך בתחילת לולאה זה אומרת int x שווה לאפס.
בעוד x הוא פחות מ -100, לעשות כמה דברים שבתוך סוגריים מסולסלים,
אז בסופו של הלולאה שלך, שאתה אומר x בתוספת בתוספת, אתה הגדלה x.
בסופו של x יקבל 100 ואתה יהיה
להפסיק כי המצב x הוא פחות מ -100
כבר לא יהיה נכון ברגע שx שווה ל -100.
100 הוא לא פחות מ -100.
>> עכשיו מבלבל במקצת, ההתנהגות בלוק השריטה הוא הפוך.
אז להיות זהיר מאוד אם זה ההסתערות הראשונה שלך לשימוש בלולאות.
בעיקרון, חוזר עד הבלוק בScratch
יחזור על משהו שוב ושוב ושוב,
עד הביטוי, בוליאנית ביטוי במשושה הוא אמיתי.
אז זה ימשיך לעשות זה עד שזה נכון.
בינתיים, תהיה תוך הלולאה תמשיך לעשות את זה עד שהוא כוזב.
אז הם די דומים, אבל יש שהבחנה קטנה רק
להיות זהיר של במיוחד כמו שאתה עושה ההסתערות הראשונה שלך ממעבר
לגרד לג.
הסוג של הלולאה הבא הוא בעצם די דומה.
זה נקרא לעשות בזמן לולאה.
לולאה זו תבצע את כל הקווים קוד בין הסוגריים המסולסלים פעם,
ואז זה יהיה לבדוק ביטוי בוליאני.
אם ביטוי בוליאני מעריך לנכון,
זה יחזור וחזור תהליך זה שוב ושוב
ושוב, עד בוליאנית ביטוי מעריך שווא.
אז לולאה זו, בניגוד ללולאה בזמן, היא מובטח לרוץ לפחות פעם אחת.
זה יכול להיות די שימושי.
>> לבסוף, יש לנו ללולאה.
ללולאות הם סוג של מבחינה תחבירית לא אטרקטיבי
ויש הרבה הולכים כאן, כך לשאת איתי
כפי שאנו מנסים ולשבור חתיכות אלה בנפרד.
בדרך כלל, במקרה השימוש של ללולאה הוא
רוצה לחזור על משהו מספר מסוים של פעמים.
בדוגמא זו כאן, יש לי הבלוק חוזר
מהתחלה, שהוא מקביל ללולאה
ב- C, חוזר משהו 10 פעמים.
וללולאה ב השמאל שם, ש
היא ארבע לולאה ש היה עושה את אותו הדבר.
זה הייתי הולך 10 פעמים.
ספירה מאפס, אנחנו להגדיל לעבור כל הלולאה.
ואנחנו ממשיכים לעשות את זה עד הוא אני פחות מ -10.
>> אז מה קורה?
יש המון קוד שם.
בואו לשבור אותו ל מה שקורה צעד
צעד כפי שאנו לחפור ללולאה.
הדבר הראשון שקרה הוא משתנה הדלפק הוא מרכז.
הכל מהשמאל לכי ראשון פסיק בתוך הסוגריים
הוא הוצא להורג.
במקרה זה, אנחנו אומר int i שווה 0.
הכרזה משתנה חדש בשם i, שמשתנים הוא מספר שלם סוג
ואנחנו אומרים את הערך בתוך משתנה כי הוא הולך להיות אפס.
>> הדבר השני שאנחנו עושים הוא לאחר מכן, אנו מעריכים באופן מיידי
ביטוי בוליאני.
ביטוי בוליאני הוא ב אמצע של שתי נקודה-פסיק.
אני הוא פחות מ -10.
זה נכון כאן, נכון?
אנחנו פשוט אמרתי הוא שאני שווה אפס, וכך הוא 0 פחות מ -10,
וכדי שהמצב נכון ועכשיו אנחנו יהיו
להמשיך לבצע את הגוף של הלולאה.
אם זה היה שקר.
אם, למשל, אמרתי במקום אני שווה 0 שם אמרתי שאני שווה 15,
int i שווה 15.
ובכן 15 הוא לא פחות מ -10, כדי ש אף פעם לא היה נכנסים לגוף של הלולאה
כי ביטוי בוליאני שם היה להעריך שהוא שקרי.
>> לאחר שאנחנו עוברים מלמעלה למטה, אנו נתקלים כי סגירת סד מתולתל,
דבר שלישי שקורה.
משתנה הדלפק הוא מוגדל, או לייתר דיוק, את הקווים
קוד של הצהרה לאחר פסיק שני בתוך
לסוגר לולאות מבוצעת.
אז אנחנו מתחילים על ידי אומר int i שווה 0.
אז לבדוק אם או לא ביטוי בוליאני הוא אמיתי.
0 הוא פחות מ, 10 כך שזה נכון.
אז אנחנו הולכים להמשיך לגוף הלולאה.
דברים יקרה בתוך הלולאה, ו כאשר אנו נתקלים שבמתולתלים סגירה
הסד, הדבר הבא שאנחנו אנחנו זה להגיד שתוספת, בתוספת.
הייתי אפס כרגע הוא שאני אחד.
לאחר מכן, אנחנו שוב לבדוק את הערך של ביטוי בוליאני באמצע.
אחת מהן הוא פחות מ -10.
אז אנחנו נעבור את זה לעבד שוב ושוב.
אנחנו נגיע לסגירה סד מתולתל שוב.
אנחנו להגדיל אני מ 1 עד 2 ו2-3.
וכן הלאה וכן הלאה וכן הלאה, עד ש סופו של דבר הערך של i הופך 10.
האם 10 פחות מ -10?
מס '
ספירה מ 0, אנחנו כבר נעלמו עד 10 חזרות של לולאה.
אנחנו כבר חזרתי 10 פעמים, פשוט כפי שעשינו בגוש Scratch.
ואז זה בעצם תהליך לארבע לולאה.
>> עכשיו לוקח מן קוד בפועל ולשים אותו
רק כמה הצהרות כלליות בסיסיות.
הנה מה שקורה.
כל הדוחות ב להתחיל מבוצעים ראשון.
אולי יש לך יותר מפעם אחת.
לאחר מכן, ביטוי בוליאני מסומן.
אם הביטוי מעריך לנכון, לבצע את גוף לולאת פעם אחת.
אם הביטוי מעריך לכוזב, שנסיים.
אנחנו לא לבצע גוף של הלולאה בכל.
אחרי שהוצאנו להורג גוף הלולאה פעם אחת,
אז אנחנו עושים את מה שהוא ב חלק תוספת שם.
שהיא בדרך כלל הולכת להיות משהו כמו שתוספת, בתוספת
או משהו כזה, ש משנה משתנה דלפק.
ואז, אחרי שתוספת, ש לבדוק את הביטוי שוב
וחזור על שלבים אלה שוב ושוב ושוב, עד הביטוי הוא
כבר לא נכון.
>> אז מה הם המקרים השימוש ללולאה?
השתמשו להשתמש בלולאה בזמן, כאשר אתה רוצה לולאה לחזור
מספר לא ידוע של פעמים, אבל זה אולי לא יכול להפעיל את כל.
דוגמא נפוצה מאוד של בשימוש בעת לולאה
הוא להפעיל את בקרת הזרימה למשחק.
אתה אולי לא יודע כמה זמן משתמש הולך להיות משחק,
אבל אתה רוצה לשמור עושה את אותו הדבר.
עדכון העמדות שדונים שונים על הלוח.
אתה רוצה לשמור על דברים נע בכל העת,
אבל אתה לא יודע מתי משתמש הוא הולך להפסיק לשחק
או כאשר הם הולכים נגמרים של חיי.
אז לולאה בזמן שהוא באמת טוב למשהו כזה.
זה מקרה שימוש טוב.
>> למטלות תוך לולאה, זה די דומה.
אתה רוצה לולאה לחזור ידועה מספר פעמים, אבל לפחות פעם אחת.
אתה יכול להשתמש בזה למשחק מדי, אבל במקרה שימוש נפוץ מאוד
הוא להציג הודעה למשתמש עבור קלט.
באופן כללי, אפשר לומר משהו כמו, לתת לי מספר חיובי,
ואתה עלול לשים את זה בתוך לולאה לעשות בזמן.
אז זה תמיד יהיה לשאול אותם ב לפחות פעם אחת למספר חיובי.
אם הם נותנים לך מספר חיובי, אתה עלול לשבור את הלולאה.
ייתכן שאתה עשית.
ביטוי בוליאני ב לעשות בזמן עשוי להיות שגוי.
>> ואתה לא שואל אותם שוב.
אם הם נותנים לך מספר שלילי שבי הם הקלידו מילה או משהו ש
לא ממש שימושי ל לך, אתה יכול להשתמש
אל תוך הלולאה לחזור ולעשות זה שוב ושוב ושוב.
אתה בהחלט רוצה לשאול שלהם לתת לך מספר אחת,
אבל אתה לא יודע כמה פעמים לאחר שהם עלולים להיות מזיקים.
וכך לעשות בזמן זה שימוש גדול מקרה ללהציג הודעה למשתמש עבור קלט.
וללולאות להשתמש מקרה בדרך כלל הוא כאשר
אתה רוצה לחזור על לולאה מספר בדיד פעמים,
לא אם כי ייתכן יודע את מספר הפעמים
רגע התכנית עוברת הידור.
>> כך למשל, אולי יש לך תכנית שבו אתה תנחה את המשתמש למספר.
והם נכנסים 100.
ולאחר מכן שלך ללולאה במקרה שמפעיל 100 פעמים.
או שאולי הם נכנסים 1,000 בתכנית שלך
ולאחר מכן להפעיל את הלולאה 1,000 פעמים.
זה מספר מסוים של פעמים.
הם לא בהכרח יודע מה מספר ש
הוא תכנית רגע הידור.
זה לא כמו לולאה בזמן איפה זה יכול להיות אינסופי.
זה די מספר שאתה פשוט לא יודע.
עכשיו למרות שיש לי כל המקרים שימוש אלה תוארו,
עליך לדעת כי ביפה הרבה בכל מצב,
אתה יכול מחלף כל שלוש הלולאות הללו.
אתה יכול להשתמש ללולאה שבו אתה אחרת היה להשתמש בלולאה בזמן.
אתה יכול להשתמש בלולאה לכל מקום היית להשתמש לעשות בזמן לולאה וכן הלאה.
זה יכול להיות קצת מסובך לפעמים, כך בדרך כלל זה תרגול טוב
לדבוק במקרה שימוש טיפוסי.
השתמש לעשות בזמן הלולאה אם ​​אתה רצה משהו פעם אחת, לפחות.
השתמש ללולאה אם ​​אתה רוצה לעשות משהו מספר מסוים של פעמים.
אחרי הכל, זו הסיבה שיש שלושה סוגים שונים של לולאות.
>> אז הם יכולים לשמש בהקשר הנכון.
אבל אתה יכול מחלף שלהם אם אתה רוצה.
אם אתה מרגיש נוח עם לולאות בזמן ואתה תמיד רוצה להשתמש בזמן לולאות.
זה משהו ש אתה יכול לעשות, למרות ש
יכול להיות קצת מבחינה תחבירית שבו ללולאה מסובכת,
יהיה הרבה יותר פשוט.
>> שמי דאג לויד וזה CS50.