Any variable (var, let or const) declared outside of functions or any block of code (not within curly brackets { }) is global scope. This isn't the case since modules also define their own, non-global scope. Any declarations outside of functions or blocks in a module are part of that module scope, not global. More on reddit.com

But can't let be considered global too? Yes. If declared in the global scope, let and const (and class) will also create global declarations. So the table is incorrect in that sense. Where this gets confusing is, unlike var and function, when let, const, and class are used in the global scope, they do not create global properties, whereas var and function do. var x = 1 let y = 2 console.log(globalThis.x) // 1 console.log(globalThis.y) // undefined This doesn't mean let, etc. are not defined in global, they just don't also exist as properties on the global object. This is possible because global scope has two buckets: an object record (global object and its properties) and a declarative record (declarations not in global object). Definitions in both contribute to those values which are globally available. So in the above example, var x is put into global's object record and let y is placed into the declarative record. What's nice about the declarative record is that it prevents collisions with properties of the global object. This can be especially important on the web as the global object is also the window object with many window-specific properties like name. If you've ever tried to create a name var in the global scope on the web, you may have noticed some problems. var foo = {} console.log(foo) // {} var name = {} console.log(name) // [object Object] What happens here is, var name ends up assigning to the pre-existing window.name property which will stringify values on assignment. The result is that the original object is lost and you're left with its string representation of "[object Object]". foo escapes this fate because it does not already exist on window. Variables defined in the declarative record do not have this problem. let name = {} console.log(name) // {} console.log(window.name) // '' or whatever the window name is In this case, our let name declaration is placed in the declarative record separate from the object record allowing it to coexist with the name property. The declarative record is checked first when referring to global variables by name so checking for just name gives us our declared value. For the object value, you can go directly through the global object accessing it as a property seen here with window.name. Where even if you declare the variable in block statement, it will automatically set it to globabal variable? This will only be the case if you use a non-block scoped declaration with a block statement in the global scope... and that can actually depend on strict mode too. Normal block-scoped declarations in a block do not become global. They're scoped to the block. let x // global { let y // block scoped, not global } Because var isn't block scoped, it will always create a global if in the global scope var x // global { var y // also global } If anywhere in your code - in global, in a block, in a function... - you assign a value to an undeclared variable, that will create a new global property. This isn't a declaration at this point, just an assignment, and if there is no variable of that name in scope, it defaults to assigning a global. function foo () { // function scope { // block scope x = 1 } } foo() console.log(x) // 1 This does not work in strict mode. Strict mode enforces assignments are to valid declarations (or global properties). So instead, an error is thrown. "use strict" function foo () { // function scope { // block scope x = 1 // Error! Does not exist } } foo() Strict mode also has an effect on function declarations making them block-scoped. Not var, only functions. So whereas normally a function in a block in the global scope would be global { function foo () { console.log('foo called') } } foo() // foo called In strict mode, the function would instead be scoped to that block and not be accessible as a global (or in the parent function scope if in a function) "use strict" { function foo () { console.log('foo called') } } foo() // Error! Does not exist So yeah, scope can be a little tricky in JS ;) More on reddit.com

Can someone explain how variable scope works in JavaScript? Do variables maintain the same scope when they are inside or outside of a function? Is this distinction important? Additionally, when variables are declared globally, where is their storage located? More on community.latenode.com

As a Python developer, I hate it too. I'd rate it as one of the biggest warts in the language ( here's a bunch of other warts ). It bites me the most often when creating lambdas inside a loop: fns = [] for i in range(5): fns.append(lambda: i) for fn in fns: print(fn()) # Prints "5" 5 times. The "fix" is to use lambda i=i: i, so that it binds the value to a new locally scoped variable with the same name. The current scoping rules do have their advantages: for i in range(100): pass # Print the last loop value: print(i) But I'd still rather have block-scoped names. More on reddit.com