Исполняемый код и контекст исполнения в JS

bar() { foo(); console.log(a); var a = 6; }
bar();

{ var x = 20; console.log(x); // 20 foo(); // 10 } bar();

x = 10;
procedure foo() print(x) end
foo() // 10
procedure bar() x = 20 foo() // 20 end
bar()

Статическая область видимости:

Динамическая область видимости:

и функциями;
Связано с синтаксической структурой кода, такой как FunctionDeclaration, BlockStatement, Catch и TryStatement;
Состоит из записи окружения и ссылки на внешнее лексическое окружение;

{
environmentRecord: {
Object: function,
// etc ...
x: 10
},
outer: null
};
fooEnvironment = {
environmentRecord: {
y: 20
},
outer: globalEnvironment
};

y = 20;
console.log(x + y); // 30
}
function baz() {
var z = 30;
console.log(x + y); // 40
}
}

fooEnvironment = {
environmentRecord: {x: 10},
outer: globalEnvironment
};
barEnvironment = {
environmentRecord: {y: 20},
outer: fooEnvironment
};
bazEnvironment = {
environmentRecord: {z: 30},
outer: fooEnvironment
};

ECMAScript, содержащей объявления переменных, констант, let, class, module, import и / или функций. Декларативная запись среды связывает набор идентификаторов, определенных объявлениями, содержащимися в его области.)
Объектные записи
Запись объектной среды используется для определения связи переменных и функций, появившихся в глобальном контексте и внутри with-операторов.

c() {}
}

environment = {
// storage
environmentRecord: {
type: "declarative",
a: <...>,
b: <...>,
c: <...>
},
// reference to the parent environment
outer: <...>
};

30}) {
console.log(a + b); // 50
}
console.log(a + b); // 30, restored

context.lexicalEnv = {
environmentRecord: {a: 10, b: 20},
outer: null
};
previousEnv = context.lexicalEnv;
withEnv = {
environmentRecord: {a: 30},
outer: context.lexicalEnv
};
context.lexicalEnv = withEnv;
context.lexicalEnv = previousEnv;

VariableEnvironment: { ... },
LexicalEnvironment: { ... },
}

формой вызова функции

var foo = {
bar: function () {
console.log(this);
};
};

foo.bar();// "this" === "foo"
var bar = foo.bar;
bar();// "this" === global
this.bar();// "this" === global
bar.prototype.constructor();// "this" === "bar.prototype"
// --- non-Reference cases ---
(foo.bar = foo.bar)();// "this" === "global" or "undefined"
(foo.bar || foo.bar)();// "this" === "global" or "undefined"
(function () {this;})();//"this" === "global" || "undefined"

environmentRecord: {
arguments: {0: 10, length: 1, callee: foo},
a: 10,
b: 20
},
outer: globalEnvironment
};

var bar = function () {
console.log(a);
};
foo(); // 10, from VariableEnv
bar(); // 20, from LexicalEnv
}
foo(); // 10
bar(); // still 20

foo.[[Scope]] = globalContext.[[VariableEnvironment]];
// "with"
previousEnvironment = globalContext.[[LexicalEnvironment]];
globalContext.[[LexicalEnvironment]] = {
environmentRecord: {a: 20},
outer: previousEnvironment
};
// "bar" is created
bar.[[Scope]] = globalContext.[[LexicalEnvironment]];
// "with" is completed, restore the environment
globalContext.[[LexicalEnvironment]] = previousEnvironment;

компонента в текущем контексте выполнения

function resolveIdentifier(lexicalEnvironment, identifier) {
// если метод вызван из конечного окружения, переменной нет
if (lexicalEnvironment == null) {
throw ReferenceError(identifier + " is not defined");
}
// если значение найдено, возвращаем его Reference
if (lexicalEnvironment.hasBinding(identifier)) {
return new Reference(lexicalEnvironment, identifier);
}
return resolveIdentifier(lexicalEnvironment.outer, identifier);
}

{
var c = 30;
console.log(a + b + c); // 60
})();
})();

resolveIdentifier(bar.[[LexicalEnvironment]], "a") ->
-- bar.[[LexicalEnvironment]] - not found,
-- bar.[[LexicalEnvironment]].outer ->
foo.[[LexicalEnvironment]]) -> not found
-- bar.[[LexicalEnvironment]].outer.outer ->
found reference, value 10