Область определения функции 7 класс как найти: Дистанционный репетитор — онлайн-репетиторы России и зарубежья

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

  >>> def func ():
... var = 100 # нелокальная переменная
... def nested ():
... nonlocal var # Объявить var нелокальным
... var + = 100
...
... вложенный ()
... печать (var)
...
>>> func ()
200
  

С помощью оператора nonlocal var вы сообщаете Python, что вы измените var внутри nested () .Затем вы увеличиваете var с помощью операции расширенного присваивания. Это изменение отражено в нелокальном имени var , которое теперь имеет значение 200 .

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

  >>> nonlocal my_var # Попробуйте использовать нелокальное значение в глобальной области видимости
  Файл "", строка 1
SyntaxError: нелокальное объявление недопустимо на уровне модуля
>>> def func ():
... nonlocal var # Попробуйте использовать нелокальную переменную в локальной области видимости
... печать (var)
...
  Файл "", строка 2
SyntaxError: привязка для нелокальной 'var' не найдена
  

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

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

  >>> def func ():
... def nested ():
... nonlocal lazy_var # Попробуйте создать нелокальное ленивое имя
...
  Файл "", строка 3
SyntaxError: привязка для нелокальной 'lazy_var' не найдена
  

В этом примере, когда вы пытаетесь определить нелокальное имя с помощью nonlocal lazy_var , Python немедленно вызывает SyntaxError , потому что lazy_var не существует во включающей области nested () .

Использование охватывающих областей как замыканий

Замыкания — это особый вариант использования охватывающей области Python. Когда вы обрабатываете вложенную функцию как данные, операторы, составляющие эту функцию, упаковываются вместе со средой, в которой они выполняются.Результирующий объект называется закрытием. Другими словами, замыкание — это внутренняя или вложенная функция, которая несет информацию о своей охватывающей области, даже если эта область завершила свое выполнение.

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

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

  >>> def power_factory (exp):
... степень защиты (базовая):
... вернуть базу ** exp
... вернуть мощность
...
>>> квадрат = power_factory (2)
>>> квадрат (10)
100
>>> cube = power_factory (3)
>>> куб (10)
1000
>>> куб (5)
125
>>> квадрат (15)
225
  

Ваша функция фабрики закрытия power_factory () принимает аргумент с именем exp .Вы можете использовать эту функцию для создания замыканий, которые запускают различные операции с питанием. Это работает, потому что каждый вызов power_factory () получает свой собственный набор информации о состоянии. Другими словами, он получает свое значение exp .

Примечание: Такие переменные, как exp , называются свободными переменными . Это переменные, которые используются в блоке кода, но не определены там. Свободные переменные — это механизм, который закрытие использует для сохранения информации о состоянии между вызовами.

В приведенном выше примере внутренняя функция power () сначала назначается квадрату . В этом случае функция запоминает, что exp равно 2 . Во втором примере вы вызываете power_factory () , используя 3 в качестве аргумента. Таким образом, куб содержит функциональный объект, который запоминает, что exp — это 3 . Обратите внимание, что вы можете свободно повторно использовать square и cube , потому что они не забывают информацию о своем состоянии.

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

  >>> def mean ():
... образец = []
... def _mean (число):
...         образец.добавить (число)
... вернуть сумму (образец) / len (образец)
... вернуть _mean
...
>>> current_mean = среднее ()
>>> current_mean (10)
10.0
>>> current_mean (15)
12,5
>>> current_mean (12)
12,333333333333334
>>> current_mean (11)
12.0
>>> current_mean (13)
12.2
  

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

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

  >>> def mean ():
... всего = 0
... длина = 0
... def _mean (число):
... нелокальный итог, длина
... итог + = число
... длина + = 1
... вернуть итог / длину
... вернуть _mean
...
>>> current_mean = среднее ()
>>> current_mean (10)
10.0
>>> current_mean (15)
12,5
>>> current_mean (12)
12,333333333333334
>>> current_mean (11)
12.0
>>> current_mean (13)
12.2
  

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

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

  >>> from functools import partial
>>> def power (exp, base):
... возвратная база ** exp
...
>>> квадрат = частичный (степень, 2)
>>> квадрат (10)
100
  

Вы используете частичный для создания функционального объекта, который запоминает информацию о состоянии, где exp = 2 . Затем вы вызываете этот объект, чтобы выполнить операцию питания и получить окончательный результат.

Осуществление имен с помощью импорта

Когда вы пишете программу Python, вы обычно разбиваете код на несколько модулей. Чтобы ваша программа работала, вам необходимо перенести имена этих отдельных модулей в модуль __main__ .Для этого вам нужно явно импортировать модули или имена. Это единственный способ использовать эти имена в основной глобальной области Python.

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

  >>> dir ()
['__annotations__', '__builtins __', ..., '__spec__']
>>> import sys
>>> dir ()
['__annotations__', '__builtins __', ..., '__spec__', 'sys']
>>> import os
>>> dir ()
['__annotations__', '__builtins__' ,..., '__spec__', 'os', 'sys']
>>> from functools import partial
>>> dir ()
['__annotations__', '__builtins __', ..., '__spec__', 'os', 'partial', 'sys']
  

Сначала вы импортируете sys и os из стандартной библиотеки Python. Вызвав dir () без аргументов, вы увидите, что эти модули теперь доступны вам как имена в вашей текущей глобальной области видимости. Таким образом, вы можете использовать точечную нотацию, чтобы получить доступ к именам, которые определены в sys и os .

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

Обнаружение необычных областей видимости Python

Вы найдете некоторые структуры Python, в которых разрешение имен не соответствует правилу LEGB для областей действия Python. Эти структуры включают:

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

Объем переменных понимания

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

Понятия состоят из пары скобок ( [] ) или фигурных скобок ( {} ), содержащих выражение, за которым следуют один или несколько для предложений и затем ноль или один , если предложение на для предложения . .

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

  >>> [элемент для элемента в диапазоне (5)]
[0, 1, 2, 3, 4]
>>> item # Попробуйте получить доступ к переменной понимания
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    пункт
NameError: имя 'item' не определено
  

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

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

  >>> для элемента в диапазоне (5):
... печать (элемент)
...
0
1
2
3
4
>>> item # Доступ к переменной цикла
4
  

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

Область действия переменных исключения

Еще один нетипичный случай области видимости Python, с которым вы столкнетесь, — это случай переменной исключения . Переменная исключения — это переменная, которая содержит ссылку на исключение, вызванное оператором try . В Python 3.x такие переменные являются локальными для , за исключением блока , и забываются, когда блок заканчивается.Обратите внимание на следующий код:

  >>> lst = [1, 2, 3]
>>> попробуйте:
... lst [4]
... кроме IndexError как err:
... # Переменная err является локальной для этого блока
... # Здесь вы можете делать что угодно с помощью err
... печать (ошибка)
...
индекс списка вне допустимого диапазона
>>> err # Выходит за рамки
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    ошибаться
NameError: имя 'err' не определено
  

err содержит ссылку на исключение, вызванное предложением try .Вы можете использовать err только внутри кодового блока , за исключением предложения . Таким образом, вы можете сказать, что область Python для переменной исключения является локальной для , за исключением блока кода . Также обратите внимание, что если вы попытаетесь получить доступ к err извне , кроме блока , то получите NameError . Это потому, что как только блок , за исключением , заканчивается, имя больше не существует.

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

  >>> lst = [1, 2, 3]
>>> ex = Нет
>>> попробуйте:
... lst [4]
... кроме IndexError как err:
... ex = err
... печать (ошибка)
...
индекс списка вне допустимого диапазона
>>> err # Выходит за рамки
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
NameError: имя 'err' не определено
>>> ex # Содержит ссылку на исключение
индекс списка вне допустимого диапазона
  

Вы используете ex в качестве вспомогательной переменной для хранения ссылки на исключение, вызванное предложением try .Это может быть полезно, когда вам нужно что-то сделать с объектом исключения после завершения блока кода. Обратите внимание, что если исключение не возникает, то ex остается None .

Область действия атрибутов класса и экземпляра

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

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

  >>> класс А:
... attr = 100
...
>>> A .__ dict __. Keys ()
dict_keys (['__ module__', 'attr', '__dict__', '__weakref__', '__doc__'])
  

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

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

  >>> класс А:
... attr = 100
... print (attr) # Доступ к атрибутам класса напрямую
...
100
>>> А.attr # Доступ к атрибуту класса извне класса
100
>>> attr # Не определен вне A
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    attr
NameError: имя attr не определено
  

Внутри локальной области видимости A вы можете получить доступ к атрибутам класса напрямую, как вы это делали в операторе print (attr) . Чтобы получить доступ к любому атрибуту класса после выполнения блока кода класса, вам нужно будет использовать точечную нотацию или ссылку на атрибут, как вы это делали с A.attr . В противном случае вы получите NameError , потому что атрибут attr является локальным для блока класса.

С другой стороны, если вы попытаетесь получить доступ к атрибуту, который не определен внутри класса, вы получите AttributeError . Посмотрите на следующий пример:

  >>> A.undefined # Пытаться получить доступ к неопределенному атрибуту класса
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    А.неопределенный
AttributeError: объект типа A не имеет атрибута undefined
  

В этом примере вы пытаетесь получить доступ к атрибуту undefined . Поскольку этого атрибута нет в A , вы получите ошибку AttributeError , сообщающую, что A не имеет атрибута с именем undefined .

Вы также можете получить доступ к любому атрибуту класса, используя экземпляр класса следующим образом:

  >>> obj = A ()
>>> объект.attr
100
  

Когда у вас есть экземпляр, вы можете получить доступ к атрибутам класса, используя точечную нотацию, как вы сделали здесь с obj.attr . Атрибуты класса специфичны для объекта класса, но вы можете получить к ним доступ из любых экземпляров класса. Стоит отметить, что атрибуты класса являются общими для всех экземпляров класса. Если вы измените атрибут класса, то изменения будут видны во всех экземплярах класса.

Примечание: Думайте о точечной нотации, как если бы вы говорили Python: «Найдите атрибут с именем attr в obj .Если найдешь, отдай мне ».

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

Чтобы создать, обновить или получить доступ к любому атрибуту экземпляра изнутри класса, вам необходимо использовать self вместе с точечной нотацией.Здесь self — это специальный атрибут, представляющий текущий экземпляр. С другой стороны, чтобы обновить или получить доступ к любому атрибуту экземпляра извне класса, вам необходимо создать экземпляр, а затем использовать точечную нотацию. Вот как это работает:

  >>> класс А:
... def __init __ (self, var):
... self.var = var # Создать новый атрибут экземпляра
... self.var * = 2 # Обновить атрибут экземпляра
...
>>> obj = A (100)
>>> объект.__dict__
{'var': 200}
>>> obj.var
200
  

Класс A принимает аргумент с именем var , который автоматически удваивается внутри .__ init __ () с использованием операции присваивания self.var * = 2 . Обратите внимание, что когда вы проверяете .__ dict__ на obj , вы получаете словарь, содержащий все атрибуты экземпляра. В этом случае словарь содержит только имя var , значение которого теперь 200 .

Несмотря на то, что вы можете создавать атрибуты экземпляра в любом методе класса, рекомендуется создавать и инициализировать их внутри .__ init __ () . Взгляните на эту новую версию A :

  >>> класс А:
... def __init __ (self, var):
... self.var = var
...
... def duplicate_var (self):
... вернуть self.var * 2
...
>>> obj = A (100)
>>> obj.var
100
>>> obj.duplicate_var ()
200
>>> А.вар
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    А.вар
AttributeError: объект типа A не имеет атрибута var
  

Здесь вы изменяете A , чтобы добавить новый метод с именем duplicate_var () . Затем вы создаете экземпляр A , передавая 100 инициализатору класса. После этого теперь вы можете вызвать duplicate_var () на obj , чтобы дублировать значение, хранящееся в self.var .Наконец, если вы попытаетесь получить доступ к var , используя объект класса вместо экземпляра, вы получите AttributeError , потому что к атрибутам экземпляра нельзя получить доступ с помощью объектов класса.

Как правило, когда вы пишете объектно-ориентированный код на Python и пытаетесь получить доступ к атрибуту, ваша программа выполняет следующие шаги:

1. Сначала проверьте локальную область видимости или пространство имен экземпляра .
2. Если атрибут там не найден, проверьте локальную область видимости или пространство имен class .
3. Если имя не существует в пространстве имен класса, вы получите AttributeError .

Это основной механизм, с помощью которого Python разрешает имена в классах и экземплярах.

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

  >>> класс А:
... var = 100
... def print_var (self):
... print (var) # Попытка получить доступ к атрибуту класса напрямую
...
>>> A (). Print_var ()
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    A (). Print_var ()
  Файл "", строка 4, в print_var
    печать (var)
NameError: имя 'var' не определено
  

Поскольку классы не создают закрывающую область для методов, вы не можете получить доступ к var непосредственно из print_var () , как вы пытаетесь сделать здесь.Чтобы получить доступ к атрибутам класса изнутри любого метода, вам необходимо использовать точечную нотацию. Чтобы устранить проблему в этом примере, измените оператор print (var) внутри print_var () на print (A.var) и посмотрите, что произойдет.

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

  >>> класс А:
... var = 100
... def __init __ (сам):
... self.var = 200
...
... def access_attr (self):
... # Используйте точечную нотацию для доступа к атрибутам класса и экземпляра
... print (f'Атрибут экземпляра: {self.var} ')
... print (f'Атрибут класса: {A.var} ')
...
>>> obj = A ()
>>> obj.access_attr ()
Атрибут экземпляра: 200
Атрибут класса: 100
>>> A.var # Атрибуты класса доступа
100
>>> A (). Var # Доступ к атрибутам экземпляра
200
>>> А.__dict __. ключи ()
dict_keys (['__ module__', 'var', '__init __', ..., '__getattribute__'])
>>> A () .__ dict __. Keys ()
dict_keys (['var'])
  

Вышеупомянутый класс имеет атрибут экземпляра и атрибут класса с тем же именем var . Вы можете использовать следующий код для доступа к каждому из них:

1. Экземпляр: Используйте self.var для доступа к этому атрибуту.
2. Класс: Используйте A.var для доступа к этому атрибуту.

Поскольку в обоих случаях используется точечная запись, проблем с конфликтом имен не возникает.

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

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

Заключение

Область видимости переменной или имени определяет ее видимость во всем вашем коде. В Python область видимости реализована как локальная, охватывающая, глобальная или встроенная. Когда вы используете переменную или имя, Python последовательно выполняет поиск в этих областях, чтобы решить эту проблему. Если имя не найдено, вы получите сообщение об ошибке. Это общий механизм, который Python использует для разрешения имен и известен как правило LEGB .

Теперь вы можете:

• Воспользуйтесь областью действия Python, чтобы избежать или минимизировать ошибки, связанные с конфликтом имен
• Используйте как глобальные, так и локальные имена в своих программах, чтобы улучшить ремонтопригодность кода
• Используйте согласованную стратегию для доступа, изменения или обновления имен во всем вашем коде Python

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

Демистифицируем область действия переменных JavaScript и поднимаем их вверх

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

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

Диапазон изменения

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

В настоящее время существует три способа объявления переменной в JavaScript: с помощью старого ключевого слова var и с помощью нового ключевого слова let и const . До ES6 использование ключевого слова var было единственным способом объявления переменной, но теперь мы можем использовать let и const , которые имеют более строгие правила и делают код менее подверженным ошибкам. Ниже мы рассмотрим различия между всеми тремя ключевыми словами.

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

Глобальный охват

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

 

const name = "Моник";

function sayHi () {
  приставка.журнал (`Привет, $ {name}`);
}

скажи привет();

  

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

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

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

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

Функция в JavaScript определяет область для переменных, объявленных с использованием var , let и const . Любая переменная, объявленная в этой функции, доступна только из этой функции и любых вложенных функций.

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

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

  {
  
}
  

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

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

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

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

  var locales = {
  европа: функция () {
    var myFriend = "Моник";

    var france = function () {
      var paris = function () {
        console.log (myFriend);
      };

      Париж();
    };

    Франция();
  }
};

локации.европа ();
  

См. Pen
Variable Scope: 1 от SitePoint (@SitePoint)
на CodePen.

Здесь переменная myFriend доступна из функции paris , как она была определена во внешней области видимости функции france . Если мы поменяем местами переменную myFriend и оператор консоли, мы получим ReferenceError: myFriend не определен как , потому что мы не можем достичь внутренней области из внешней области.

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

Возвращаясь к данной метафоре, допустим, я хочу найти своего друга по имени Моник. Я знаю, что она живет в Париже, поэтому и начинаю поиски оттуда. Когда я не могу найти ее в Париже, я поднимаюсь на один уровень выше и расширяю свой поиск по всей Франции. Но опять же, ее там нет. Затем я снова расширяю свой поиск, поднимаясь на другой уровень выше. Наконец, я нахожу ее в Италии, которая в нашем случае является локальным размахом Европы.

В предыдущем примере мой друг Моник представлен переменной myFriend .В последней строке мы вызываем функцию europe () , которая вызывает france () , и, наконец, когда вызывается функция paris () , начинается поиск. Интерпретатор JavaScript работает в текущей области видимости и работает до тех пор, пока не найдет нужную переменную. Если переменная не найдена ни в одной области, создается исключение.

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

Теперь посмотрим, как работает новая область видимости блока:

  function testScope (n) {
  если правда) {
    константное приветствие = 'Привет';
    пусть имя = п;
    console.log (приветствие + "" + имя);
  }
  приставка.журнал (приветствие + "" + имя);
}

testScope ('Дэвид');
  

См. Pen
Variable Scope: 2 от SitePoint (@SitePoint)
на CodePen.

В этом примере мы видим, что приветствие и именуют переменные , объявленные с const и let , недоступны за пределами блока if .

Давайте теперь заменим const и let на var и посмотрим, что произойдет:

  function testScope (n) {
  если правда) {
    var приветствие = 'Привет';
    var name = n;
    приставка.журнал (приветствие + "" + имя);
  }
  console.log (приветствие + "" + имя);
}

testScope ('Дэвид');
  

См. Pen
Variable Scope: 3 от SitePoint (@SitePoint)
на CodePen.

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

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

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

  var test = «Я глобальный»;

function testScope () {
  var test = "Я местный";

  console.log (тест);
}

testScope ();

console.log (тест);
  

См. Pen
Variable Scope: 4 от SitePoint (@SitePoint)
на CodePen.

Даже с тем же именем локальная переменная не перезаписывает глобальную после выполнения функции testScope () . Но так бывает не всегда. Давайте посмотрим на это:

  var test = «Я глобальный»;

function testScope () {
  test = "Я местный";

  приставка.журнал (тест);
}

console.log (тест);

testScope ();

console.log (тест);
  

См. Pen
Variable Scope: 5 от SitePoint (@SitePoint)
на CodePen.

На этот раз локальная переменная test перезаписывает глобальную переменную с тем же именем. Когда мы запускаем код внутри функции testScope () , глобальная переменная переназначается. Если локальная переменная назначается без предварительного объявления с ключевым словом var , она становится глобальной переменной.Чтобы избежать такого нежелательного поведения, вы всегда должны объявлять свои локальные переменные перед их использованием. Любая переменная, объявленная с ключевым словом var внутри функции, является локальной переменной. Рекомендуется объявлять переменные.

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

Подъемник

Интерпретатор JavaScript выполняет множество операций за кулисами, и одна из них — «подъем».Если вы не подозреваете об этом «скрытом» поведении, это может вызвать большую путаницу. Лучший способ думать о поведении переменных JavaScript — всегда визуализировать их как состоящие из двух частей: объявления и инициализации / присвоения:

  var состояние;
состояние = "готово";

var state = "готово";
  

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

Мы уже знаем, что любая переменная, объявленная в области видимости, принадлежит этой области. Но чего мы пока не знаем, так это того, что независимо от того, где переменные объявлены в определенной области, все объявления переменных перемещаются в верхнюю часть своей области (глобальной или локальной).Это называется поднятием , поскольку объявления переменных поднимаются в верхнюю часть области видимости. Обратите внимание, что подъем перемещает только объявление. Любые назначения остаются на месте. Давайте посмотрим на пример:

  console.log (состояние);
var state = "готово";
  

См. Pen
Variable Scope: 6 от SitePoint (@SitePoint)
на CodePen.

Как вы можете видеть, когда мы регистрируем значение состояния , на выходе получается undefined , потому что мы ссылаемся на него до фактического присвоения.Вы могли ожидать, что будет выброшено ReferenceError , потому что состояние еще не объявлено. Но вы не знаете, что переменная объявлена ​​и инициализирована значением по умолчанию undefined за сценой. Вот как код интерпретируется движком JavaScript:

  var состояние;
console.log (состояние);
состояние = "готово";
  

Важно отметить, что переменная не перемещается физически.Подъем — это всего лишь модель, описывающая, что JS-движок делает за кулисами.

Теперь давайте посмотрим, как работает подъем с переменными let :

  {
  
  console.log (состояние);
  пусть состояние = "готово";
}
  

См. Pen
Variable Scope: 7 от SitePoint (@SitePoint)
на CodePen.

В этом примере вывод консоли — это не undefined , но выдается справочная ошибка. Почему? Переменные let , в отличие от переменных var , не могут быть прочитаны / записаны, пока они не будут полностью инициализированы.Они полностью инициализируются только там, где они фактически объявлены в коде. Итак, объявление переменной let поднимается, но не инициализируется значением undefined , как в случае с переменными var . Участок от начала блока до фактического объявления переменной называется временной мертвой зоной . Это механизм, который обеспечивает лучшую практику программирования, заставляя вас объявлять переменную перед ее использованием. Если мы переместим консольный оператор из TDZ, мы получим ожидаемый результат: готов .

  {
  
  пусть состояние = "готово";
  console.log (состояние);
}
  

См. Pen
Variable Scope: 8 от SitePoint (@SitePoint)
на CodePen.

Переменные, объявленные с ключевым словом const , имеют то же поведение, что и переменные let .

Функции

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

  function showState () {}
var showState = function () {};
  

Самый простой способ отличить объявление функции от выражения функции — это проверить позицию слова функция в операторе.Если функция является самым первым в операторе, то это объявление функции. В противном случае это выражение функции.

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

  showState ();

function showState () {
  console.log («Готово»);
}

var showState = function () {
  console.log («Ожидание»);
};
  

См. Pen
Variable Scope: 9 от SitePoint (@SitePoint)
на CodePen.

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

  function showState () {
  console.log («Готово»);
}

var showState;

showState ();

showState = function () {
  console.log («Ожидание»);
};
  

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

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

  var showState = function () {
  console.log («Ожидание»);
};

function showState () {
  приставка.журнал («Готово»);
}

showState ();
  

См. Pen
Variable Scope: 10 от SitePoint (@SitePoint)
на CodePen.

На этот раз мы вызываем функцию showState () в последней строке кода, что меняет ситуацию. Теперь получаем на выходе "Idle" . Вот как это выглядит при интерпретации движком JavaScript:

  function showState () {
  console.log («Готово»);
}

var showState;

showState = function () {
  приставка.журнал ("Ожидание");
};

showState ();
  

Примечание: стрелочные функции работают идентично функциональным выражениям.

Классы

 
var user = new Person ('Дэвид', 33);


class Person {
  конструктор (имя, возраст) {
    this.name = имя;
    this.age = возраст;
  }
}
  

 
class Person {
  конструктор (имя, возраст) {
    this.name = имя;
    this.age = возраст;
  }
}


var user = new Person ('Дэвид', 33);
console.log (пользователь);
  

 
console.log (typeof Person);

var user = new Person ('Дэвид', 33);


var Person = class {
  конструктор (имя, возраст) {
    this.name = имя;
    this.age = возраст;
  }
};
  

 
console.log (typeof Person);


var Person = class {
  конструктор (имя, возраст) {
    this.name = имя;
    this.age = возраст;
  }
};


var user = new Person ('Дэвид', 33);
console.log (пользователь);
  

 int main ()
{
    int a = 0; // начинается область видимости первой 'а'
    ++ a; // имя 'a' находится в области видимости и относится к первому 'a'
    {
        int a = 1; // начинается область действия второй 'а'
                   // область видимости первой 'а' прерывается
        а = 42; // 'a' находится в области видимости и относится ко второму 'a'
    } // блок заканчивается, область действия второго 'а' заканчивается
      // возобновляется область действия первого 'а'
} // блок заканчивается, область действия первого 'а' заканчивается
int b = a; // Ошибка: имя 'a' не входит в область видимости 

 try {
    f ();
} catch (const std :: runtime_error & re) {// начинается область повторного выполнения
    int n = 1; // начинается область n
    std :: cout << re.what (); // re находится в области видимости
} // область действия заканчивается, область действия n заканчивается
 catch (std :: exception & e) {
    std :: cout << re.what (); // ошибка: re не входит в область видимости
    ++ n; // ошибка: n не входит в область видимости
} 

 Base * bp = new Derived;
if (Производное * dp = dynamic_cast <Производное *> (bp))
{
    dp-> f (); // dp находится в области видимости
} // область действия заканчивается

for (int n = 0; // начинается область n
    n <10; // n находится в области видимости
    ++ n) // n находится в области видимости
{
    std :: cout << n << ''; // n находится в области видимости
} // объем n заканчивается 

 const int n = 3;

int f1 (int n, // область глобального 'n' прервана,
                  // начинается область действия параметра 'n'
       int y = n); // ошибка: аргумент по умолчанию ссылается на параметр

int (* (* f2) (int n)) [n]; // ОК: область действия параметра функции 'n'
                        // заканчивается в конце декларатора своей функции
                        // в деклараторе массива глобальное n находится в области видимости
// (объявляется указатель на функцию, возвращающую указатель на массив из 3 int

// напротив
авто (* f3) (int n) -> int (*) [n]; // ошибка: параметр 'n' как привязанный к массиву


int f (int n = 2) // начинается область видимости 'n'
try // функция try block
{// тело функции начинается
   ++ n; // 'n' находится в области видимости и относится к параметру функции
   {
      int n = 2; // начинается область видимости локальной переменной 'n'
                 // область действия параметра функции 'n' прервана
      ++ n; // 'n' относится к локальной переменной в этом блоке
    } // область локальной переменной 'n' заканчивается
                 // область действия параметра функции 'n' возобновляется
} ловить(...) {
   ++ n; // n находится в области видимости и относится к параметру функции
   бросать;
} // последний обработчик исключений завершается, область действия параметра функции 'n' заканчивается
int a = n; // ОК: глобальное 'n' находится в области 

 namespace N {// начинается область N (как член глобального пространства имен)
    int i; // начинается область действия i
    int g (int a) {вернуть; } // начинается область действия g
    int j (); // начинается область j
    void q (); // начинается область видимости q
    namespace {
        int x; // область видимости x начинается
    } // объем x не заканчивается
    inline namespace inl {// начинается область inl
      int y; // начинается область видимости y
    } // объем y не заканчивается
} // область видимости i, g, j, q, inl, x, y прервана

namespace {
    int l = 1; // начинается область l
} // область l не заканчивается (это член безымянного пространства имен)

namespace N {// область видимости i, g, j, q, inl, x, y продолжается
    int g (char a) {// перегружает N :: g (int)
        вернуть l + a; // l из безымянного пространства имен находится в области видимости
    }
    int i; // ошибка: повторяющееся определение (i уже в области видимости)
    int j (); // ОК: повторное объявление функции разрешено
    int j () {// ОК: определение ранее объявленного N :: j ()
        вернуть g (i); // вызывает N :: g (int)
    }
    int q (); // ошибка: q уже находится в области видимости с другим типом возврата
} // область видимости i, g, j, q, inl, x, y прервана

int main () {
    используя пространство имен N; // область видимости i, g, j, q, inl, x, y возобновляется
    я = 1; // N :: i находится в области видимости
    х = 1; // N: :( анонимно) :: x находится в области видимости
    у = 1; // N :: inl :: y находится в области видимости
    inl :: y = 2; // N :: inl также входит в область видимости
} // область видимости i, g, j, q, inl, x, y прервана 

 класс X {
    int f (int a = n) {// X :: n находится в области видимости внутри параметра по умолчанию
         вернуть a * n; // X :: n находится в области видимости внутри тела функции
    }
    используя r = int;
    г г ();
    int я = п * 2; // X :: n находится в области видимости внутри инициализатора

// int x [n]; // Ошибка: n не входит в область видимости в теле класса
    статическая константа int n = 1;
    int x [n]; // ОК: n теперь находится в области видимости в теле класса
};

// r X :: g () {// Ошибка: r находится вне области видимости вне тела функции-члена
auto X :: g () -> r {// ОК: конечный возвращаемый тип X :: r находится в области видимости
    return n; // X :: n находится в области видимости в теле внеклассовой функции-члена
} 

 typedef int c; // :: c
перечисление {я = 1}; // :: я
class X {
    char v [i]; // Ошибка: здесь i ссылается на :: i
               // но есть еще X :: i
    int f () {
         return sizeof (c); // ОК: X :: c, а не :: c находится в области видимости внутри функции-члена
    }
    char c; // X :: c
    перечисление {я = 2}; // X :: i
};

typedef char * T;
struct Y {
    Т а; // Ошибка: в этот момент T относится к :: T
         // но есть еще Y :: T
    typedef long T;
    Т б;
}; 

 enum e1_t {// перечисление без области видимости
  А,
  В = А * 2
}; // область действия A и B не заканчивается

enum class e2_t {// перечисление с ограниченной областью видимости
    SA,
    SB = SA * 2 // SA входит в область видимости
}; // область действия SA и SB заканчивается

e1_t e1 = B; // ОК, B находится в области видимости
// e2_t e2 = SB; // Ошибка: SB не входит в область видимости
e2_t e2 = e2_t :: SB; // ОК 

 template 
class X: public Array  // T может использоваться в имени базового класса
{
   // T можно использовать и внутри тела
}; // области действия T и U заканчиваются, область действия X продолжается 

 template