Объем в JavaScript – объяснение глобальной, локальной и блочной области видимости.

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

В огромном мире программирования, область действия (scope) является фундаментальным концептом, который лежит в основе поведения переменных в любом языке программирования.

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

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

Что такое область действия?

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

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

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

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

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

JavaScript предлагает различные типы области действия, при чем три основных типа – это глобальная, локальная и блочная области действия.

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

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

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

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

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

Содержание

• Глобальная область действия– Переменные, объявленные в глобальной области– Как получить доступ к глобальным переменным– Возможные проблемы с глобальной областью– Лучшие практики использования глобальной области действия
• Локальная область действия– Переменные, объявленные в локальной области– Как получить доступ к локальным переменным– Концепция затенения переменных– Преимущества использования локальной области действия
• Блочная область действия– Переменные, объявленные в блочной области– Различия между блочной и локальной областями действия– Как использовать блочную область действия с помощью let и const– Блочная область действия в условных операторах и циклах
• Цепочка областей действия– Как JavaScript разрешает ссылки на переменные– Понимание лексической области действия– Вложенные области действия и их влияние на цепочку областей действия
• Замыкания и область видимости функций– Как связаны область видимости функций и замыкания– Практические примеры замыканий
• Лучшие практики в области действия– Советы по избеганию распространенных проблем, связанных с областью действия– Важность минимизации глобальных переменных– Использование подходящих имен переменных для ясности– Когда использовать разные типы области действия
• Заключение

Глобальная область видимости

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

Можно представить глобальную область видимости как “городскую площадь” вашей программы, где все могут видеть и получать доступ к тому, что происходит.

Для иллюстрации давайте рассмотрим аналогию. Представьте, что ваша программа на JavaScript – это маленький город, а глобальная область видимости – это центральная площадь города.

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

Переменные, объявленные в глобальной области видимости

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

var globalVariable = "I'm in global scope";function myFunction() {  // Эта функция может получить доступ к globalVariable  console.log(globalVariable);}myFunction();

Здесь globalVariable объявлен в глобальной области видимости, и myFunction может получать к нему прямой доступ и использовать его.

Как получить доступ к глобальным переменным

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

var townMessage = "Welcome to our lovely town!";function welcomeMessage() {  console.log(townMessage); // Получение доступа к глобальной переменной}welcomeMessage();

Возможные проблемы с глобальной областью видимости

Хотя глобальная область видимости может быть очень удобной, она имеет свои потенциальные недостатки.

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

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

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

Лучшие практики использования глобальной области видимости

Чтобы минимизировать потенциальные проблемы, связанные с глобальной областью видимости, рекомендуется следовать следующим лучшим практикам:

1. Используйте глобальную область видимости с осторожностью: Объявляйте переменные в глобальной области видимости только тогда, когда это действительно необходимо для их глобального доступа.
2. Избегайте перезаписи глобальных переменных: Будьте осторожны при изменении глобальных переменных, чтобы избежать непреднамеренных побочных эффектов.
3. Используйте названия переменных, ясно отражающие их назначение: Выбирайте названия переменных, которые четко передают их назначение, особенно в глобальной области видимости, где они могут влиять на множество частей вашего кода.

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

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

Понимание глобальной области видимости – это важный шаг в освоении механизмов областей видимости JavaScript.

Локальная область видимости

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

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

Переменные в локальной области видимости защищены от вмешательства или изменения кода вне их области видимости, предоставляя уровень изоляции.

Переменные, объявленные в локальной области видимости

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

Эти переменные, по сути, “локальны” для этого блока кода, и их нельзя прямо получить доступ извне.

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

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

Вот пример:

function myFunction() {  var localVariable = "I'm in local scope";  console.log(localVariable);}myFunction();// Получение доступа к localVariable здесь приведет к ошибке

В этом коде localVariable находится в локальной области видимости, что означает, что он доступен только в блоке myFunction.

Как получить доступ к локальным переменным

Доступ к локальным переменным является простым в пределах области, в которой они определены.

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

function greet() {  var greeting = "Привет, мир!";  console.log(greeting); // Доступ к локальной переменной}greet();

В этом примере greeting является локальной переменной, и она безопасно доступна внутри функции greet без влияния на переменные вне ее.

Концепция скрытия переменных

Скрытие переменных происходит, когда вы объявляете переменную с тем же именем внутри локальной области видимости, эффективно “скрывая” переменную с тем же именем в более высокой области видимости.

Это похоже на размещение объекта с тем же именем в нескольких комнатах, и внутренний объект имеет преимущество при попытке получить к нему доступ.

Рассмотрим этот пример:

var message = "Глобальное сообщение";function showMessage() {  var message = "Локальное сообщение"; // Это "скрывает" глобальную переменную  console.log(message); // Доступ к локальной переменной}showMessage();console.log(message); // Доступ к глобальной переменной

В этом коде локальная переменная message скрывает глобальную переменную с тем же именем, когда вы находитесь внутри функции showMessage.

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

Локальная область видимости предлагает несколько преимуществ:

1. Изоляция: Это предотвращает намеренное взаимодействие с переменными в других частях вашего кода, уменьшая риск ошибок и конфликтов.
2. Модульность: Это позволяет вам компартментализировать ваш код, делая его более управляемым и легче поддерживаемым.
3. Повторное использование: Переменные в локальной области видимости могут быть определены и использованы в пределах определенных функций или блоков, способствуя повторному использованию кода без влияния на остальную часть программы.

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

Область видимости блока

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

В отличие от глобальной и локальной областей видимости, которые определяются функциями или глобальным контекстом, область видимости блока создается внутри определенных блоков кода, таких как условные операторы (if, else, switch) и циклы (for, while).

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

Для иллюстрации представьте себе русскую матрешку. Большая кукла представляет глобальную область видимости, и каждая меньшая кукла, вложенная внутри нее, представляет область видимости блока.

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

Переменные, объявленные в области видимости блока

Переменные, объявленные в области видимости блока, доступны только внутри блока, в котором они определены. Эти переменные похожи на скрытые сокровища внутри каждой матрешки, известные и доступные только в их собственных отсеках.

Вот пример использования области видимости блока внутри оператора if:

if (true) {  let blockVariable = "Я нахожусь в области видимости блока";  console.log(blockVariable);}// Доступ к blockVariable здесь вызывает ошибку

В этом коде blockVariable определена внутри блока, создаваемого оператором if, и недоступна вне его.

Различия между областью видимости блока и локальной областью видимости

Область видимости блока часто путают с локальной областью видимости, но существует ключевое отличие.

В локальной области видимости переменные обычно определяются внутри функции, в то время как область видимости блока создается внутри блоков кода, таких как операторы if, for или while.

Локальная область видимости относится к уровню функции и охватывает всю функцию, тогда как область видимости блока ограничена только конкретным блоком, в котором переменная определена.

Рассмотрим следующий код, чтобы выделить разницу:

function myFunction() {  if (true) {    var localVariable = "Я нахожусь в области видимости блока";    let blockVariable = "Я также нахожусь в области видимости блока";  }  console.log(localVariable); // Доступно  console.log(blockVariable); // Ошибка: blockVariable не определена}

В этом примере localVariable доступна внутри функции, потому что она находится в локальной области видимости. С другой стороны, blockVariable доступна только внутри блока if из-за области видимости блока.

Как использовать блочную область с помощью let и const

Введение ключевых слов let и const в JavaScript существенно улучшило блочную область.

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

function exampleBlockScope() {  if (true) {    let blockVariable = "Я нахожусь в блочной области с использованием 'let'";    const constantBlockVar = "Я нахожусь в блочной области с использованием 'const'";  }  console.log(blockVariable); // Ошибка: blockVariable не определена  console.log(constantBlockVar); // Ошибка: constantBlockVar не определена}

В этом коде blockVariable и constantBlockVar находятся в блочной области и недоступны вне соответствующих блоков.

Блочная область в условных операторах и циклах

Блочная область часто используется в условных операторах и циклах для управления областью видимости переменных. Рассмотрим следующий пример:

function checkCondition() {  let result = "До условия";  if (true) {    let result = "Внутри условия"; // Переменная с блочной областью  }  console.log(result); // "До условия" из внешней области видимости}

В этом коде переменная result находится в блочной области внутри оператора if и не влияет на переменную result во внешней области видимости.

Блочная область – это мощный инструмент для управления видимостью переменных и предотвращения нежелательных конфликтов переменных в конкретных блоках кода.

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

Цепочка областей видимости

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

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

Этот процесс поиска переменных через несколько областей видимости известен как “цепочка областей видимости”.

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

Когда вам нужна какая-то информация, вы начинаете с текущей страницы, и если она там не находится, перелистываете страницы, пока не найдете ее.

Как JavaScript разрешает ссылки на переменные

Чтобы лучше понять цепочку областей видимости, рассмотрим следующий пример:

var globalVariable = "Я глобальная";function outerFunction() {  var outerVariable = "Я во внешней области видимости";  function innerFunction() {    var innerVariable = "Я во внутренней области видимости";    console.log(innerVariable); // Доступ к innerVariable    console.log(outerVariable); // Доступ к outerVariable    console.log(globalVariable); // Доступ к globalVariable  }  innerFunction();}outerFunction();

В этом примере функция innerFunction может получить доступ к переменным из своей локальной области видимости (например, innerVariable), внешней области видимости (например, outerVariable) и глобальной области видимости (например, globalVariable). JavaScript следует цепочке областей видимости, чтобы найти эти переменные.

Понимание лексической области

Цепочка областей видимости в JavaScript следует принципу, известному как лексическая (или статическая) область видимости.

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

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

Рассмотрим следующий код:

var a = "Я глобальная";function firstFunction() {  var a = "Я в первой функции";  function secondFunction() {    console.log(a); // Обращение к a из firstFunction, а не к глобальной a  }  secondFunction();}firstFunction();

В этом примере, даже если secondFunction вызывается изнутри firstFunction, она все равно обращается к переменной a из области видимости, где она была объявлена (лексическая область видимости), которая является firstFunction.

Вложенные области видимости и их влияние на цепочку областей видимости

Цепочка области видимости может стать более сложной, когда у вас есть вложенные функции или блоки кода.

Каждый новый уровень вводит новый лист в стек. Переменные во внутренних областях видимости могут затенять (скрывать) переменные с тем же именем во внешних областях видимости.

Вот пример, чтобы проиллюстрировать эту концепцию:

var x = 10;function outer() {  var x = 20;  function inner() {    var x = 30;    console.log(x); // Обращение к x из самой внутренней области видимости (x = 30)  }  inner();  console.log(x); // Обращение к x из внешней области видимости (x = 20)}outer();console.log(x); // Обращение к x из глобальной области видимости (x = 10)

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

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

Это похоже на перелистывание страниц книги для поиска нужной информации в правильном порядке.

Замыкания и область видимости функций

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

Представьте замыкания как небольшие “пакеты” кода, которые инкапсулируют функцию и переменные, с которыми она должна работать.

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

Аналогично рассмотрим ланчбокс, в котором содержится бутерброд и некоторые ингредиенты. Ланчбокс хранит все вместе и позволяет насладиться приемом пищи в нужное время и место.

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

Как связаны область видимости функции и замыкания

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

Это поведение является результатом области видимости функции и цепочки областей видимости.

Давайте рассмотрим пример, чтобы проиллюстрировать замыкания:

function outerFunction() {  var outerVariable = "Я нахожусь в outerFunction";  function innerFunction() {    console.log(outerVariable); // Обращение к outerVariable из внешней области видимости  }  return innerFunction;}var closure = outerFunction();closure(); // У этого все еще есть доступ к outerVariable

В этом коде innerFunction объявляется внутри outerFunction, создавая замыкание.

Когда вызывается outerFunction и присваивается переменной closure, она сохраняет доступ к переменной outerVariable, даже после того, как outerFunction завершила выполнение.

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

Практические примеры замыканий

Замыкания используются в различных сценариях на JavaScript. Вот несколько практических примеров:

• Инкапсуляция данных: Замыкания позволяют инкапсулировать данные и поведение. Это похоже на запечатанный конверт, содержащий информацию, к которой можно получить доступ только через определенные методы.

function createCounter() {  var count = 0;  return {    increment: function() {      count++;    },    getCount: function() {      return count;    }  };}var counter = createCounter();counter.increment();console.log(counter.getCount()); // Получение доступа к переменной count через замыкания

• Обработчики событий: Замыкания часто используются при обработке событий. Функция-обработчик события может “помнить” контекст, в котором она была создана, что облегчает доступ к переменным при обработке событий.

function setupEvent() {  var message = "Привет, мир!";  document.getElementById("myButton").addEventListener("click", function() {    alert(message); // Получение доступа к переменной message через замыкание  });}

• Шаблон модуля: Замыкания могут использоваться для создания модульных и организованных структур кода. Вы можете скрывать детали внутренней реализации и предоставлять только необходимый интерфейс.

var module = (function() {  var privateVariable = "Я приватный";  return {    publicFunction: function() {      console.log(privateVariable); // Получение доступа к privateVariable через замыкание    }  };})();module.publicFunction();

Замыкания – это фундаментальное понятие, которое позволяет использовать передовые методы программирования на JavaScript и необходимо для понимания таких тем, как обратные вызовы, обещания и асинхронное программирование.

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

Лучшие практики по области видимости

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

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

Вот некоторые лучшие практики, связанные с областью видимости:

Советы по избеганию распространенных проблем, связанных с областью видимости

• Ограничение глобальных переменных: Минимизируйте использование глобальных переменных. Их чрезмерное использование может привести к конфликтам именования и затруднить поддержку вашего кода по мере его роста. Используйте глобальную область видимости только для переменных, которые действительно должны быть доступны из разных частей вашего приложения.
• Использование строгого режима: Включите строгий режим в вашем коде JavaScript. Строгий режим помогает обнаруживать распространенные ошибки программирования и “небезопасные” действия, включая случайное создание глобальных переменных. Чтобы включить строгий режим, добавьте следующую строку в начало ваших скриптов:

"use strict";

• Избегайте затенения переменных: Будьте осторожны при повторном использовании имен переменных во вложенных областях видимости, так как это может привести к путанице и непредсказуемому поведению. Используйте описательные имена переменных и минимизируйте затенение для повышения читабельности кода.

Важность минимизации глобальных переменных

• Инкапсуляция данных: Инкапсулируйте ваши данные внутри функций и модулей. Хранение данных в локальной или функциональной области видимости уменьшает риск непреднамеренного вмешательства и делает ваш код более модульным и поддерживаемым.
• Избегание побочных эффектов: Минимизация глобальных переменных помогает уменьшить непреднамеренные побочные эффекты в вашем коде. Глобальные переменные могут быть изменены из нескольких мест, что затрудняет определение источника изменений и приводит к неожиданным результатам.

Использование подходящих имен переменных для ясности

• Описательное именование: Используйте четкие и описательные имена переменных, передавая их назначение. Эта практика особенно важна в глобальной области видимости, где имена переменных могут влиять на несколько частей вашего кода. Описательные имена улучшают понимание кода и его поддержку.
• Избегание однобуквенных переменных: Хотя однобуквенные имена переменных, такие как i и j, распространены в циклах, старайтесь использовать их сдержанно вне контекста циклов. Означенные имена переменных повышают читабельность кода и упрощают его понимание вам и другим.

Когда использовать различные виды области видимости

• Глобальная область видимости: Используйте глобальную область видимости только для переменных, которые действительно должны быть доступны во всем вашем приложении. Глобальные переменные должны быть редкими и тщательно управляемыми исключениями.
• Локальная и блочная область видимости: Используйте локальную и блочную области видимости для изоляции и контроля переменных. Используйте локальную область видимости внутри функций и блочную область видимости для переменных внутри конкретных блоков кода, таких как циклы и условные операторы.
• Замыкания: Используйте замыкания для инкапсуляции данных и поведения по мере необходимости. Замыкания предоставляют мощный способ создания самодостаточных блоков функциональности и особенно ценны для защиты данных и модульности.

Освоение области видимости в JavaScript крайне важно для написания эффективного и поддерживаемого кода.

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

Имейте в виду, что область видимости не является только техническим аспектом программирования. Она также играет решающую роль в написании надежного и масштабируемого кода.

Выводы

Область видимости в JavaScript – это фундаментальное понятие, которое влияет на поведение и структуру вашего кода.

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

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

Механизмы области видимости JavaScript подобны фундаменту здания – они определяют структуру, стабильность и функциональность вашего кода.

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

Заключая данное изучение области видимости, важно подчеркнуть некоторые ключевые моменты:

1. Область видимости – ключевое понятие: Область видимости не является просто технической характеристикой. Это основополагающее понятие, которое влияет на то, как вы пишете, организуете и поддерживаете ваш код на JavaScript.
2. Глобальная, локальная и блочная область видимости: JavaScript предлагает различные типы области видимости, каждая из которых выполняет определенные задачи. Глобальная область видимости обеспечивает широкую доступность, локальная область видимости обеспечивает изоляцию, а блочная область видимости контролирует видимость в пределах конкретных блоков кода.
3. Цепочка области видимости и замыкания: Понимание цепочки области видимости важно для понимания того, как JavaScript разрешает ссылки на переменные. Замыкания, использующие область видимости функций, играют решающую роль в инкапсуляции данных и поведения.
4. Лучшие практики имеют значение: Следование лучшим практикам по области видимости, таким как минимизация глобальных переменных, использование описательных имен переменных и использование локальной и блочной области видимости, приведет к более чистому и поддерживаемому коду.

При работе над реальными проектами помните об этих принципах, связанных с областью видимости, и применяйте их для создания кода, который не только надежен, но и адаптирован к изменяющимся требованиям веб-разработки.

Продолжайте исследовать и отрабатывать эти концепции, и вы будете на пути к совершенствованию JavaScript.

---

• JavaScript
• scope