将 Let 变量声明与 With 语句一起使用

Question

I read about with statement from Ecma Specification and in there with statement evaluation like this.

1. Let val be the result of evaluating Expression.
2. Let obj be? ToObject(? GetValue(val)).
3. Let oldEnv be the running execution context's LexicalEnvironment.
4. Let newEnv be NewObjectEnvironment(obj, oldEnv).
5. Set the withEnvironment flag of newEnv's EnvironmentRecord to true.
6. Set the running execution context's LexicalEnvironment to newEnv.
7. Let C be the result of evaluating Statement.
8. Set the running execution context's LexicalEnvironment to oldEnv.
9. Return Completion(UpdateEmpty(C, undefined)).

If with statement use Lexical Environment for evaluation why my sample code not work?

const user = {
   fullName: "Murad Sofiyev"
};
with(user) {
    let firstName = "Tofiq";
    fullName = "Tofiq Sofiyev";
}

console.log(user.firstName); // Undefined
console.log(user.fullName); // Tofiq Sofiyev

PS: I know with statement is deprecetaed but this is help me to understand Lexical Environment and Variable Environment:)

Answer 1

The { following the with(user) creates an entirely new LexicalEnvironment. There are actually two environments created there: the environment for the with 'd object, and the environment for the new { block. When you use let firstName = "Tofiq"; , you're creating a new variable name inside the inner (block-scoped) environment.

This might be a bit more obvious if you can see that you can use with without a paired { :

 const user = { firstName: 'foo', }; with(user); console.log('Not a syntax error');

Here, the environment created by the with 'd value is created, and goes completely unused. (and there's no inner environment).

Another issue is that firstName doesn't exist on the object. If the object had the firstName property and you used var instead of let , the new Tofiq would be assigned to the object.

 const user = { firstName: 'foo', }; with(user) { var firstName = "Tofiq"; } console.log(user.firstName); // Tofiq // because var is not block-scoped // so `var firstName` finds an outer Lexical Environment with that same variable name

Answer 2

Using let always creates a variable in block scope. So even though you use it inside the with block, it is creating a new variable scope to the with . You might want that behaviour if you needed to do some calculations inside the block.