Instructor: Let's now explore some more features
of the for loop
and also create a somewhat more useful example.
And one of the most used applications
of for loops is to loop through a race.
So let's get back the array that we were using before.
So where is that?
So, I mean the one
where we talked about objects.
Yeah, this one.
So go to this lecture about introduction to objects
and then grab this Jonas array.
And maybe you didn't write it back then
but then you can just write it, right now.
Okay, and so now we can use a for loop
to loop through this array.
And let's say for now that we wanted to individually
log every element of the array to the console.
So very simple.
All we want to do is to log these five elements here.
So let's write a for loop.
And as always, we start with the counter.
So let...
And now a traditional counter variable name has been I
for a long time.
And so let's use that here as well.
So just I, and this time we need to start it at zero.
And that's because the array is zero based
when it comes to reading elements out of the array.
Remember, and this will make sense once we actually write
the code of this loop.
Let's now actually skip the condition for now.
So we're gonna deal with that a little bit later.
And so now updating the counter
is gonna work exactly the same as before.
So since we want to log all of the elements
we need to update the counter variable simply by one.
And so again, we use ++, okay.
And now let's write or loop here itself.
So console.log,
and remember all we want to log to the console
is each element of the array.
And so without a loop
we would write that like this,
so Jonas zero.
Right?
And then let's do that outside.
So we would do this
this, and then all the way to
number four.
All right.
So let's comment is out
but this is helpful to see what kind of code
we want to achieve.
So again, we want to start at Jonas zero
which is the first element.
Jonas one is this one, then two, three, and four.
And so that's the reason why we started the counter at zero
because that's the first element that we want to get.
It's Jonas zero.
And so here, instead of hard coding to zero,
of course, we are going to use or counter variable.
So, and that's I.
And now the trickiest part here, is the condition.
And so that's why we left it for the end,
but now we need to actually tackle it.
So for how long do we want to keep this loop running?
Well, it should run when I is zero.
Right?
It should also run when it's one two, three, and four.
Because four is the last element.
But when it's five, it's no longer run.
Right?
And that's because Jonas at five does not exist.
Let's just write that,
does not exist.
And so that means that the I counter variable
should always stay below five.
So let's write that here.
So I should stay
below five.
And so with this,
as soon as the counter variable is updated to five
then the next iteration of the loop will not run anymore.
So let's try this.
And here it's of course not Jonas
it's Jonas array.
So let's actually change the name up here,
in the array itself.
Try that again.
And yeah, we get a log of each of the elements
in the array.
So all of the five of them.
Great.
But there's actually still one problem with this,
which is that we hard-coded the length of the array
here with five.
So let's now say
that we add another element,
let's say just true.
And so if we try this now,
do you think that's true will be logged here as well?
Well, it will not.
Because of course we are still telling JavaScript
that I should stay below five.
And so it will not print the array at position number five,
which does now exist.
So now we do have Jonas at position five, right?
And so the solution to this,
is to not hard code the value here
but to compute this value.
So basically to get it from JavaScript itself.
And how can we get this number?
Well, actually this five is simply the length of the array
right?
Not of this one anymore, but off the original one.
So this array has a length of five.
And so five is exactly the number that we put here.
And so we can simply replace the hard-coded value
with a dynamically calculated one.
and that's Jonas.length.
Remember?
So,
let's try that.
And indeed it still works.
And if I now go back to adding something else
like true,
then Jonas.length
will now be six.
And that of course happens automatically.
And we don't have to manually change any code
in that loop.
So now we did true also appears here in our luck.
Great.
Let's now also log something else here.
Let's say the type of the variable.
So type of Jonas i.
And I hope that this part here makes sense.
So the fact that we're using the counter variable here
to retrieve all the elements of the array.
So now let's say, so string,
string, number, string, object.
So remember how I said that an array is in fact an object
and here we have the proof of that.
And then finally the last one is of course a boolean.
Okay.
So I hope that this logic here made sense.
And so this is in a nutshell,
how we loop race using the for loop.
Now, what we did here, was only to read values
from an array.
But now let's also at the same time,
create a new array which will contain
this type of each of the elements.
So basically this, all right?
So again, what I want to do now
is to create a new array which will contain all the types
for all these elements.
And if that sounds a little bit useless,
then just keep in mind that these are all just
educational exercises.
So I designed them to show you how these different features
of the language work.
So in real world, we would probably not create an array
with types of variables.
But this is excellent to show you,
how to create a new array based on the values
of one original array.
So to do that we start by creating
a new empty array outside of the loop.
And let's do that here, after this one.
So I will call this one types.
And now I think this is something we didn't do before,
which is to simply create an empty array.
And all we have to do is to basically create an array
with the usual syntax, but without any element inside of it.
And so now we have to go here to the same loop
because this new array types will be based
on the Jonas array.
So it's gonna have the same length.
And so we can use the exact same loop
that we used to read data from the Jonas loop
also to construct this new types array.
So let's say types,
at position I, should be equal to
type of Jonas
at position I.
And remember that this works
because we can essentially do this.
So we could do it again without the loop
and say types zero
is equals string.
So this would work, right?
And so of course it also works with the
index number here dynamically.
And so that's exactly what we're doing here
in the exact same way as we read data
from the Jonas array,
right?
So in iteration zero,
we will have type zero equals type of Jonas zero.
Then in the next iteration,
we will have types one
equals type of Jonas one
and then two, three, four, and five.
All right.
So just to see if that works
let's then log to the console,
this newly created
or to be more accurate, this newly filled array.
So let's see.
And indeed now we get this array
which has exactly the types that we can see here as well.
So string, string, number,
string, object, and boolean.
So these six that we also have here
which means that we achieved our goal here.
Now, this is just one way
of filling an array.
And let me write that down here,
filling the types array.
And here we do basically reading
from Jonas array.
But this is just one way of doing it.
So let's comment out this one
and do it in another way.
And do you remember how to add elements
to an array in another way?
Well, we could use the push method, right?
So that would be types.push.
And remember that push
adds a new element to the end of the array.
And so here, we now need to pass in the element
that we do want to add on to the array.
And so that's again
type of Jonas
at position I.
So off the current counter.
And so if we try this now again,
we should get to the same.
And it's important that we add the new element
to the end of array and not to the beginning.
So we really need to use pushier and not unshift.
So I think that this way of doing it here
is actually a little bit cleaner.
But if you prefer this first way here
then of course you can just use that one as well.
But what matters here,
is that we really understood the logic
of how to construct all the different parts of this for loop
in order to loop the array.
So it starts the counter being zero
because that's the first element of the array.
And then this condition here
which specifies that the current index always needs to stay
below the length of the array that we're looping through.
And then in the loop itself
we always get the current element using the current counter.
Which is gonna go from zero
to the length of the array minus one basically.
All right.
And to make sure we really get this
let's try another, maybe more practical example.
So let's go back to having an array of birth years.
So 1991,
2007,
let's say 1969
and 2020.
And now what we want to do is to calculate the ages
for all these four birth years here.
And we want to store them in a new array.
And that's a very common type of operation,
which we actually already did before
but without using loops.
So essentially that's what we did
in the tip calculator challenge.
So,
yeah, here.
So here we had an array of three bills
and then we manually calculated the tip for each of them.
So manually we specified index zero,
one and two,
and created a new array based on these values.
But in the real world, we would have used a loop to do that.
And so that's what we will do now.
Okay.
Just with another, a bit more simple example.
Years is the array which contains the birth years,
and now let's create another
and again, empty array, which will then hold the ages.
And so what we're gonna do now
is to loop through years and then fill up these ages array.
So four,
and then once more,
let's define the counter at zero
for the same reasons that we did it before.
And it's not a problem that discounter variable here
has exactly the same name.
Then the condition is also gonna be the same.
And actually the whole loop
always kind of looks the same,
when we loop over an array.
So now here the difference
is that it's of course, years.length.
And then at the end,
we as always increased the counter by one.
And now what we need to do is to calculate the age
of the current year.
So that's gonna be,
2037.
So as always that's the year that we're currently in,
let's say, and then minus the current birth here.
So how do we get that?
We say years, at the current loop position.
Okay?
So that's nothing new.
I hope now at this point, okay.
So we have this calculation now
and now we want to add it to this new empty array.
So we say we want to push it,
to that array.
And so we use the push method to do that.
So ages.push.
And so this is the value
that we want to push into this empty array.
And that's actually it.
So let's check it out in a console
and
here we go.
So just to confirm,
2037 minus 1991 is of course 46.
And that's just do it with 27 as well,
2007 I mean.
And so that's 30, which is this one.
And so this array result, is correct indeed.
So what we essentially did is this.
We cannot do an operations
between simple values and an array.
So that I showed you earlier, right?
We can not do 2037
minus the years array.
That will just give us not a number.
And so here in this loop,
we basically did it individually.
So we did to calculation one by one.
In each iteration of the loop
we calculated 2037
minus this year and then added it
to the first position in the ages array.
Then we did 2037 minus this
and put it at the end of the ages array again.
And then the same for this one and for 2020.
Great.
So that is a very very useful
and important application of the for loop.
And now to finish,
let's learn about two important statements
for loops.
And that's the continue and to break statement.
Let me just write that here,
continue and break.
And let's start with continue.
So continue is to exit the current iteration of the loop
and continue to the next one.
On the other hand, break is used
to completely terminate the whole loop.
So let's see two quick examples for that.
And let's go back to actually this loop
that we had here.
Where we looped this Jonas array.
So I will just copy this,
because we already learned how to loop through the array.
And now I'm just interested in showing you
how continue and to break a work.
So let me delete this
and this as well.
And now let's say that for some reason,
we only wanted to print elements to the array
that are strings.
And the continue statement is perfect for this.
Because again,
with continue we can exit the current iteration of the loop.
So what we can do here, is to say,
if the type of the current element
so of Jonas I,
is not a string,
then continue.
And so that's how we write the continue statement.
It's really just this continue keyword.
So again, what we want to do here,
is to only log strings to the console.
Which means that everything else,
should basically be skipped.
And that's what we do here.
So we say, if the type of the current element,
so that's this one here.
So if the type of the current element
is not a string then continue.
Which again means,
that the current iteration of the loop is exited,
and then the next one starts immediately.
So let's just write some other note here
to the console just so we know
what we're doing here, like
all the strings
because otherwise the output here
is gonna start to look a little bit confusing.
But anyway, let's test this now.
And indeed, we only get strings now.
So these three are strings
and all the other ones are not strings.
So this number, this array and this boolean,
so they will now not get printed.
Because we basically skipped them.
For example, that eight number,
which is 46 here.
So the third element, does have to type number here.
Right?
So it's not a string.
And so this year will be true
because of course number is different than string.
And so this is true.
And so this code here, will run.
And what continue will do
is that it will immediately exit the current iteration.
And so this line of code here,
will not be executed in the current iteration.
It will not even be reached.
Okay.
And now finally, let me just show you how break works.
And remember that what break does
is to completely terminate the whole loop.
So not just the current iteration.
So what we want to do now, is to log no other elements
after we found a number.
So essentially after a number is found
which will be this 46 here,
nothing else should be printed.
So let's do that.
And i will again, copy all of this.
And so let's say here
break
with number.
So let's translate a logic that we just said into the code.
So as soon as a number is found,
we want to break the loop.
So, our if condition here should be
type of Jonas I,
so the current element,
if it's equal to a number,
so now that's number then break.
Now, okay.
Let's see the result here.
And indeed, that's exactly what we wanted.
So after the first number is found
which is this 46 here,
nothing else is printed.
So in this iteration where the number is found
not even this line of code is printed anymore
and then the loop is terminated completely.
All right.
Now this might not sound very practical,
but believe me there are some important use cases
for continue and break.
It's just hard to create some small and isolated
code examples to show you just how useful they can be.
But anyway I wanted to let you know
that continue and break exist.
But the most important takeaway from this lecture,
is definitely to understand,
how we can loop through a race
using this kind of logic here.
Okay, so this one here is really important
that you understand this snippet of code.