Подтвердить что ты не робот

Что такое "Контекст выполнения" в JavaScript?

Мой заголовок в значительной степени суммирует все.

Может кто-нибудь просветить меня...

"Что такое" Контекст выполнения "в JavaScript?"

и о том, как это относится к этому: "подъем, прототип цепочки, объем и сбор мусора"

4b9b3361

ОТВЕТЫ

Ответ 1

Вы спрашиваете о нескольких разных понятиях, которые не очень тесно связаны. Я попытаюсь кратко остановиться на каждом из них.

Контекст выполнения - это понятие в спецификации языка, которое в условиях неспециалиста — грубо приравнивается к "среде", в которой выполняется функция; то есть переменная область (и цепочка областей видимости, переменные в замыканиях из внешних областей), аргументы функции и значение объекта this.

Стек вызовов представляет собой набор контекстов выполнения.

См. также этот ответ и в этой статье.

Область действия буквально такова: область, в которой доступна переменная. Упрощенно:

var x;

function a() {
    var y;
}

x можно получить из любого места. Когда вызывается a, x будет во внешней области. (Сохраняется в цепочке областей.)

Напротив, y может быть доступен только кодом в a(), поскольку он ограничен областью a. Это ключевое слово var: ограничивает переменную локальной областью. Если мы опустим var, y попадет в глобальную область, обычно считается плохой.

Думайте о подъеме, как о компиляции. В JavaScript функции объявления "поднимаются" вверху области. Другими словами, они анализируются и оцениваются перед любым другим кодом. (Это противоречит выражениям , которые вычисляются inline.) Рассмотрим следующее:

a();
b();

function a() { }
var b = function() { }

Вызов a() будет успешным, потому что его объявление было поднято вверх; a было назначено автоматически до начала выполнения программы. Вызов b() приведет к ошибке с TypeError, потому что b не будет определен до строки 4.

Ответ 2

Вы задали так много понятий, но давайте выберем одно за другим и поймем их.

Среда, в которой работает ваш код - это Execution context. Он создается, когда ваш код выполняется.

Execution Context (Global), созданный JS Engine, содержит для вас 3 важных момента:

  1. Глобальный объект - window
  2. Специальный объект this
  3. Ссылка на внешнюю среду

Давайте рассмотрим простой пример, чтобы понять Global Execution Context:

var a = "Hello World";

function b(){

}

Когда JS Engine выполняет этот код выше, он создает следующий контекст выполнения (показанный на рисунке): Глобальный контекст выполнения

Теперь давайте посмотрим, как JS Engine создает Execution Context (тогда мы выкопаем и поймем подъем): рассмотрим этот сценарий:

b();
console.log(a);

var a = "Hello World!";
function b(){
    console.log("Called b!");
}

Я могу вызвать функцию b() даже если она будет объявлена позже. Это означает, что JS Engine делает что-то перед выполнением моего кода, давайте посмотрим, что:

JS Engine выполняет следующие два шага при выполнении любого кода:

ФАЗА СОЗДАНИЯ:

  • Разбор JS Engine - прогоняет ваш код и identifies variables & functions созданные кодом (которые будут использоваться на этапе выполнения)
  • Установка пространства памяти для переменных и функций - "Подъем"
  • Подъем - перед выполнением вашего кода JS Engine выделяет пространство памяти для Var & Func, используемого внутри кода. Эти переменные и функции составляют контекст выполнения любой функции, которая должна быть выполнена. Все переменные в JS изначально установлены как неопределенные.

ФАЗА исполнения: довольно просто понять,

  • Когда код выполняется построчно (через JS-интерпретатор), он может получить доступ к переменным, определенным в контексте выполнения.
  • назначение переменных выполняется на этом этапе

Новый контекст выполнения создается при каждом вызове функции

Стек контекста выполнения: что происходит при вызове функции:

function b(){

}

function a(){
    b();
}

a();

  • Теперь в первую очередь будет создан Global Execution Context (как описано выше)

  • затем начинается выполнение, и интерпретатор встречает call to function a(), и here a new execution context is created pushed on top EC Stack

    поэтому каждый раз, когда вы вызываете функцию, новый EC создается и помещается поверх стека EC.

  • так что теперь EC for a() CREATED интерпретатор будет выполнять код внутри a() построчно

  • затем intrepreeter встречает call to function b(), это создает другой EC который помещается сверху или стек EC

  • Когда b() завершится, он будет извлечен из стека, затем a() завершит работу и вплоть до Global EC

см. стек выполнения для приведенного выше фрагмента кода

Ответ 3

Я затронул только те темы, которые наиболее тесно связаны.

Контекст выполнения - это оболочка вокруг существующего кода; который содержит код, который вы не написали; но генерируется JS Engine.

Он состоит из следующего:

  • Глобальный объект
  • 'this'
  • Внешняя среда
  • Ваш код

Контекст выполнения создается каждый раз, когда вы запускаете файл .js/app. Первым шагом на этом этапе создания является Подъем. JS Engine резервирует пространство или настраивает память для всех переменных и функций, определенных в вашем коде. Затем они доступны, когда ваш код выполняется по очереди.

Например:

b();
console.log(a);
var a = "hi!";
function b() {
    console.log("calling function");
}

Здесь функция b() и переменная a оба доступны до того, как они определены, однако из-за hoisting консоль не будет вызывать никаких ошибок.

Результат будет выглядеть как (попробуйте)

calling function
undefined

Обратите внимание, как функция была выполнена полностью, но для переменной undefined. Это связано с тем, что Подвижность выполняется по-разному для функций vs переменных. Функция в целом забирается в память, но для переменных пространство зарезервировано как заполнитель со значением undefined. Фактическое значение затем заменяется, когда двигатель выполняет ваш код по очереди.

Надеюсь, это очистит концепцию для вас.

Ответ 4

"Контекст выполнения" - это зонтик, который обертывает весь код, чтобы помочь ему управлять. Это как менеджер, который управляет любой средой. Поскольку существует так много лексических сред, потому что в приложении JavaScript у вас много переменных и функций, вам нужен способ управлять всем. Что на первом месте, что на втором месте и так далее, и если у вас не было среды "Контекст выполнения" , все идет в ад. Поэтому рассмотрим "Контекст выполнения" - оболочку, менеджер, управляющий вашим кодом.

Ответ 5

Я хотел бы обратиться

  1. контекст
  2. этот контекст (связь с контекстом)
  3. Объем

1: контекст выполнения

JavaScript является однопоточным языком, то есть одновременно может выполняться только одна задача. Когда интерпретатор JavaScript изначально выполняет код, он сначала входит в глобальный контекст выполнения по умолчанию. Каждый вызов функции с этого момента приведет к созданию нового контекста выполнения.

Здесь часто возникает путаница, термин " контекст исполнения" фактически для всех намерений и целей относится скорее к сфере, а не к контексту. Это неудачное соглашение об именах, однако это терминология, определенная спецификацией ECMAScript, так что мы как-то застряли с ней.

Каждый раз, когда создается новый контекст выполнения, он добавляется к вершине стека выполнения. Браузер всегда будет выполнять текущий контекст выполнения, который находится поверх стека выполнения. После завершения он будет удален из верхней части стека, и управление вернется в контекст выполнения ниже.

Контекст выполнения может быть разделен на этап создания и выполнения. На этапе создания интерпретатор сначала создает переменный объект (также называемый объектом активации), который состоит из всех переменных, объявлений функций и аргументов, определенных в контексте выполнения. Оттуда цепочка областей действия инициализируется следующим, и значение этого определяется последним. Затем на этапе выполнения код интерпретируется и выполняется.

2: этот контекст

Что такое "этот" контекст? Контекст чаще всего определяется тем, как вызывается функция. Когда функция вызывается как метод объекта, это устанавливается для объекта, для которого вызывается метод:

var obj = {
    foo: function() {
        return this;   
    }
};

obj.foo() === obj; // true

Тот же принцип применяется при вызове функции с оператором new для создания экземпляра объекта. Когда вызывается таким способом, значение этого в пределах области функции будет установлено во вновь созданный экземпляр:

function foo() {
    alert(this);
}

foo() // window
new foo() // foo

При вызове в качестве несвязанной функции по умолчанию это будет глобальный контекст или объект окна в браузере. Однако, если функция выполняется в строгом режиме, контекст по умолчанию будет неопределенным.

3: Переменная область

Переменная может быть определена в локальной или глобальной области видимости, которая устанавливает доступность переменных из разных областей во время выполнения. Любая определенная глобальная переменная, означающая, что любая переменная, объявленная вне тела функции, будет жить во время выполнения и может быть доступна и изменена в любой области видимости. Локальные переменные существуют только в теле функции, для которого они определены, и будут иметь различную область видимости для каждого вызова этой функции. Там он подлежит присваиванию, извлечению и манипулированию значениями только внутри этого вызова и недоступен за пределами этой области.

В ECMAScript 6 (ES6/ES2015) введены ключевые слова let и const, которые поддерживают объявление локальных переменных области видимости блока. Это означает, что переменная будет ограничена областью действия блока, в котором она определена, например оператором if или циклом for, и не будет доступна вне открывающих и закрывающих фигурных скобок блока. Это противоречит объявлениям var, которые доступны вне блоков, в которых они определены. Разница между let и const заключается в том, что объявление const, как следует из названия, является константой - ссылка только для чтения на значение. Это не означает, что значение является неизменным, просто идентификатор переменной не может быть переназначен.

Для других тем: GC: GC Prototyping: прототипирование

Ответ 6

При выполнении функции вы создаете новый execution context, содержащий локальную память, которая называется variable environment и this, который является заполнителем, он будет ссылаться внутри своего контекста исполнения на все, что слева от . где эта функция вызывается.

Ответ 7

Я предполагаю, что простой пример объяснит все.

Примечание: function.call(object) вызывает функцию function в контексте object

// HTML

​<p id="p"></p>​​​​​​​​​​​​​​​​​​​​​​​​

// JavaScript

function helloWorld() {
    alert("HelloWorld: " + this);
}

var p = document.getElementById("p");
helloWorld();                // HelloWorld: [object DOMWindow]
helloWorld.call(window);     // HelloWorld: [object DOMWindow]
​​​​​​helloWorld.call("String");   // HelloWorld: String // Note: "toString()"
helloWorld.call​​​​(p);          // HelloWorld: [object HTMLParagraphElement]
helloWorld.call(new Date());​​​​ // HelloWorld: Tue Feb 21 2012 21:45:17 GMT+0100 (Central Europe Standard Time)

Ответ 8

Контекст выполнения - это оболочка, помогающая управлять запущенным кодом В вашем коде вы увидите, что множество лексических сред означает, что области кода между {}, но которые в настоящее время выполняются, управляются с помощью контекста execute.it может содержать ваш код, а также может содержать помимо того, что вы написали в коде.