We're back with a program that prints out my array of friends.
But there's something that really annoys me about it.
Every time I add a new friend to the array, I have to add
a new text command down here.
So let's say I add Winston.
Well, he doesn't automatically show up.
If I want him to show up, I have to go and say text(myFriends[3],
and then change the y position and then we see Winston.
So that's way too much work.
I just want it so that every time I add someone else to the array,
it does the text command automatically.
Well, do you remember when we learned loops?
Loops were a great way to repeat the same bit of code
many times in a row.
Like, if we wanted to have a bunch of trees in a row
or a bunch of balloons.
Well, as it turns out, loops are also a great way to run a bit of code
on each element in an array.
In fact, you'll use a loop almost every time you use an array.
They work really well together.
So lets use a loop to display my friends' names, instead of having
all these text commands to show you what I mean.
So we'll start with the three questions we always ask ourselves
when we're making a loop.
First, what do I want to repeat? Well, look up here. What's repeated?
The text command.
What do I want to change each time? Well, let me just look
and see what's different, the y position and the current index, right?
So the friend num and the y position.
And how long should we repeat? Well, we keep going
until there are no more friends.
So now we know what we want, and we can make our loop.
We start off with a counter variable to keep track of where we are in the loop.
So we'll say var friendNum = 0;
We're going to start with zero because remember that 0
is the first element in the array, not 1. Then we have our while loop.
So we'll say while(friendNum < my friends.length).
So we're gonna compare the current counter variable to the total number
of things in the array. Inside the loop, that's where
we use our text command.
So we say, text(myFriends[ and then here, instead of a number,
we're gonna put friendNum because friendNum represents
the current number.
And then we'll just put one position for now.
This has given us a little infinite loop error because we haven't
actually changed anything about friendNum.
Remember, we need to increment friendNum each time, otherwise the loop
will go on forever because that condition's always true.
I see something happened. Let me comment out the old code
so I can really see what's happened.
What we have is we've showed all the names,
but they're all on top of each other.
So, we need to change our y position.
Let's just say 'friendNum*30'.
That's good but Sophia's off the screen and Sophia's not going
to be very happy if she finds that out.
So, let's just add 30 to that. So now they're all offset by 30.
Beautiful! So now you see we have a loop displaying our array.
And that means if we add more people like OhNoes Guy, or maybe even Sal,
if I just add him to the array then Sal will be my friend.
Awesome! Now he's my buddy.
And you see that it just automatically shows the new friends
because it's always going through the whole array.
So we can delete our old code. We don't need that anymore.
And let's just go through this code here and review what it does.
So we start off with friendNum equal to zero.
We check to see if friendNum is less than the current length.
So you imagine zero is less than six. That's true.
So then we go inside here and we say text, my friends friendNum.
So that'll be my friends zero, the first time.
And then 30 plus zero times 30.
So it displays Sophia at 10 and 30. That's what it does.
And then friendNum++. So then it becomes 1.
And then it goes back around and says, "Ok, is 1 less
than myfriends.length? Yeah, it is."
And it keeps going, keeps going, keeps going.
And then finally we get to Sal. Remember, Sal is actually
the sixth element in the array, but he's index 5, since we start at zero.
So, is five less than six? Yes.
So it displays myfriends five.
And then it becomes six and we say, "Is six less than six?"
No. It's equal.
So this'll be false. So it will never display the sixth element
which is good because there is nothing in index six.
There's a sixth element, but nothing in index six.
it can be really confusing, the fact that it's zero and one
and doing all that but you'll get the hang of it.
All right, so that's our loop.
Now, if you want to, you can actually use a for loop
as well if you prefer for loops.
For for loops, we'll just say, for, and then, var friendNum = 0;
and then we have our condition
friendNum < myFriends.length
and then our increment: friendNum++
and then inside the for loop, we can just put just this line of code here.
and I'll just change the x so that you can see
it does exactly the same thing. So it's up to you which one you use,
but the point is to use a loop with your arrays
because it will make you so powerful.
A jsme zpátky u programu,
který pomocí pole vypisuje seznam mých kamarádů.
Něco se mi ale na něm vůbec nelíbí.
Pokaždé, když do pole přidám nového kamaráda,
musím zde dolů přidat nový textový příkaz.
Řekněme, že přidám Winstona.
Neukáže se jen tak.
Pokud chci, aby se ukázal, musím napsat "text(myFriends[3]...".
Potom ještě změním polohu y a pak už uvidím Winstona.
To je zbytečně moc práce.
Chci, aby se při přidání někoho do pole vytvořil textový příkaz automaticky.
Pamatujete si, jak jsme se učili cykly?
Cykly nám pomohly opakovat tu samou část kódu několikrát za sebou.
Například když jsme chtěli mít několik stromů za sebou.
Nebo hromadu balónů.
Cykly jsou mimo jiné taky skvělým způsobem pro to,
jak přehrát část kódu pro každý prvek v poli.
Cykly použijete skoro vždy, když budete používat pole.
Pracují spolu opravdu dobře.
Pojďme tedy pro zobrazení jmen mých přátel použít cyklus.
Použijeme ho namísto všech těchto textových příkazů.
Začneme se třemi otázkami,
na které se ptáme vždy, když tvoříme cyklus.
První: co chci opakovat?
Podívám se, co se opakuje, a vidím textový příkaz.
Druhá: co chci pokaždé změnit?
Podíváme se a zjistíme, že odlišná je poloha y a aktuální index.
Kamarádovo číslo a poloha y.
Třetí: jak dlouho chceme opakovat?
Chceme opakovat, až dokud nevypíšeme všechny kamarády.
Teď už víme, co chceme, a tím pádem můžeme vytvořit cyklus.
Začneme proměnnou pro počítaní, abychom měli přehled o stavu cyklu.
Napíšeme: var friendNum = 0;
A číslem 0 začíname kvůli tomu, že je to zároveň prvním číslem pole.
Není to číslo 1.
Poté máme while cyklus.
Napíšeme: while(friendNum < myFriends.length)
Porovnáme tedy aktuální počítadlo s celkovým počtem věcí v poli.
A uvnitř cyklu, tam kde používáme textové příkazy,
napíšeme textový příkaz myFriends, akorát místo čísla napíšeme "friendNum".
FriendNum totiž představuje aktuální číslo.
Pro teď určíme jen jednu pozici.
Náš kód momentálně produkuje chybu s nekonečným cyklem.
A to kvůli tomu, že jsme ohledně friendNum nic nezměnili.
Musíme friendNum pokaždé zvyšovat, jinak pojede smyčka donekonečna.
To kvůli tomu, že by to bylo vždy true.
Něco se stalo, teď zakomentuji starý kód.
Tím pádem můžu vidět, co se to vlastně stalo.
Takže jsme zobrazili všechna jména, jsou ale všechna naházena přes sebe.
Musíme změnit polohu y.
Napíšeme friendNum krát 30.
Je to sice fajn, ale Sophia se teď nachází mimo obrazovku.
A pokud to zjistí, tak ji to moc nepotěší.
Pojďme k tomu přidat 30, čímž je všechny posuneme o 30.
Pěkné, teď máme cyklus zobrazující naše pole.
A to znamená, že kdybychom měli více lidí, jako Ohnoes Guy,
nebo dokonce Sala, z kterého přidáním do pole udělám svého kamaráda.
A teď je můj kámoš.
Jak vidíte, nové kamarády to zobrazuje automaticky,
protože se to pokaždé přidá do celého pole.
Náš starý kód můžeme smazat, už ho nebudeme potřebovat.
Pojďme si teď kód projít a zopakovat si, jak vlastně funguje.
Začínáme s proměnnou friendNum rovné číslu 0.
Zkontrolujeme, zda je friendNum menší než aktuální délka.
Takže si to představíme a vidíme, že 0 je méně než 6.
To je pravdivé.
Poté jdeme sem a napíšeme: text(myFriends[friendNum]...)
Poprvé by to tedy bylo: myFriends[0].
Dále následuje: 30 plus 0 krát 30.
Čímž se zajistí vyobrazení Sophie na pozicích 10 a 30.
Poté máme friendNum++, čili se hodnota stává 1.
Poté se cyklus opakuje a ptá se: je číslo 1 menší než délka pole?
Ano, je.
A cyklus běží a běží.
A potom se dostaneme k Salovi.
Sal je šestým prvkem v poli, má ale index 5 (kvůli začátku na 0).
Je 5 méně než 6?
Ano, je.
Zobrazuje to kamaráda 5 a poté se hodnota stává 6.
A je 6 méně než 6?
Ne, není, je to rovno.
Podmínka bude tedy nepravdivá (false).
Nikdy se tedy nezobrazí šestý prvek.
A to je dobře, protože v indexu 6 nic není.
Šestý element je, ale index 6 nic neobsahuje.
Může to být celkem matoucí, nejdřív je to 0, pak 1 a pak další.
Naučíte se to.
To je tedy náš cyklus.
Pokud chcete, můžete klidně použít cyklus for.
V případě, že preferuje cyklus for.
Pro for cyklus napíšeme for(var FriendNum = 0) a podmínku.
FriendNum je méně než myFriends.length, poté máme přírůstek friendNum++.
A do vnitřku for cyklu vložíme tento řádek kódu.
Změním polohu x a jak vidíte, dělá to úplně tu samou věc.
Takže je na vás, který z nich použijete.
Důležité je, že použijete cyklus v kombinaci s vaším polem.
Učiní vás to opravdu mocnými.
Estamos de regreso con un programa que imprime el arreglo de mis amigos.
Pero hay algo en esto que realmente me molesta.
Cada vez que añado un nuevo amigo a mi arreglo, tengo que añadir un comando "text" aquí abajo.
Digamos que añado a "Winston".
Bueno, no se muestra automáticamente.
Si quiero mostrarlo, tengo que ir aquí y escribir "text(myFriends[3]" , luego cambiar la posición de "y" y entonces vemos a "Winston".
Eso es mucho trabajo.
Yo quisiera que cada vez que añado a alguien a mi arreglo se ejecute el comando "text" automáticamente.
Bueno, ¿recuerdas cuando aprendimos de ciclos?
Usar ciclos es una gran manera de repetir la misma porción de código muchas veces en una fila.
Como si quisiéramos tener un montón de árboles en una fila o un montón de globos.
Bueno, pues los ciclos también son una solución para correr una porción de código para cada elemento de un arreglo.
De hecho, usarás un ciclo casi siempre que uses arreglos. Funcionan muy bien juntos.
Así que para mostrarte lo que quiero decir, usemos un ciclo para desplegar los nombres de mis amigos, en lugar de tener todos estos comandos de texto.
Así que empezaremos con las tres preguntas que siempre nos hacemos cuando queremos usar un ciclo.
Primera, ¿qué es lo que quiero repetir? Bueno, revisemos aquí. ¿Qué es lo que se está repitiendo? El comando "text".
¿Qué es lo que quiero cambiar cada vez? Bueno, déjenme ver qué es diferente. La posición de "y" y el índice, ¿cierto? Así que lo que queremos cambiar es el número de amigo y la posición de "y".
¿Hasta cuándo quiero repetir? Bueno, queremos repetir hasta que no haya más amigos.
Así que ahora sabemos lo que queremos, y podemos hacer el ciclo.
Empezaremos con una variable que será un contador, para llevar un seguimiento de dónde estamos en el ciclo. Así que digamos "var friendNum = 0;"
Vamos a empezar con 0 porque recuerden que 0 es el primer elemento del arrego, no 1.
Luego tenemos nuestro ciclo "while". Así que diremos "while(friendNum < myFriends.lenght)". (Mientras la variable "friendNum" sea menor que "myFriends.lenght").
Así que vamos a comparar el contador actual con el total de elementos del arreglo.
Y es dentro del ciclo, donde usamos el comando "text".
Así que decimos "text(myFriends[" y aquí, en lugar de un número, ponemos la variable "friendNum" porque "friendNum" representa el elemento actual.
Y luego voy a poner esta posición por ahora.
Aquí nos marca un error de ciclo infinito porque en realidad no hemos cambiado nada en "friendNum".
Recuerda, necesitamos incrementar "friendNum" cada vez, de otra manera el ciclo correrá de manera indefinida porque la condición siempre será verdadera.
Veo que algo pasa. Voy a poner comentarios en el código anterior. Para que pueda ver realmente qué está pasando.
Lo que tenemos aquí es que hemos mostrado todos los nombres, pero están unos encima de otros.
Así que tenemos que cambiar la posición de "y".
Digamos "friendNum" multiplicado por 30.
Ok, eso está bien, pero "Sophia" está fuera de la pantalla, y "Sophia" no va a estar muy contenta si se da cuenta de esto.
Así que sumemos 30 a esto. Ahora todos están recorridos en 30.
¡Hermoso! Ahora puedes ver que tenemos un ciclo que despliega nuestro arreglo.
Y eso significa que si añadimos más personas como "OhNoes Guy", o tal vez a "Sal", si lo añado a mi arreglo entonces "Sal" va a ser mi amigo. ¡Impresionante! Ahora él es mi amigo.
Y puedes ver que automáticamente se muestran los amigos nuevos, porque siempre se recorre todo el arreglo.
Así que podemos borrar nuestro código anterior. Ya no lo necesitamos.
Y vamos a recorrer el código y revisar lo que hace.
Comenzamos con "friendNum" igual a cero.
Verificamos si "friendNum" es menor que la longitud actual de arreglo.
Así que sabemos que cero es menor que 6. Eso es verdad.
Entonces vamos aquí dentro y decimos que imprima el elemento "friendNum" del arreglo "myFriends"
Éste será cero, la primera vez.
Y luego será igual a 30 más cero por 30.
Así que despliega "Sophia" en 10 y 30. Es lo que hace.
Y luego "friendNum++". Así que ahora "friendNum" es 1.
Y luego regresa al principio y dice: "Ok, ¿1 es menor que 'myFriends.lenght'? Sí, sí lo es".
Y continúa, continúa y continúa.
Y finalmente llegamos a "Sal". Recuerda que "Sal" es el sexto elemento en el arreglo, pero su índice es 5, porque empezamos en cero.
Entonces, ¿cinco es menor que seis? Sí.
Así que despliega "myFriends" índice 5.
Y luego esto es seis y decimos: "¿seis es menor que seis? No. Es igual.
Entonces esto es falso. Así que nunca desplegará el sexto elemento,
lo cual es bueno porque no hay nada en el índice seis.
Hay un sexto elemento, pero no hay nada en el índice seis.
Eso puede ser realmente confuso, el hecho de que haya un cero y un uno y todo eso, pero podrás manejarlo.
Muy bien, éste es nuestro ciclo.
Ahora, si quieres puedes usar un ciclo "for" si es que prefieres los ciclos "for".
Para usar un ciclo "for", escribiremos "for" y luego, "var friendNum = 0;" y luego tenemos nuestra condición
"friendNum < myFriend.lenght",
y luego escribimos nuestro incremento "friendNum++".
Y luego dentro del ciclo "for" ponemos esta línea de código aquí.
Y sólo cambiaré la "x" para que puedas ver
que hace exactamente lo mismo. Así que tú decides cuál ciclo usar, el punto es que uses un ciclo con tu arreglo, porque eso te hará muy poderoso.
חזרנו, עם תוכנה שמדפיסה את מערך החברים שלי.
אבל יש משהו שממש מעצבן אותי לגביה.
בכל פעם שאני מוסיפה חבר חדש למערך, אני צריכה להוסיף פקודת text כאן למטה.
בואו נאמר שאני מוסיפה את ווינסטון.
ובכן, הוא לא מופיע אוטומטית.
אם אני רוצה שהוא יופיע, אני צריכה לכתוב text(myFriends[3], ואז לשנות את המיקום בציר ה-y, ואז אנו רואים את ווינסטון.
זה הרבה יותר מדי עבודה!
אני רק רוצה שבכל פעם שאני מוסיפה מישהו למערך, שורת הקוד תתבצע אוטומטית.
ובכן, אתם זוכרים שכלמדנו לולאות?
לולאות היו דרך מעולה לחזור על אותו קטע קוד פעמים רבות ברצף.
למשל, אם רצינו לקבל אוסף עצים או בלונים ברצף.
ובכן, מסתבר שלולאות הן גם דרך מעולה להריץ קטע קוד מסוים על כל איבר במערך.
למעשה, אתם תשתמשו בלולאה כמעט בכל פעם שתשתמשו במערך. הם עובדים מצוין יחד.
בואו נשתמש בלולאה כדי להציג את השמות של החברים שלי, במקום כל השורות האלו עם פקודות text, כדי שתראו למה אני מתכוונת.
נתחיל עם שלוש שאלות שאנחנו תמיד שואלים את עצמנו כשאנחנו כותבים לולאה.
ראשית, על מה אני רוצה לחזור? ובכן, הסתכלו על הקוד כאן למעלה. מה חוזר על עצמו? פקודת ה-text.
מה אני רוצה שיהיה שונה בכל פעם? בואו נסתכל ונראה מה שונה. מיקום ה-y, והאינקס הנוכחי במערך, נכון? אז את מספר החבר ואת מיקום ה-y.
וכמה פעמים עלינו לחזור על הפעולה? נמשיך לחזור עד שלא יהיו יותר חברים במערך.
אז עכשיו אנחנו יודעים מה אנחנו רוצים, ואנחנו יכולים ליצור את הלולאה.
נתחיל עם משתנה מונה (counter) כדי לעקוב איפה אנחנו בלולאה. אז נכתוב: 'var friendNum=0;'
אנחנו נתחיל מ-0, כי כפי שאתם זוכרים, 0 הוא האיבר הראשון במערך, לא 1.
אחרי זה יש לנו את לולאת ה-while שלנו. נכתוב: 'while(friendNum < my friends.length)'
אנחנו הולכים להשוות את ערך המונה הנוכחי עם המספר הכולל של איברים במערך.
בתוך הלולואה, זה איפה שנשתמש בפקודת ה-text.
נכתוב: 'text(myFriends[' ואז כאן, במקום מספר, נרשום 'friendNum', כי friendNum מייצג את המספר הנוכחי.
וכרגע נרשום רק מיקום אחד.
קיבלנו שגיאת לולאה אינסופית, כי לא שינינו את friendNum במהלך הלולאה.
זכרו, אנחנו צריכים להגדיל את friendNum בכל פעם, אחרת הלולאה תמשיך לנצח, כי התנאי שלה תמיד יהיה נכון.
אני רואה שמשהו קרה. תנו לי רק להפוך את הקוד הישן להערה כדי שאוכל לראות מה הקוד החדש באמת עושה.
מה שקרה הוא שהראנו את כל השמות, אבל הם כולם אחד על השני.
אז אנחנו צריכים לשנות את מיקום ה-y שלנו.
בואו פשוט נכתוב: 'friendNum*30'.
אוקיי, זה טוב, אבל סופיה מחוץ למסך, וסופיה לא תהיה מרוצה אם היא תגלה את זה.
אז בואו פשוט נוסיף לזה 30. עכשיו הם כולם מוזזים ב-30.
יפה! אז עכשיו אתם רואים שיש לנו לולאה שמציגה את המערך שלנו.
וזה אומר שאם נוסיף עוד אנשים, כמו OhNoesGuy או Sal - אם אני רק אוסיף אותו למערך, אז Sal יוצג בתור חבר שלי. מצוין! עכשיו הוא חבר שלי.
ואתם רואים שזה אוטומטית מציג חברים חדשים כי זה תמיד עובר על כל המערך.
נוכל למחוק את הקוד הישן שלנו. אנחנו לא זקוקים לו עוד.
בואו נעבור על הקוד הזה כאן ונבין מה הוא עושה.
אנחנו מתחילים עם friendNum שווה לאפס.
אנחנו בודקים אם friendNum קטן מהאורך הנוכחי [של המערך].
כפי שאתם חושבים, 0 קטן מ-6, אז התנאי הוא נכון.
אנו נכנסים לתוך הלולאה, ואז כתוב text(myFriends[friendNum]...
זה יהיה myFriends במקום ה-0, בפעם הראשונה.
ואז 30, ועוד אפס כפול 30.
אז זה מציג את סופיה במיקום (10,30). זה מה שזה עושה.
ואז friendNum++. עכשיו הערך הוא 1.
ואז אנחנו חוזרים חזרה והקוד בודק - האם 1 קטן מהאורך של myFriends? כן, הוא קטן יותר.
וזה ממשיך, ממשיך, וממשיך.
לבסוף אנחנו מגיעים ל-Sal. זכרו, Sal הוא למעשה האיבר השישי במערך, אבל מספר האינדקס שלו הוא 5, כי מתחילים לספור מאפס.
האם 5 קטן מ-6? כן.
אז זה מציג את myFriends במקום ה-5.
ואז ה-counter (מונה) הופך ל-6, ואנחנו שואלים: האם 6 קטן מ-6? לא. הם שווים.
התנאי יהיה שקר. אז זה לא לעולם לא יציג את האיבר השישי,
מה שטוב, כי אין שום דבר באינדקס 6.
יש איבר שישי, אבל לא אינקדס מספר 6.
זה יכול להיות ממש מבלבל, העובדה ש-0 הוא האיבר הראשון וכל זה, אבל אתם תתפסו את זה.
אוקיי, זו הלולאה שלנו.
עכשיו, אם תרצו, אתם יכולים להשתמש גם בלולאת for אם אתם מעדיפים לולאות for.
במקרה של לולאות for, אנחנו נכתוב פשוט: for, ואז var friendNum שווה ל-0.
ואז יש לנו את התנאי שלנו - friendNum קטן מ-myFriends.length
ואז את פעולת הקידום: 'friendNum++'
ואז בתוך לולאת ה-for, אנחנו פשוט שמים את שורת הקוד הזאת.
ואני רק אשנה את מיקום ה-x כדי שתוכלו לראות
שזה עושה בדיוק את אותו הדבר. זה תלוי בכם באיזה מהם להשתמש, אבל הנקודה היא להשתמש בלולאה עם המערכים שלכם, כי זה נותן לכם הרבה כוח.
ჩვენ ვუბრუნდებით პროგრამას, რომელიც ბეჭდავს ჩემი მეგობრების მწყობრს.
მაგრამ აქ არის რაღაცა, რაც ნამდვილად მაღიზიანებს.
ყოველ ჯერზე, როცა ვამატებ ახალ მეგობარს მწყობრში,
უნდა დავუმატო ახალი text ბრანება აქ.
მაგალითად ვამატებ ვინსტონს.
ის ავტომატურად არ ჩნდება.
თუ მინდა რომ გამოჩნდეს, უნდა დავწერო "text(myFriend[3]", შემდეგ შევცვალო
y-ის პოზიცია და შემდეგ ვხედავთ ვინსტონს.
ეს ცოტა ზედმეტი სამუშაოა.
მე უბრალოდ მინდა, რომ ყოველჯერზე როცა დავამატებ ვინმეს მწყობრში,
თავისით აკეთებდეს text ბრძანებას.
გახსოვთ როდის ვისწავლეთ loop-ები?
Loop-ები იყო კარგი გზა ერთი და იგივე კოდის გასამეორებლად ერთ რიგში.
მაგალითად თუ გვინდოდა, რომ გვქონოდა რამოდენიმე ხე მწკრივში
ან რამოდენიმე ბუშტი.
როგორც ჩანს, loop-ები ასევე კარგი გზა გავუშვათ პატარა კოდი
თითო ელემენტზე მწყობრში.
სინამდვილეში, loop-ი ყოველთვის გჭირდებათ, როცა იყენებთ მწყობრს (array).
ერთად მართლაც კარგად მუშაობენ.
მოდით გამოვიყენოთ loop-ი, რომ გამოვსახოთ ჩემი მეგობრების სახელები,
ამ text ბრძანებების მაგივრად, რომ განახოთ რას ვგულისხმობ.
დავიწყოთ სამი კითხვით, რომელსაც ვუსვავთ ჩვენ თავს, როცა ვიწყებთ loop-ის გაკეთებას.
პირველი, რა მინდა რომ გავიმეორო? შეხედეთ აქ. რა მეორდება? text ბრძანება.
რა მინდა რომ შევცვალო ყოველ ჯერზე? მოდით შევხედოთ და ვნახოთ რა არის განსახვავებული.
y-ის პოზიცია და ინდექსი, ხომ? ანუ მეგობრის ცვლადი და y-ის პოზიცია.
და რამდენჯერ უნდა გავიმეოროთ? სანამ მეტი მეგობარი აღარ იქნება.
ეხლა ვიცით რა გვინდა და შეგვიძლია გავაკეთოთ ჩვენი loop-ი.
ვიწყებთ მოპიდაპირე ცვლადით, რომ ვიცოდეთ სად ვართ loop-ში.
ანუ ვწერთ "var friendNum=0;"
ვიწყებთ ნულით, იმიტომ რომ, ხომ გახსოვთ 0 არის პირველი ელემენტი მწყობრში, და არა 1.
შემდეგ გვაქვს while loop-ი. ვწერთ "while(friendNum < my friends.length)'
ჩვენ უნდა შევადაროთ მიმდინარე მოპირდაპირე ცვლადი,
ჯამური რაღააცეების რიცხვს მწყობრში.
loop-ის შიგნით, სადაც ვიყენებთ ჩვენს text ბრძანებას.
ვწერთ, "text(myFriends[" - და შემდეგ აქ, რიცხვის მაგივრად, ჩავსვავთ "friendNum"-ს,
რადგან "friendNum" წარმოადგენს მიმდინარე რიცხვს.
შემდეგ ჩავსვათ მხოლოდ ერთ პოზიციას ჯერ-ჯერობით.
ამან მოგვცა პატარა უსასრულო loop-ის შეცდომა, რადგან "friendNum"-თან
დაკავშირებით არაფერი არ შეგვიცვლია.
გახსოვთ, ჩვენ უნდა გავზარდოთ "friendNum" ყოველ ჯერზე, წინააღმდეგ შემთხვევაში
loop-ი გაგრძელდება უსასრულოდ, რადგან ეს მნიშვნელობა ყოველთვის მართალია.
ვხედავ რაღაც მოხდა. მოდით დავაკომენტარებ ძველ კოდს, რომ კარგად დავინახო რა მოხდა.
ჩვენ გვაქვს ყველა სახელი, მაგრამ ყველა ერთ ადგილას წერია.
ამიტომ, უნდა შევცვალოთ ჩვენ y პოზიცია.
მოდით, ვთქვათ "friendNum*30".
კარგით, ეს უკეთესია მაგრამ სოფია ეკრანს გარეთ არის და სოფიას ეს
არ გუახარდება თუ გაიგებს.
ამიტომ, მოდით დავამატოთ 30. ეხლა ყველა დაშორებულია 30-ით.
ლამაზია! ეხლა ხედავთ loop-ი როგორ გამოსახავს ჩვენს მწყობრს.
და ეს ნიშნავს რომ, თუ დავამატებთ მეტ ხალხს, როგორც OhNoesGuy ან შეიძლება Sal,
თუ უბრალოდ დავამატებ მწყობრს, მაშინ Sal-ი იქნება ჩემი მეგობარი. მაგარია!
ეხლა ის უკვე ჩემი მეგობარია.
თქვენ ხედავთ, რომ ეს ავტომოტურად გვიჩვენებს ახალ მეგობრებს,
რადგან ყოველთვის მთლიან მწყობრს გადის.
შეგვიძლია წავშალოთ ჩვენი ძველი კოდი. მეტი აღარ გვჭირდება.
მოდით გავიაროთ ეს კოდი თავიდან და გადავხედოთ რა აკეთებს.
ჩვენ ვიწყებთ "friendNum" უდრის ნულით.
ვამოწმებთ, რომ ვნახოთ, "friendNum"-ი თუ ნაკლებია მიმდინარე სიგრძეზე.
წარმოვიდგენთ რომ ნული ნაკლებია ექვსზე. მართალია.
შემდეგ შევდივართ აქ და ვწერთ text, ჩემი მეგობრები "friendNum".
თავიდან ყველა გახდება ნული.
შემდეგ, 30 პლუს 0 გამრავლებული 30-ზე.
ეს გვიჩვენებს სოფიას 10-ზე და 30-ზე. ამას აკეთებს ეს.
შემდეგ friendNum++. და შემდეგ ხდება 1.
შემდეგ ბრუნდება უკან და ამომბს, "კარგი, 1 ნაკლებია "myFriends.length"-ზე? კი არის."
და მიდის, მიდის და მიდის.
და ბოლოს მივდივართ Sal-თან. გახსოვთ, Sal-ი არის მეექვსე ელემენტი მწყობრში,
მაგრამ მისი ინდექსი არის 5, რადგან ვიწყებთ ნულიდან
ხუთი ნაკლებია ექვსზე? კი.
ამიტომ გვიჩვენებს "myFriends" ხუთს.
შემდეგ ხდება ექვსი და ვამბობთ, "ექვსი ნაკლებია ექვსზე?" არა. ტოლია.
ამიტომ ეს იქნება მცდარი. მეექსვე ელემენტს არსდროს არ გვიჩვენებს,
რაც კარგია, რადგან ინდექს ექვსში არ არაფერი არ არის.
მეექვსე ელემენტი არის, მაგრამ ინდექს ექვსში არაფერი არ არის.
შეიძლება დამაბნეველი იყოს, ის ფაქტი რომ ნულია და ერთი
და ამ ყველაფერს აკეთებს, მაგრამ მიეჩვევით.
კარგით, ეს არის ჩვენი loop-ი.
ეხლა, თუ გინდათ, შეგიძლიათ გამოიყენოთ for loop-ი, თუ გირჩევნიათ for loop-ები.
for loop-ებისთვის, ჩვენ უბრალოდ დავწერთ for, და შემდეგ, "var friendNum = 0;"
და შემდეგ გვაქვს ჩვენი პირობა
"friendNum < myFriends.length"
და შემდეგ ჩვენი ზრდადი - "friendNum++",
და შემდეგ for loop-ის შიგნით, შეგვიძლია უბრალოდ ჩავსვათ კოდის ეს ხაზი.
და მე შევცვლი x-ს, რომ დაინახოთ, რომ ზუსტად იგივეს აკეთებს.
ასე რომ, თქვენი ნებაა რომელს გამოიყენებთ, მაგრამ იდეა ის არის რომ გამოიყენოთ
loop-ი მწყობრის დროს, რადგან ეს ნამდვილად გაგაძლიერებთ.
제 친구들을 출력하는 배열로 돌아왔어요
그런데 저를 굉장히 거슬리게 하는 것이 있네요
새로운 친구를 배열에 추가할 때마다 새로운 text 명령어를 추가해야 해요
Winston을 추가해 볼게요
자동으로 나타나지는 않아요
그를 나타나게 하고싶으면 'text(myFriends[3]' 을 쓰고 y좌표를 바꿔야 하죠
이렇게 하면 일이 너무 많아요
배열에 누군가를 추가할 때마다 text 명령어도 자동으로 되었으면 좋겠어요
반복문에 대해 배웠던 것 기억나세요?
반복문은 같은 코드를 반복해서 사용할 때 쓰면 좋은 방법이에요
마치 나무나 풍선들을 한 줄로 세운다거나 할 때 말이죠
반복문은 배열의 각 요소들에 대해 코드를 실행할 때 쓰면 좋아요
사실 여러분들이 배열을 쓸 때마다 반복문을 함께 사용하게 될거에요
둘은 굉장히 잘 어울리거든요
제 친구들의 이름을 출력할 때 매번 명령어를 쓰지 않고 반복문을 사용해볼게요
반복문을 사용할 때의 세 가지 질문들로 시작할게요
첫번째, 뭘 반복해야하나요?
여기 뭐가 반복되나요? text 명령어죠.
매번 무엇을 바꿔야 하나요?
여기 뭐가 다른지 한번 살펴볼게요
y좌표와 현재 인덱스군요 그러니까 친구 번호와 y좌표
몇 번 반복해야하죠? 친구가 없을 때까지 반복해야해요
이제 필요한 것을 알았으니 반복문을 만들 수 있어요
반복문에서 우리가 어디까지 와 있는지를 알려주는 카운터 변수로 시작할게요
그러니까 'var friendNum = 0;' 으로요
0부터 시작할거에요 배열의 첫번째는 0인걸 기억하세요
다음에 여기 while문을 쓸게요
'while(friendNum < myfriends.length)'
현재 카운터 변수와 배열 요소의 총 개수를 비교할 거에요
반복문 안에는 text명령어를 쓸거에요
'text(myFriends['라고 쓰고, 여기에 숫자 대신 'friendNum'을 쓰세요 왜냐하면 그것이 현재의 순서를 말해주는 것이니까요
지금은 좌표를 고정시켜 둘게요
지금은 friendNum을 바꾸지 않아서 무한반복 에러가 발생해요
매번 friendNum을 증가시키는 걸 잊지마세요
아니면 조건이 항상 참이기 때문에 반복문이 무한히 수행될 거에요
여기 뭔가 생겼네요 예전 코드는 주석으로 처리할게요
모든 이름들이 나타났지만 다 겹쳐져 있어요
y좌표를 바꿔보도록 하죠
'friendNum * 30'으로 할게요
낫긴한데 Sophia가 화면 밖으로 벗어났군요 얘가 알면 별로 좋아하지 않을 것 같아요
여기 30을 더할게요 이제 30만큼 내려왔네요
아름답네요! 반복문을 사용해 배열을 출력하게 되었어요
이제 OhNoesGuy나 Sal을 array에 추가하면 바로 제 친구가 되는 거에요
항상 배열 전체를 훑기 때문에 새 친구들을 자동으로 보여줄 거에요
예전 코드는 더 이상 필요없으니 지울게요
이 코드가 어떤 일을 하는지 다시 살펴볼게요
friendNum = 0 부터 시작해요
그리고 friendNum이 배열의 현재 길이보다 작은지 체크해요
0은 6보다 작아요 참이죠
그러면 반복문안으로 들어가서 text명령어를 수행해요
처음에는 myFriends[0] 에요
다음엔 30 + 0 * 30 이고요
그러니까 Sophia를 (10,30)위치에 출력해요
그리고 friendNum++ 을 하니까 1이 되요
다시 돌아가서 "1은 myFriends.length 보다 작지? 응, 맞아" 를 하는거에요
그리고 또 하고, 또 하고, 또 계속 반복 해요
마지막으로 Sal이 나와요
기억하세요. Sal은 6번째 요소지만 0에서 시작하니까 인덱스는 5에요
5가 6보다 작나요? 그렇죠
myFriends[5]를 출력하게 돼요
그럼 이 값이 6이 될 거고 "6이 6보다 작나요?" 아뇨. 같죠
이건 거짓이 될 거에요 여섯 번째 요소를 출력하지 않겠죠
6번 인덱스엔 아무것도 없으니까 괜찮아요
6번째 요소는 있지만 6번 인덱스엔 아무것도 없어요
좀 헷갈릴 수 있지만 곧 익숙해 질거에요
좋아요. 이게 반복문이에요
만약 for문을 더 좋아하면 for문을 사용해도 돼요.
for문에서는 'for'랑 'var friendNum = 0;' 을 쓰고 여기 조건을 쓸게요
'friendNum < myFriends.length;'
그리고 증가하는 부분도요 'friendNum++'
for문 안에는 이 코드를 쓰면 돼요
여러분이 보이도록 x좌표를 바꿀게요
둘 다 완전히 같은 일을 해요
어떤 걸 사용할지는 여러분 마음이에요
요점은 반복문을 배열과 함께 사용하면 좋다는 거에요
왜냐면 여러분들을 훨씬 강력하게 해줄거니까요
Wracamy do programu z tablicą moich znajomych.
Coś mnie tu irytuje.
Dodając znajomego, muszę też dodać nowe polecenie „text”.
Powiedzmy, że dodaję Winstona. Nie pokazuje się automatycznie.
Musiałabym napisać: 'text(myFriends[3]',
zmienić pozycję „y” i dopiero zobaczymy Winstona.
Za dużo pracy!
Chcę, żeby za każdym razem, gdy kogoś dodaję,
polecenie „text” pisało się samo.
Pamiętacie pętle?
To świetny sposób, żeby wiele razy powtarzać fragment programu.
Np. gdybyśmy chcieli mieć szereg drzew lub grupę baloników.
Okazuje się, że pętle to też dobry sposób,
by powtarzać fragment programu przy każdym elemencie tablicy.
Będziecie używać pętli przy każdym użyciu tablicy.
Dobrze współpracują.
Za pomocą pętli pokażę imiona znajomych,
zamiast pisać te wszystkie polecenia „text”.
Zacznijmy od trzech pytań związanych z pętlą.
1.: „Co chcę powtarzać?”.
Zobaczmy. Co się powtarza? Polecenie „text”.
Co chcę zawsze zmieniać? Spójrzmy, co się zmienia.
Pozycja „y” i indeks, tak?
Numer znajomego oraz pozycja „y”.
A jak długo mamy to powtarzać? Aż skończą się znajomi.
Wiemy, czego chcemy, możemy więc zrobić pętlę.
Najpierw licznik, by wiedzieć, gdzie jesteśmy.
Powiemy: 'var friendNum = 0;'
Zaczniemy od zera,
bo pamiętajcie, to jest pierwszy element tablicy, nie 1.
Teraz pętla warunkowa. Napiszemy: 'while(friendNum...
< my friends.length)'.
Porównamy licznik
z łączną liczbą rzeczy w tablicy.
Wewnątrz pętli użyjemy polecenia „text”.
Piszemy: 'text(myFriends['.
Zamiast liczby wstawimy 'friendNum',
bo oznacza bieżącą liczbę.
Na razie wprowadzimy jedną pozycję.
I mamy komunikat o błędzie „pętla nieskończona”,
bo nie zmieniliśmy nic we „friendNum”.
Zawsze zwiększamy „friendNum”. Inaczej pętla się nie skończy,
bo ten warunek zawsze jest prawdziwy.
Coś się zdarzyło.
Porzucę stary program, prześledzimy to.
Wyświetliły się wszystkie imiona, ale jedne na drugich.
Trzeba zmienić pozycję „y”.
Powiedzmy: 'friendNum*30'.
Dobrze, ale Sophia zniknęła.
Jeśli się dowie, nie będzie zadowolona.
Dodajmy do tego 30. Teraz wszystkie się rozsuną.
Pięknie! Dzięki pętli pokazuje się tablica.
Jeśli dodamy więcej ludzi, np. faceta „O, nie!” lub Sala...
Dodam go do tablicy i będzie moim znajomym.
Świetnie! To mój kumpel!
Jak widać, program automatycznie pokazuje nowych znajomych,
bo zawsze przechodzi przez całą tablicę.
Możemy skasować stary program. Już go nie potrzebujemy.
Przejrzyjmy ten program i zobaczmy, co robi.
Zaczynamy od „friendNum” równego zero.
Sprawdzamy, czy „friendNum” jest mniejsze niż bieżąca długość.
Zero jest mniejsze od sześciu. To prawda.
Wejdźmy tutaj i napiszmy: „text my friends friendNum”.
To będzie zero. Pierwszy punkt.
A potem 30 plus zero razy 30.
Program pokazuje Sophię w pozycji 10-30.
Właśnie tak. Później: - „friendNum++”. I robi się 1.
Program pyta: „Czy 1 to mniej niż myFriends.length?”. Tak.
I działa dalej, i dalej...
W końcu dochodzimy do Sala.
Jest szóstym elementem tablicy,
ale ma nr 5, bo zaczynamy od zera.
Czy 5 jest mniejsze od 6? Tak.
Program pokazuje „myFriends5”.
Dalej jest 6. Pytamy:
„Czy 6 jest mniejsze od 6?”. Nie: jest równe.
To fałsz. Program nie pokaże szóstego elementu.
I dobrze, bo żaden nie ma takiego numeru.
Jest szósty element, ale numeru szóstego nie ma.
To zero i jedynka mogą wam mącić w głowach, ale przywykniecie.
To jest nasza pętla.
Możecie też używać pętli FOR, jeśli takie wolicie.
Wtedy powiemy tylko: „for' i 'var friendNum = 0;”
i podamy warunek: „friendNum < myFriends.length”
oraz zmianę: 'friendNum++'
Wewnątrz pętli FOR umieścimy ten fragment programu.
Zmienię „x”, żebyście zobaczyli,
że program robi to samo.
Używajcie do tablic pętli,
bo to wam da wielką moc!
Voltamos com um programa que imprime array de amigos.
Mas tem algo nisso que me deixa irritada.
Sempre que adiciono um novo amigo no array tenho que adicionar um novo texto no fim.
Digamos que adicione Winston.
Ele não irá aparecer automaticamente.
Para aparecer, digito text(MyFriends[3]) e mudamos a posição y e veremos Winston.
É muito trabalhoso.
Sempre que adicionar algo ao array, quero que o texto seja adicionado automaticamente
Você se lembra de quando aprendemos laços?
Laços de repetição foram um bom modo de repetir o mesmo trecho de código várias vezes.
Como, se quiséssemos ter várias árvores enfileiradas ou um monte de balões.
Laços de repetição é uma excelente maneira de rodar um pedaço de código em cada array
De fato, você verá laço de repetição em quase todas as vezes que ver um array.
Eles trabalham muito bem em conjunto.
Vamos usar laços de repetição para imprimir na tela nomes de amigos,
ao invés de usar todos esses comandos, para mostrar o que eu quero dizer.
Comecemos com três perguntas que sempre nos fazemos quando criamos um laço.
Primeiro, o que eu quero repetir? Veja. O que é repetido? O comando texto.
O que quero mudar toda vez? Bem, deixe-me ver o que é diferente.
A posição 'y' e o atual 'index', certo ?
O número do amigo e a posição 'y'.
E quantas vezes devo repetir? Bem, repetiremos até que não haja mais amigos.
Então agora sabemos o que queremos, e podemos criar nosso laço.
Começamos com a variável counter para sabermos em que lugar do laço estamos.
Então vou dizer var friendNum = 0;
Inicializaremos como zero, pois ele é o o primeiro elemento do array, e não 1.
Teremos o nosso laço while, então diremos while(friendNum < myfriends.length).
Iremos comparar o valor atual de "counter" com a variável número de objetos no array.
Dentro do laço, será onde usaremo o comando "text".
Diremos, text(myFriends) - e aqui, ao invés do número
colocaremos friendNum porque representa o número atual.
E então colocaremos apenas uma posição.
Isto nos dá um pequeno erro de repetição infinita
porque não mudamos de fato nada no friendNum.
Lembre-se, precisamos incrementar friendNum toda vez
caso contrário o laço sempre se repetirá pois a condição sempre será verdadeira.
Vi que algo aconteceu. Comentarei o outro código para poder ver o que houve.
O que temos é que mostramos todos os nomes, mas eles um em cima do outro.
Então, precisamos mudar posição 'y'.
Vamos dizer apenas 'friendNum * 30'.
Ficou bom, mas Shophia está fora da tela e ela não vai ficar feliz se descobrir isso.
Então, vamos adicionar apenas 30. Agora todos aparecendo com 30.
Agora você verá que temos um laço para imprimindo nosso array.
Isso significa que se adicionarmos mais pessoas como OhNoesGuy, ou até mesmo Sal,
se eu incluí-los no array, então Sal será meu amigo. Legal! Agora ele é meu colega.
Você vê que aparece automaticamente novos amigos pois está percorrendo todo o array.
Então podemos apagar nosso código antigo. Não precisamos mais dele.
Vamos dar uma olhada nesse código novamente e revisar o que ele faz.
Começamos com friendNum = 0;.
Verificamos se friendNum é menor que o tamanho atual.
Então imagine que zero é menor que seis. O que é verdade.
Então vamos pra cá e dizemos que 'text', é igual valor de firendNum.
Isso vai virar zero, a primeira vez.
E então 30 mais zero 30.
Sophia aparece na posição 10 e 30. É o que isso faz.
E então friendNum++, e vira 1.
E código recomeça e valida, "Ok, 1 é menor que o myFriends.Lenght? Sim é."
E continua e continua e continua.
E então chegamos ao Sal, lembre,
Sal é atualmente o sexto elemento no array, mas seu índice é 5,
já que começamos com zero.
Então, cinco é menor que seis? Sim.
Então vai imprimir 'myFriends' cinco.
E então vira seis e validamos. "Seis é menor que seis?" Não, é igual.
Então será falso. Nunca apresentaremos o sexto elemento.
O que é bom porque não há nada na sexta posição.
Há um sexto elemento, mas não há nada dentro.
Pode ser bem confuso, o fato de ser zero e um, mas você pega o jeito.
Muito bem, esse é nosso laço.
Agora, se você quiser, você pode usar um laço do tipo "for" se você preferir.
Para laços do tipo "for", dizemos apenas 'for' e var friendNum=0; e a condição .
friendNum < myFriends.length;
e o incremento: friendNum++
E então dentro do laço 'for', podemos colocar somente essa linha de código aqui.
E apenas mudarei o 'x' para que você possa ver.
O resultado é o mesmo.
Você que decide qual usar, mas a questão é usar um laço com o array dará mais poder.
Legendado por [Valter Bigeli] Revisado por [Fernando dos Reis]
Ми повернулися до програми, що виводить масив моїх друзів.
Але є дещо, що справді дратує мене.
Кожного разу додаючи нового друга в масив, мені потрібно ввести нову текстову команду
Скажемо, я додаю Вінстона.
Що ж, він автоматично не виводиться.
Якщо я хочу, щоб він, щоб показався, мені слід ввести 'text(myFriends[3]',а потім
змінити положення у, і тоді ми побачимо, Вїнстона. Так що це занадто багато роботи.
Я хочу щоб кожного разу додаючи когось в масив команда тексту вводилась автоматично
І так, ви пам'ятаєте, що ми вчили цикли?
Цикли є чудовим способом щоб повторити той самий кусочок коду багато разів підряд.
Наприклад, якщо б ми хотіли мати купу дерев в ряд або повітряних куль.
Як виявилось, цикли це хороший спосіб щоб запустити код по кожному елементі в масиві
Насправді, ви будете використовувати цикл майже зажди, коли ви використовуєте масив.
Вони працюють дуже добре разом.
Отже, використаємо цикл щоб показати імена моїх друзів замість цих текстових команд
щоб показати що я маю на увазі.
Тому, ми розпочнемо з трьох питань які ми ставимо собі кожного разу створюючи цикл.
По-перше, що я хочу повторити. Подивимось тут. Що повторюється? текстова команда.
Що я хочу змінювати кожного разу? Отже, подивлюсь, що відрізняється.
Позиція "y" і цей показник, так? Отже, кількість друзів та "y" позиція
І як довго нам слід повторюати? Будемо продовжати до тих пір, поки
не закінчаться друзі.
Отже, тепер ми знаємо, що ми хочемо, і можемо зробити наш цикл.
Ми починаємо зі змінною лічильника, щоб відстежувати, де ми знаходимося в циклі.
Так що ми скажемо "var friendNum = 0;"
Ми почнемо з нуля, тому що пам'ятаєте, що 0 є першим елементом в масиві, а не 1.
Тоді у нас є умовний цикл. Отже ми введемо "while(friendNum < my friends.length)".
Тоді, поточну змінну лічильника порівняємо з загальною кількостю речей в масиві
всередині циклу де ми використовуємо нашу текствову команду.
Отже, введемо:"text(myFriends[" а тоді тут замість числа, поставимо "friendNum"
так як"friendNum" відображає поточне чилсо
І тоді ми встановимо одну позицію зараз.
Це дало нам нескінченну помилку циклу, так як ми нічого не змінили в friendNum.
Пам'ятайте, що нам потрібно збільшувати friendNum кожен раз, інакше цикл триватиме
вічно, тому що ця умова завжди істинна.
Бачу трапилось щось. Я закоментую старий код, і я побачу, що сталося.
Зараз ми маємо те, що показали всі імена, але вони всі один на одному.
Отже, нам потрібно змінити свою позицію у. тому просто введемо 'friendNum*30'
Добре, але Софія за екраном і вона не буде дуже радою дізнавшись про це.
Отже, просто додамо 30 до цього. І тепер всі вони зміщуються на 30.
Гарно! Так що тепер ви бачите, що у нас є цикл, що відображає наш масив.
І це означає, що якщо ми додамо більше таких людей, як OhNoEsGuy, або можливо
навіть Сал і якщо просто додати його в масив, то він буде моїм другом.
Відмінно! Тепер він мій приятель.
Бачите, що він просто автоматично показує нових друзів, так як це завжди проходить
через весь масив.
Отже, ми можемо видалити наш старий код. Нам він більше не потрібний
І давайте просто переглянемо цей код тут і подивимось, що він робить.
Таким чином, ми починаємо "friendNum" рівне нулю.
Ми перевіряємо, чи friendNum менше поточної довжини.
Таким чином, уявіть собі, що 0 менше 6 Це істина.
І тоді всередині тут, ми ввели text, my freinds friendNum.
І це стане нулем, в перший раз. А потім 30 плюс нуль помножити на 30.
Код відображає Софію в 10 і 30. Ось що він робить. А тоді FriendNum ++. стає 1.
Потім він йде назад знову і каже: "Добре, чи 1 менше, ніж myFriends.length? Звісно"
І так продовжується далі і далі і далі.
Ми нарешті добрались до Сал. Пам'ятайте, що насправді Сал шостий елемент в масиві,
але його показник 5, так як ми починаємо з нуля. Отже, п'ять менше за шість? Звісно
Так що він відображає myFriends 5
І тоді стає шість, і ми говоримо, "шість менше, ніж шість?" Ні. рівні.
І це буде не істинною. Так що ми ніколи не покажемо шостий елемент,
це добре, так як немає нічого в індексі шість.
Є шостий елемент, але нічого в індексі 6.
це можливо досить заплутано, щодо 1 та 0 і робити все це, але ви впораєтесь з цим.
Гаразд. Отже, це наш цикл.
Тепер, якщо хочете, можете використовувати цикл for, якщо ви віддаєте перевагу їм.
Для циклу for введемо 'for,' а потім 'var friendNum = 0;' і тоді матимемо нашу умову
'friendNum < myFriends.length'
а потім наше зростання: 'friendNum++'
І потім всередині циклу for ми можемо просто поставити саме цей рядок коду сюди.
І я просто зміню "x" щоб ви побачили Він робить точно те ж саме.
Отже, це залижить від вас, який з них ви використовуєте, але справа в тому, щоб
використовувати цикл з масивами, тому що це зробить вас дуже могутніми.
Ta cùng quay lại với chương trình mảng về bạn bè của tôi.
Có một điều khiến tôi cảm thấy rất khó chịu.
Mỗi khi thêm một người bạn mới vào mảng, tôi lại phải thêm một lệnh text ở dưới đây.
Giả sử tôi thêm Winston.
Cậu ta không tự động hiển thị đâu.
Nếu tôi muốn cậu ta hiển thị, tôi phải nhập text(myFriends[3], sau đó thay đổi vị trí y và ta sẽ nhìn thấy Winston.
Quá nhiều thứ phải làm.
Tôi chỉ muốn mỗi lần thêm ai đso vào mảng, lệnh văn bản sẽ tự động được nhập.
Các bạn có nhớ những gì đã học về vòng lặp không?
Đó là phương pháp lặp mã liên tục rất hiệu quả.
Giống như khi ta muốn có một hàng cây hay một chùm bóng.
Hóa ra, vòng lặp còn rất hữu ích trong việc chạy một đoạn mã trên từng phần tử trong một mảng.
Trên thực tế, hầu như mỗi khi sử dụng mảng, ta đều phải sử dụng vòng lặp. Chúng phối hợp với nhau rất tốt.
Ta hãy sử dụng vòng lặp để hiển thị tên bạn bè của tôi, thay vì phải nhập toàn bộ chỗ lệnh văn bản này, để cho các bạn thấy ý đồ của tôi.
Ta sẽ bắt đầu với ba câu hỏi mà ta thường tự đặt ra khi tạo vòng lặp.
Thứ nhất, tôi muốn lặp cái gì? Hãy nhìn lên đây. Cái gì đang được lặp lại? Lệnh text.
Mỗi lần lặp tôi muốn thay đổi cái gì? Ta cùng quan sát và xem có gì khác biệt. Vị trí y và chỉ số hiện tại, đúng không? Vậy là friendNum và vị trí y.
Và ta nên lặp trong bao lâu? Ta sẽ lặp cho tới khi không còn bạn bè để lặp nữa.
Sau khi đã xác định được những gì mình cần, ta có thể tiến hành tạo vòng lặp.
Trước hết ta tạo một biến đếm để theo dõi vị trí của mình trong vòng lặp. Ta nhập var friendNum = 0.
Ta sẽ bắt đầu với số 0 vì 0 là phần tử đầu tiên trong mảng, không phải 1.
Sau đó ta tạo vòng lặp while. Ta nhập while(friendNum < myfriends.length).
Ta sẽ so sánh biến đếm hiện tại với tổng số phần tử trong mảng.
Và áp dụng lệnh văn bản trong vòng lặp.
Ta nhập text(myFriends[ - và tại vị trí này, thay vì số, ta sẽ nhập friendNum vì friendNum thể hiện số bạn bè hiện tại.
Bây giờ ta sẽ chỉ thêm một vị trí thôi.
Ta đang mắc phải lỗi vòng lặp vô hạn vì ta chưa thay đổi friendNum.
Hãy nhớ rằng, mỗi lần lặp ta đều phải gia tăng friendNum, nếu không vòng lặp sẽ chạy mãi mãi vì điều kiện luôn luôn đúng.
Tôi thấy có điều gì đó ở đây. Tôi sẽ chú thích mã cũ để có thể hiểu được chuyện gì vừa xảy ra.
Ta đã hiện thị toàn bộ tên rồi, nhưng chúng đang chồng chéo lên nhau.
Vì vậy ta cần phải thay đổi vị trí y.
Ta nhập friendNum*30.
Vậy là tốt rồi nhưng Sophia đang bị ra khỏi màn hình và sẽ không vui tí nào nếu biết đâu.
Ta phải thêm 30 vào biến. Giờ thì tên sẽ hiển thị từ 30 trở đi.
Đẹp rồi đấy! Hiện tại ta đã có một vòng lặp hiển thị mảng.
Điều đó có nghĩa là khi ta thêm người, ví dụ như ông OhNoes kia, hay thậm chí Sal, vào mảng thì Sal sẽ trở thành bạn của tôi. Tuyệt vời!
Các bạn có thể thấy tên mới sẽ tự động được hiển thị vì vòng lặp luôn luôn rà lại toàn bộ mảng.
Vậy là ta có thể xóa mã được rồi. Nó không cần thiết nữa.
Ta cùng xem lại mã này một chút nhé.
Ta bắt đầu với friendNum = 0.
Ta sẽ kiểm tra xem liệu friendNum có nhỏ hơn độ dài hiện tại không.
0 nhỏ hơn 6. Như vậy điều kiện đúng.
Sau đó ta nhập vào bên trong, text myFriends friendNum.
Lần đầu tiên sẽ là số 0.
Sau đó 30 + 0 * 30.
Sophia sẽ được hiển thị tại vị trí 10 và 30. Đó chính là chức năng của đoạn mã này.
Tiếp theo là friendNum ++. Sau đó tới phần tử 1.
Đoạn mã sẽ lại quay lại từ đầu và tự hỏi, “OK, 1 có nhỏ hơn 6 không? Có”.
Rồi cứ thế liên tục.
Và cuối cùng ta có Sal. Hãy nhớ rằng, Sal là phần tử thứ 6 trong mảng, nhưng chỉ số lại là 5, vì ta bắt đầu từ 0.
Vậy 5 có nhỏ hơn 6 không? Có.
Ta hiển thị myFriends 5.
Sau đó biến tăng lên 6 và ta lại hỏi, “6 có nhỏ hơn 6 không?” Không, nó bằng nhau.
Vây điều kiện sai. Máy tính sẽ không hiển thị phần tử thứ 6,
cũng tốt vì chẳng có gì ở chỉ số 6 cả.
Ta có phần tử thứ 6, nhưng không có chỉ số 6.
Chuyện 0 và 1 có thể khá khó hiểu, nhưng dần dần bạn sẽ quen thôi.
Được rồi, vậy đó chính là vòng lặp.
Bây giờ, nếu muốn, các bạn cũng có thể sử dụng vòng lặp for nếu thích vòng lặp for hơn.
Đối với vòng lặp for, ta sẽ nhập for, sau đó var friendNum = 0, kế đến là điều kiện
'friendNum < myFriends.length'
và gia số friendNum ++,
rồi ta có thể đưa dòng mã này vào bên trong vòng lặp for.
Tôi sẽ thay đổi x để các bạn thấy
quy trình giống y hêt. Sử dụng vòng lặp nào là tùy thuộc vào bạn, tôi chỉ nhấn mạnh nên sử dụng vòng lặp khi làm việc với mảng vì nó cực kỳ hiệu quả.
我們回到那顯示我的陣列 (array) 朋友的程式
但是有一些事真的惹惱了我
每次我添加一個新朋友到陣列中 都要補充
一個新的文字命令 (text command) 到這裡
假設我加了溫斯頓
他不會自動顯示出來
如果我要他露面 我得說 text(myFriends[3],
然後更改位置 y 才可以看到溫斯頓
這實在是很麻煩
我希望每次加入別人到陣列時 他都會自動顯示出來
程式會自動做那個文字命令
好了 還記得我們學過迴圈嗎？
迴圈是個偉大的方式 可以多次重複相同的代碼
就像 如果我們想要有連續的一堆樹木 或一串氣球
事實證明 迴圈也是陣列的元素上運行代碼中 很棒的方式
事實上 每次使用陣列時 你幾乎都會用到迴圈
他們一起工作真的很配
為了讓你明白我的意思 我不用文字命令
而是用一個迴圈 來顯示我朋友名字
我們將從三個問題開始 當我們做迴圈時 總是會問自己
首先 我想重複的是什麼？ 看過內容後，什麼是重複的？
就是文字命令 (text command)
我每次想改變什麼？ 就讓我看看有什麼不同
位置 y 和當前的索引指數 (index) ，是吧？
就是 NUM 這位朋友和位置 y
那我們應該重複多久？
繼續下去 直到沒有其它朋友
好 現在我們知道想要什麼 可以做個迴圈
我們從計數器變量 (counter variable) 開始追蹤迴圈位置
所以我們說 var friendNum = 0;
計數從零開始 因為 0 是陣列中的第一個元素
1 不是第一個元素
我們有 while 迴圈 所以我們說 while(friendNum < my friends.length)
現在我們要比較 當下計數器變量與陣列中元素的總數
迴圈中 這裡是使用文字命令處
我們說 text(myFriends[
而這裡我們放 friendNum 不放數字 因為 friendNum 代表當前的數量
我們目前為止只放一個位置 y
OK 這給了我們一個無限迴圈的錯誤
因為我們還沒有改變 friendNum
請記住 每次迴圈都需要遞增 friendNum
否則條件為真 迴圈會永遠繼續下去
我看到某些事情發生了 讓我註釋掉舊代碼 看看發生了什麼事
我們想現出所有的名字 但是他們都被蓋掉了
因此 我們需要改變位置 y
讓我們就說 'friendNum*30'
這很好 但索菲亞關閉銀幕
索菲亞如果發現了這一點 她會很不高興
那就讓我們加 30 現在全部都差距 30
好棒！現在你看 我們有顯示陣列的迴圈
這意味著如果我們增加更多的人 像是蓋伊 或者是薩爾 Sal
如果我只加 薩爾 Sal 到陣列 薩爾他會成為我的朋友
真棒！現在 他是我哥們了
呃... 你可以看到 新朋友是自動顯示
因為它始終排在陣列裡
我們可以刪除舊代碼 因為不再需要它
我們檢視整個代碼 並查看它是在做什麼
我們從 friendNum 等於零開始
我們檢查看看 friendNum 是否小於當前長度
你可以想像 0 比 6 小 確實如此
於是 我們從這裡進去 我們說 我的朋友 friendNum
所以這將是我的第零個朋友 第一次
然後 30 加上 0 乘以 30
它顯示索菲亞在位置 10 和 30 上 就是這樣的
然後用 friendNum ++ 於是 friendNum 就變成 1
然後它返回說： 1 比 myfriends.length 的長度小嗎？
是啊 沒錯
迴圈這樣一直保持下去...
最後我們來到薩爾 記住 薩爾在陣列中其實是第六元素
但他的索引指數 (index) 是 5 因為指數從零開始
那麼 5 比 6 小？是
因此 顯示 myfriends 等於 5
然後 它變成 6 我們問 6 比 6 小嗎？
錯！ 6 等於 6 因此這是錯誤的
因此 它永遠不會顯示第六個元素
這很好 因為指數 6 沒有任何人
有第六元素 但沒有人在指數六
這可能令人混淆 他是 0 也是 1
但你終究會領悟的
好吧 這就是我們的迴圈
現在 如果你願意嘗試使用迴圈 可使用 for 迴圈
前提是你想從 for 迴圈開始嘗試
有關 for 迴圈 我們說 for var friendNum = 0;
然後有 friendNum < myFriends.length 這個條件
然後我們增量：friendNum ++
for 迴圈中 我們可以把剛才那行代碼放在這裡
我只是改變 x 可以看到 for 迴圈是完全一樣的東西
取決於你使用哪一種迴圈 重點是 把迴圈用於陣列
因為它會讓你變得很厲害