CODEWITHSUNDEEP
javascriptlexical-scope
John bracciano
John bracciano

Reputation: 81

Learning JavaScript: Lexical Versus Dynamic Scoping

So I was reading this book, following along with the code examples and running them using node console. In Chapter 7, paragraph 'Lexical Versus Dynamic Scoping', the author claims that the following code will result in an error:

const x = 3;
function f() {
    console.log(x); // this will work
    console.log(y); // this will cause a crash
}

const y = 3;
f();

This is due to the fact that (as the book reads)

Scoping in JavaScript is lexical...

and

Lexical scoping means whatever variables are in scope where you define a function from (as opposed to when you call it) are in scope in the function.

However this code runs just fine, and produces the following output:

3

3

I have searched for other examples of lexical scoping and what it means, but they all seem to suggest slightly different things from what the book says. So I am left wondering, is the explanation in the book completely wrong or am I missing something very basic?

Upvotes: 2

Views: 660

Answers (3)

Dong Nguyen
Dong Nguyen

Reputation: 1269

This book looks quite old - 11 years ago. The world is no longer the same. Now we see that JavaScript changes day after day. I think that we should not use any book produced since 2 years ago.

The problem you (and the book) mentioned is relating to another concept: strict mode. In ECMAScript 5, you can turn on this mode by adding "use strict" on top of your JavaScript file. So that, you would see some errors throw while they don't in regular mode. If you want to get the example works, you may need to find an old browser, IE8 or such - I'm not sure, then create a HTML file, then add your script to, then turn on strict mode, it may give you the same result as the author said.

Strict mode is no longer the case in JavaScript today - I would like to talk about ECMAScript 6, or ES6, or ECMAScript 2015. We simple don't need to care about strict mode while writing JavaScript now. I have many module on npmjs.org but none of them have "use strict" declaration at all.

Just my two cents: in programming, don't read old books, because everything changes so fast.

Upvotes: 1

Rajat Sharma
Rajat Sharma

Reputation: 839

The above code will work fine. However, this will fail.

const x = 3;
function f() {
    console.log(x); // this will work
    console.log(y); // this will cause a crash
}
f();
const y = 3;

That is because y is not yet declared or defined at the time of function invocation and

x is accessible because Scoping is lexical and function will access the x defined in global scope, if not found on local.

This can be understood by this example more clearly

function b(){
  console.log(v) //=> 1
} //lexically defined at global scope

function a(){
  var v = 2
  console.log(v) //=> 2
  b() //called in the scope of a()
}

var v = 1
a()
console.log(v) //=> 1

console.log in b() will give 1 because according to lexical global scope v = 1. But according to Dynamic Scope (created by a()) it should be 2, which is not the case.

Hope this helps :)

Upvotes: 2

Quentin
Quentin

Reputation: 944445

The quoted description…

Lexical scoping means whatever variables are in scope where you define a function from (as opposed to when you call it) are in scope in the function.

… is correct.

The code example is wrong. The function f has access to any variable (or constant) that exists in the scope that it is declared in. What the book appears to get wrong is that constants can be added to that scope after the function has been declared.

Where the function is declared matters. When it is declared, not so much.

Upvotes: 3

Related Questions