Область видимости переменных

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

Если выражение верхнего уровня содержит объявление переменной с ключевым словом local, то эта переменная недоступна за пределами данного выражения. Переменная внутри выражения не влияет на глобальные переменные с тем же именем. Примером может служить объявление local x в блоке begin или if на верхнем уровне.

Имейте в виду, что интерактивная командная строка (REPL) относится к глобальной области модуля Main.

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

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

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

Когда выражение x = <value> используется в локальной области, его значение определяется в Julia по следующим правилам с учетом того, где находится выражение присваивания и на что уже ссылается x в этой части кода.

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

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

Начнем с простой и ясной ситуации — присваивания внутри строгой области, в данном случае внутри тела функции, когда локальной переменной с таким именем еще не существует:

Внутри функции greet присваивание x = "hello" приводит к созданию новой локальной переменной x в области функции. При этом значение имеют два факта: присваивание происходит в локальной области, и локальной переменной x еще нет. Так как x — локальная переменная, не важно, имеется ли глобальная переменная с именем x. Здесь для примера мы выполняем присваивание x = 123 перед определением и вызовом greet.

Так как переменная x в greet локальная, вызов greet не влияет на значение глобальной переменной x (и неважно, существует ли она). Согласно правилу для строгой области, существование глобальной переменной с именем x не учитывается: присваивание значения переменной x в строгой области происходит на локальном уровне (если только переменная x не объявлена как глобальная).

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

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

Как и в предыдущем примере, первое присваивание переменной s в начале функции sum_to приводит к объявлению новой локальной переменной s в теле функции. У цикла for собственная внутренняя локальная область в пределах области функции. В месте, где происходит присваивание s = s + i, локальная переменная s уже существует, поэтому присваивание приводит к изменению значения существующей переменной s, а не к созданию новой локальной переменной. Это можно проверить, вызвав sum_to в REPL.

Так как переменная s является локальной для функции sum_to, вызов функции не влияет на глобальную переменную s. Кроме того, можно заметить, что выражение s = s + i в цикле for изменяет ту же переменную s, которая была создана в результате инициализации s = 0, так как мы получаем правильную сумму 55 для целых чисел от 1 до 10.

Давайте немного остановимся на том факте, что у цикла for собственная область, и напишем немного более развернутый вариант функции, который назовем sum_to_def. В нем сумма s + i сохраняется в переменной t перед изменением s.

Эта версия возвращает s, как и ранее, но также использует макрос @isdefined для возврата логического значения, указывающего, существует ли локальная переменная с именем t, определенная во внешней локальной области функции. Как видно из результата, переменная t не определена вне тела цикла for. Причина снова кроется в правиле для строгой области: так как присваивание значения переменной t происходит внутри функции, которая вводит строгую область, оно приводит к созданию новой локальной переменной t в локальной области, где она появляется, то есть внутри тела цикла. Даже если бы существовала глобальная переменная с именем t, разницы бы не было — на правило для строгой области содержимое глобальной области не влияет.

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

Этот пример иллюстрирует пару важных моментов.

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

Давайте перейдем к ряду более запутанных случаев, где применяется правило нестрогой области. Для этого мы извлечем тела функций greet и sum_to_def в контекст нестрогой области. Сначала давайте поместим тело функции greet в цикл for, который образует нестрогую область, и выполним его в REPL.

Так как глобальная переменная x не определена на момент выполнения цикла for, применяется первое положение правила для нестрогой области и переменная x создается как локальная для цикла for. Поэтому после выполнения цикла глобальная переменная x остается неопределенной. Далее давайте извлечем тело функции sum_to_def в глобальную область и зафиксируем ее аргумент как n = 10.

Что делает этот код? Подсказка: это вопрос с подвохом. Правильный ответ: все зависит от обстоятельств. Если вход в этот код происходит в интерактивном режиме, он выполняется так же, как в теле функции. Но если код выполняется из файла, выводится предупреждение о неоднозначности и происходит ошибка «переменная не определена». Давайте сначала проверим его работу в REPL.

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

Вторым фактом объясняется то, почему в результате выполнения цикла изменяется значение глобальной переменной s, а первым — то, почему переменная t по-прежнему не определена после выполнения цикла. Теперь давайте попробуем выполнить тот же код так, как если бы он содержался в файле.

Здесь мы используем функцию include_string для вычисления code как содержимого файла. Можно было бы также сохранить code в файле, а затем вызвать include для этого файла — результат был бы таким же. Как видите, код в данном случае выполняется совсем не так, как в REPL. Давайте разберемся, что здесь происходит.

Этот пример демонстрирует ряд важных аспектов, связанных с областями: в пределах области каждая переменная может иметь только одно значение, которое не зависит от очередности выражений. Наличие выражения s = t в цикле делает переменную s локальной для него. Это означает, что она также является локальной, когда используется в правой части выражения t = s + i, хотя это выражение вычисляется первым. Можно было бы подумать, что s в первой строке цикла будет глобальной переменной, а s во второй строке — локальной, но это невозможно, так как эти две строки находятся в одном блоке области, а в пределах определенной области каждая переменная может иметь только один смысл.

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

В версиях Julia до 0.6 включительно все глобальные области работали так, как сейчас в REPL: когда присваивание x = <value> происходило в цикле (либо в блоке try/catch или в теле struct), но вне тела функции (либо блока let или включения), решение о том, должна ли переменная x быть локальной для цикла, принималось в зависимости от наличия глобальной переменной с именем x. Преимущество такого подхода в том, что оно интуитивно понятно и удобно, так как максимально похоже на поведение внутри тела функции. В частности, оно позволяет легко переносить код из тела функции в REPL и наоборот при отладке функции. Но есть и недостатки. Во-первых, такой подход сложен для объяснения и понимания: он часто приводил пользователей в замешательство и вызывал жалобы. Вполне справедливые. Во-вторых, что более важно, он создает сложности при написании масштабных программ. В небольшом фрагменте кода наподобие следующего понять, что происходит, несложно.

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

Разобраться, что происходит здесь, уже не так просто. Так как x + "hello" вызовет ошибку метода, представляется вероятным, что намерением было сделать переменную x локальной для цикла for. Однако исходя из значений времени выполнения и существующих методов нельзя определять области переменных. Поведение, принятое в версиях Julia до 0.6 включительно, было особенно опасным по следующей причине: кто-то мог сначала написать цикл for, и он отлично работал, но потом кто-то другой мог добавить совсем в другом месте, возможно в другом файле, новую глобальную переменную и смысл кода менялся. Он либо просто начинал завершаться сбоем, либо, что еще хуже, выполнялся, но с неверным результатом. В грамотно спроектированных языках программирования такой эффект жуткого дальнодействия не должен допускаться.

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

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

Начиная с версии Julia 1.5, этот код работает без аннотации global в интерактивных контекстах, таких как REPL или блокноты Jupyter (как и в Julia 0.6), а в файлах и других неинтерактивных контекстах выводится такое недвусмысленное предупреждение.

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

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

Переменные часто применяются для присвоения имен определенным неизменяющимся значениям. Значения таким переменным присваиваются только один раз. Сообщить о таком присваивании компилятору можно с помощью ключевого слова const.

В одном операторе const можно объявить несколько переменных.

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

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

Особые присваивания верхнего уровня, например выполняемые ключевыми словами function и struct, по умолчанию являются константными.

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

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

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

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

Глобальные привязки можно объявить не только как имеющие константное значение, но и как имеющие константный тип. Это можно сделать, не присваивая фактического значения, с помощью синтаксиса global x::T либо же при присваивании в виде x::T = 123.

При любом присваивании значения глобальной переменной Julia сначала пытается преобразовать его в соответствующий тип с помощью функции convert:

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

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