Понимание того, как работает подъем в JavaScript

Такие читатели, как вы, помогают поддерживать MUO. Когда вы совершаете покупку по ссылкам на нашем сайте, мы можем получать партнерскую комиссию.

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

Узнайте все о том, как работает подъем в JavaScript и как лучше всего им управлять, чтобы избежать ошибок в коде.

Поднятие переменных с помощью var, let и const

Подъем возможен, потому что JavaScript использует систему компиляции JIT (Just-in-Time), которая сканирует ваш код, чтобы идентифицировать все переменные в соответствующих областях.

Затем компилятор JIT поднимает все экземпляры объявлений переменных в верхнюю часть их области видимости при компиляции. JavaScript поднимает только объявления переменных, а не их инициализацию.

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

вар

Доступ к неинициализированной переменной, объявленной с помощью вар ключевое слово вернется неопределенный. Например:

консоль.log(foo); // неопределенный
вар фу = 2;

Приведенные выше журналы кода неопределенный потому что он звонит console.log прежде чем он инициализирует переменную.

Компилятор JavaScript просматривает предыдущий блок кода так:

вар фу;
консоль.log(foo); // неопределенный
фу = 2;

Во время подъема переменные подчиняются правила области действия JavaScript. Javascript только поднимет переменную в верхнюю часть области, в которой вы ее объявили. Попытка зарегистрировать значение переменной за пределами ее объявленной области приведет к ReferenceError. Например, если вы объявите переменную внутри функции, она не будет видна за пределами этой области:

функциямоя функция() {
консоль.log(foo); // неопределенный
вар фу = 10;
}
мояФункция();
консоль.log(foo); // ReferenceError: foo не определен

Попытка доступа к переменной за пределами ее области действия приведет к ReferenceError.

пусть и const

Согласно МДН документация по позволять и константа подъем, JavaScript также поднимает переменные, объявленные с помощью позволять и константа ключевые слова. Однако, в отличие от переменных, объявленных с помощью вар ключевое слово, они не инициализируются неопределенный ценить.

Например:

функциямоя функция() {
консоль.log(foo); // неопределенный
консоль.лог (бар); // ReferenceError: невозможно получить доступ к 'bar' до инициализации
консоль.log(баз); // ReferenceError: невозможно получить доступ к 'baz' до инициализации
вар фу = 5;
позволять бар = 10;
константа баз = 15;
}
мояФункция();

Вы не можете получить доступ к переменным, объявленным с помощью ключевых слов let и const, до их инициализации со значением.

Подъемные функции

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

Объявление функции — это функция, объявленная с именем, а функциональное выражение — это функция, имя которой можно опустить. Например:

функцияфу() {
// объявление функции
}
константа бар = () => {
// функциональное выражение
}

JavaScript поднимает объявления функций, но не выражения функций. Например:

Фу(); // 5
бар(); // TypeError: bar() не является функцией
// Объявление функции
функцияфу() {
консоль.бревно(5);
}
// Выражение функции
вар бар = функциявыражение() {
консоль.бревно(10);
};

Этот код вызывает фу перед объявлением и инициализацией его как функции, но он все еще регистрирует 5 к консоли. Однако, пытаясь позвонить бар приводит к Ошибка типа.

Управление подъемом

Знание о подъеме и потенциальных ошибках, которые могут возникнуть при неправильном управлении, может сэкономить вам долгие часы отладки. Вот несколько способов, которыми вы можете управлять подъемом.

Объявление переменных внутри функций

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

Объявить переменные с помощью let или const

Вы должны всегда использовать lэт и снаст ключевые слова вместо вар ключевое слово при объявлении переменных. Эта практика полезна при объявлении локальных переменных внутри функции. Знание правильных способов объявить переменные в JavaScript уменьшает вероятность ошибок, вызванных поднятием кода.

Объявите переменные в верхней части их области видимости

Объявите все свои переменные в верхней части соответствующих областей видимости перед любыми другими операторами. Это гарантирует, что компилятору JavaScript не придется поднимать эти переменные для доступа к ним.

Использование строгого режима

Строгий режим — это режим JavaScript. который регулирует плохой синтаксис, оптимизирует время выполнения вашего кода и запрещает злоупотребление нестрогим синтаксисом JavaScript, выдавая ошибки во время компиляции.

Например, в «неаккуратном режиме» из-за подъема вы можете получить доступ к переменной вне инициализированной функции, даже если она не была объявлена:

мояФункция();
консоль.log(foo); // 20
функциямоя функция() {
 фу = 20; 
}

В приведенном выше блоке кода JavaScript автоматически объявляет фу и поднимает его на вершину глобальной области видимости, игнорируя область, в которой вы ее инициализировали.

Вы можете использовать строгий режим, чтобы исправить это поведение и выдать ошибку, если вы попытаетесь получить доступ к переменной за пределами ее области действия.

Строгий режим не прекращает подъем вообще. Вместо этого он предотвращает наиболее запутанные и подверженные ошибкам формы подъема. По-прежнему важно понимать общую концепцию и правила подъема, даже при использовании системы безопасности строгого режима.

Чтобы включить строгий режим на глобальном уровне, объявите синтаксис в верхней части файла сценария:

"использоватьстрогий"; // или 'использоватьстрогий'

Чтобы перейти в строгий режим на уровне функции, объявите синтаксис в верхней части тела функции перед любыми операторами:

функциямоя строгая функция() {
 "использоватьстрогий";
}

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

Объявление строгого режима на глобальном уровне предотвращает доступ к переменным за пределами их соответствующих областей:

"использоватьстрогий";
мояФункция();
консоль.log(foo); // ReferenceError: foo не определен
функциямоя функция() {
 фу = 20; 
}

При включенном строгом режиме компилятор JavaScript поднимет мояФункция() в начало своей области без необъявленной переменной.

Поймите, что влияет на подъем

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

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