0:00:01.273,0:00:04.238
חזרנו, עם תוכנה שמדפיסה את מערך החברים שלי.

0:00:04.238,0:00:07.007
אבל יש משהו שממש מעצבן אותי לגביה.

0:00:07.007,0:00:11.295
בכל פעם שאני מוסיפה חבר חדש למערך, אני צריכה להוסיף פקודת text כאן למטה.

0:00:11.295,0:00:13.378
בואו נאמר שאני מוסיפה את ווינסטון.

0:00:13.378,0:00:15.211
ובכן, הוא לא מופיע אוטומטית.

0:00:15.211,0:00:20.775
אם אני רוצה שהוא יופיע, אני צריכה לכתוב text(myFriends[3], ואז לשנות את המיקום בציר ה-y, ואז אנו רואים את ווינסטון.

0:00:23.630,0:00:25.414
זה הרבה יותר מדי עבודה!

0:00:25.522,0:00:30.767
אני רק רוצה שבכל פעם שאני מוסיפה מישהו למערך, שורת הקוד תתבצע אוטומטית.

0:00:31.937,0:00:34.736
ובכן, אתם זוכרים שכלמדנו לולאות?

0:00:34.736,0:00:38.378
לולאות היו דרך מעולה לחזור על אותו קטע קוד פעמים רבות ברצף.

0:00:38.378,0:00:43.273
למשל, אם רצינו לקבל אוסף עצים או בלונים ברצף.

0:00:43.273,0:00:49.628
ובכן, מסתבר שלולאות הן גם דרך מעולה להריץ קטע קוד מסוים על כל איבר במערך.

0:00:49.628,0:00:57.378
למעשה, אתם תשתמשו בלולאה כמעט בכל פעם שתשתמשו במערך. הם עובדים מצוין יחד.

0:00:57.378,0:01:03.736
בואו נשתמש בלולאה כדי להציג את השמות של החברים שלי, במקום כל השורות האלו עם פקודות text, כדי שתראו למה אני מתכוונת.

0:01:03.736,0:01:07.795
נתחיל עם שלוש שאלות שאנחנו תמיד שואלים את עצמנו כשאנחנו כותבים לולאה.

0:01:07.795,0:01:13.438
ראשית, על מה אני רוצה לחזור? ובכן, הסתכלו על הקוד כאן למעלה. מה חוזר על עצמו? פקודת ה-text.

0:01:13.438,0:01:26.069
מה אני רוצה שיהיה שונה בכל פעם? בואו נסתכל ונראה מה שונה. מיקום ה-y, והאינקס הנוכחי במערך, נכון? אז את מספר החבר ואת מיקום ה-y.

0:01:26.069,0:01:33.570
וכמה פעמים עלינו לחזור על הפעולה? נמשיך לחזור עד שלא יהיו יותר חברים במערך.

0:01:33.570,0:01:37.440
אז עכשיו אנחנו יודעים מה אנחנו רוצים, ואנחנו יכולים ליצור את הלולאה.

0:01:37.440,0:01:44.378
נתחיל עם משתנה מונה (counter) כדי לעקוב איפה אנחנו בלולאה. אז נכתוב: 'var friendNum=0;'

0:01:44.378,0:01:50.471
אנחנו נתחיל מ-0, כי כפי שאתם זוכרים, 0 הוא האיבר הראשון במערך, לא 1.

0:01:50.548,0:01:57.766
אחרי זה יש לנו את לולאת ה-while שלנו. נכתוב: 'while(friendNum < my friends.length)'

0:01:57.766,0:02:04.462
אנחנו הולכים להשוות את ערך המונה הנוכחי עם המספר הכולל של איברים במערך.

0:02:04.462,0:02:07.868
בתוך הלולואה, זה איפה שנשתמש בפקודת ה-text.

0:02:08.068,0:02:13.460
נכתוב: 'text(myFriends[' ואז כאן, במקום מספר, נרשום 'friendNum', כי friendNum מייצג את המספר הנוכחי.

0:02:13.460,0:02:17.961
וכרגע נרשום רק מיקום אחד.

0:02:17.961,0:02:25.710
קיבלנו שגיאת לולאה אינסופית, כי לא שינינו את friendNum במהלך הלולאה.

0:02:25.710,0:02:30.230
זכרו, אנחנו צריכים להגדיל את friendNum בכל פעם, אחרת הלולאה תמשיך לנצח, כי התנאי שלה תמיד יהיה נכון.

0:02:34.750,0:02:39.271
אני רואה שמשהו קרה. תנו לי רק להפוך את הקוד הישן להערה כדי שאוכל לראות מה הקוד החדש באמת עושה.

0:02:39.271,0:02:43.607
מה שקרה הוא שהראנו את כל השמות, אבל הם כולם אחד על השני.

0:02:43.607,0:02:45.706
אז אנחנו צריכים לשנות את מיקום ה-y שלנו.

0:02:45.706,0:02:50.211
בואו פשוט נכתוב: 'friendNum*30'.

0:02:50.211,0:02:55.129
אוקיי, זה טוב, אבל סופיה מחוץ למסך, וסופיה לא תהיה מרוצה אם היא תגלה את זה.

0:02:55.129,0:02:59.628
אז בואו פשוט נוסיף לזה 30. עכשיו הם כולם מוזזים ב-30.

0:02:59.628,0:03:04.294
יפה! אז עכשיו אתם רואים שיש לנו לולאה שמציגה את המערך שלנו.

0:03:04.294,0:03:13.569
וזה אומר שאם נוסיף עוד אנשים, כמו OhNoesGuy או Sal - אם אני רק אוסיף אותו למערך, אז Sal יוצג בתור חבר שלי. מצוין! עכשיו הוא חבר שלי.

0:03:13.569,0:03:21.271
ואתם רואים שזה אוטומטית מציג חברים חדשים כי זה תמיד עובר על כל המערך.

0:03:21.271,0:03:24.296
נוכל למחוק את הקוד הישן שלנו. אנחנו לא זקוקים לו עוד.

0:03:24.296,0:03:28.237
בואו נעבור על הקוד הזה כאן ונבין מה הוא עושה.

0:03:28.237,0:03:31.628
אנחנו מתחילים עם friendNum שווה לאפס.

0:03:31.628,0:03:34.673
אנחנו בודקים אם friendNum קטן מהאורך הנוכחי [של המערך].

0:03:34.673,0:03:37.841
כפי שאתם חושבים, 0 קטן מ-6, אז התנאי הוא נכון.

0:03:37.841,0:03:41.712
אנו נכנסים לתוך הלולאה, ואז כתוב text(myFriends[friendNum]...

0:03:41.712,0:03:44.294
זה יהיה myFriends במקום ה-0, בפעם הראשונה.

0:03:44.294,0:03:47.295
ואז 30, ועוד אפס כפול 30.

0:03:47.295,0:03:53.712
אז זה מציג את סופיה במיקום (10,30). זה מה שזה עושה.

0:03:53.712,0:03:56.295
ואז friendNum++. עכשיו הערך הוא 1.

0:03:56.295,0:04:00.268
ואז אנחנו חוזרים חזרה והקוד בודק - האם 1 קטן מהאורך של myFriends? כן, הוא קטן יותר.

0:04:00.361,0:04:02.396
וזה ממשיך, ממשיך, וממשיך.

0:04:02.488,0:04:10.957
לבסוף אנחנו מגיעים ל-Sal. זכרו, Sal הוא למעשה האיבר השישי במערך, אבל מספר האינדקס שלו הוא 5, כי מתחילים לספור מאפס.

0:04:11.034,0:04:13.296
האם 5 קטן מ-6? כן.

0:04:13.296,0:04:15.462
אז זה מציג את myFriends במקום ה-5.

0:04:15.462,0:04:21.628
ואז ה-counter (מונה) הופך ל-6, ואנחנו שואלים: האם 6 קטן מ-6? לא. הם שווים.

0:04:21.628,0:04:25.440
התנאי יהיה שקר. אז זה לא לעולם לא יציג את האיבר השישי,

0:04:25.440,0:04:29.272
מה שטוב, כי אין שום דבר באינדקס 6.

0:04:29.272,0:04:32.772
יש איבר שישי, אבל לא אינקדס מספר 6.

0:04:32.772,0:04:38.570
זה יכול להיות ממש מבלבל, העובדה ש-0 הוא האיבר הראשון וכל זה, אבל אתם תתפסו את זה.

0:04:38.570,0:04:41.402
אוקיי, זו הלולאה שלנו.

0:04:41.402,0:04:45.045
עכשיו, אם תרצו, אתם יכולים להשתמש גם בלולאת for אם אתם מעדיפים לולאות for.

0:04:45.045,0:04:52.212
במקרה של לולאות for, אנחנו נכתוב פשוט: for, ואז var friendNum שווה ל-0.

0:04:52.212,0:04:57.237
ואז יש לנו את התנאי שלנו - friendNum קטן מ-myFriends.length

0:04:57.237,0:05:01.672
ואז את פעולת הקידום: 'friendNum++'

0:05:01.672,0:05:06.711
ואז בתוך לולאת ה-for, אנחנו פשוט שמים את שורת הקוד הזאת.

0:05:06.711,0:05:09.711
ואני רק אשנה את מיקום ה-x כדי שתוכלו לראות

0:05:09.711,0:05:13.711
שזה עושה בדיוק את אותו הדבר. זה תלוי בכם באיזה מהם להשתמש, אבל הנקודה היא להשתמש בלולאה עם המערכים שלכם, כי זה נותן לכם הרבה כוח.