Open your examples folder, and then open the block scope sub folder. Let's look at block scope example one. So here I've got this global variable i, which is equal to 100. And then I've got a block of code here. And inside the block, I output the value of i. And then outside of the block I put up with devalue by again, let's look at block example.

So I see 100, twice for A and B. And that makes sense, because I'm not actually doing anything too special here. I'm just outputting the value of i twice once once in the block, and once outside of the block. My point here is that because I didn't do anything special inside the block, I is still 100. So let's look at block example number two. I've got a global variable called I, which is equal to 100.

But then inside of my block, I've got a block level scope variable i which is equal to 50 and output that in the console. So this version of it is different than this version of I, because this one is has block level scope, it's actually scoped just to this block. So I equals 50 in the block, but I was 100 outside of the block. So when I look at block scope, Example two, I get 50 and 100. So the main point here is we're using the let keyword to create a block level scope. variable, which does not conflict with the global one because it's scoped here to the block.

Let's look at block scope example three. So here I do pretty much the exact same thing but instead of using the let keyword, I use the constant keyword to create this block scoped variable i. So if I execute blocks, example three, same thing 15 100 open block scope example number four. So here are two global variables I nj. I start to Zero and j starts at 100. I have a for loop.

And in the for loop, I increment i, but I also increment J. So what we should wind up with is a loop where the console outputs are equal to zero, and one 101 101 202, and so forth. Let's take a look at blocks go example four. And that's what we wind up with. So the point I'm making here is that we're not leveraging block scope here, we're incrementing i n j inside of the block cost. Let's see if we can fix that.

Example five, what we do is, it's very similar, except that inside of our block, we set j to be scoped just to this block. So now j is equal to 50. And we increment J. So what we're going to wind up with is a loop where the console outputs are zero 51 151 two 51 351 and so forth, because on every iteration of the loop, we're setting a new variable that scoped just to this block and incrementing it just one. So if we go to blocks go example five, that's a we get zero 51 151 to 51. Just illustrating that j is scoped to this block.

And every on every iteration of lock, we get a new version of J, we're creating a new version of j using the let keyword. And it's scoped just to this block, whereas AI is scoped globally. So it changed on every iteration. Also get block scope, example six. Here, we're doing the exact same thing. Only we're defining j with the const keyword instead of the let keyword.

But this will be a problem. Because with the const keyword, we can't overwrite the value that we create. Once we create Free Ha. And say it's equal to a, we can't turn around and say j is equal to P, because with the const keyword, we're creating a constant. So this attempt to increment j will throw a typer. Let's look at example number six.

Block scope. Example number six, you can see uncaught type error assignment to constant variable. So what that saying is, hey, you created a constant here, and then you turned around and try to change it, we can't do that. So the const keyword works the same way as let keyword it creates a block level scoped variable. But once you create that variable, you can't change it, you can't override it. So if we look at block scope, example seven, we do pretty much the same thing.

But we don't try to change j, we just leave it the way it is. So we'll get the console output of zero, 5152 5350, and so forth. So we're going to show examples block scope seven, and exactly what we do. Get to 5152 50. And that's because we create the block level j, l variable, which is equal to 50. And it's fine.

It's now j does not conflict conflict with this version of J. That's global, but we just don't change it. So the thing to remember about letting const is that with lead, you can create a variable that has block level scope, and you can change it. Whereas with const you can't change it. Once you create it, you must leave it alone. It's a constant, but both let and const create block level scoped variables.