Область видимости переменных: Область видимости. Основы | Особенности разработки на JavaScript

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

Последнее обновление: 24.01.2022

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

Глобальный контекст

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

name = "Tom"


def say_hi():
    print("Hello", name)


def say_bye():
    print("Good bye", name)

say_hi()
say_bye()

Здесь переменная name является глобальной и имеет глобальную область видимости. И обе определенные здесь функции могут свободно ее использовать.

Локальный контекст

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

def say_hi():
    name = "Sam"
    surname = "Johnson"
    print("Hello", name, surname)


def say_bye():
    name = "Tom"
    print("Good bye", name)

say_hi()
say_bye()

В данном случае в каждой из двух функций определяется локальная переменная name. И хотя эти переменные называются одинаково, но тем не менее это две разных переменных, каждая из которых доступна только в рамках своей функции. Также в функции say_hi() определена переменная surname, которая также является локальной, поэтому в функции say_bye() мы ее использовать не сможем.

Скрытие переменных

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

name = "Tom"


def say_hi():
    name = "Bob"        # скрываем значение глобальной переменной
    print("Hello", name)


def say_bye():
    print("Good bye", name)


say_hi()    # Hello Bob
say_bye()   # Good bye Tom

Здесь определена глобальная переменная name. Однако в функции say_hi определена локальная переменная с тем же именем name. И если функция say_bye использует глобальную переменную, то функция say_hi использует локальную переменную, которая скрывает глобальную.

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

name = "Tom"


def say_hi():
    global  name
    name = "Bob"        # изменяем значение глобальной переменной
    print("Hello", name)


def say_bye():
    print("Good bye", name)


say_hi()    # Hello Bob
say_bye()   # Good bye Bob

nonlocal

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

def outer():  # внешняя функция
    n = 5

    def inner():    # вложенная функция
        print(n)

    inner()     # 5
    print(n)


outer()     # 5

Здесь вложенная локальная функция inner() выводит на консоль значение переменной n, которая определена во внешней функции outer(). Затем в функции outer() вызывается внутренняя функция inner().

При вызове функции outer() здесь мы ожидаемо увидим на консоли два раза число 5. Однако в данном случае вложенная функция inner() просто получает значение. Теперь возьмем другую ситуацию, когда вложенная функция присваивает значение переменной:

def outer():  # внешняя функция
    n = 5

    def inner():    # вложенная функция
        n = 25
        print(n)

    inner()     # 25
    print(n)


outer()     # 5 
# 25    - inner
# 5     - outer

При присвоении значения во вложенной функции: n = 25 будет создаваться новая переменная n, которая скроет переменную n из окружающей внешней функции outer. В итоге мы получим при выводе два разных числа. Чтобы во вложенной функции указать, что идентификатор во вложенной функции будет представлять переменную из окружающей функции, применяется выражение nonlocal:

def outer():  # внешняя функция
    n = 5

    def inner():    # вложенная функция
        nonlocal n  # указываем, что n - это переменная из окружающей функции
        n = 25
        print(n)

    inner()     # 25
    print(n)


outer()          # 25

НазадСодержаниеВперед

область видимости простыми словами / Хабр

Доброго времени суток, друзья!

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

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

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

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

Допустим, мы определили переменную:

const message = 'Hello'
console.log(message) // 'Hello'

Мы легко можем вывести ее значение в консоль. Это понятно.

Теперь поместим объявление переменной message в блок if:

if (true) {
    const message = 'Hello'
}
console.log(message) // ReferenceError: message is not defined

На этот раз при попытке доступа к переменной выбрасывается исключение ReferenceError: message is not defined.

Почему это произошло?

Потому что блок if создал область видимости для переменной message. И message доступна только внутри этой области.

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

Итак, область видимости — это зона доступности переменных.

2. Блочная область видимости

Блок кода в JavaScript определяет область видимости переменных, объявленных с помощью ключевых слов const и let:

if (true) {
    // область видимости блока if
    const message = 'Hello'
    console.log(message) // 'Hello'
}
console.log(message) // ReferenceError

Первый console.log() благополучно выводит значение переменной message в консоль, поскольку доступ к этой переменной осуществляется в той области видимости, в которой она определена.

Однако вызов второго console.log() приводит к возникновению ошибки, поскольку переменная message недоступна во внешней по отношению к ней области видимости: в текущем контексте message не существует.

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

Например:

for (const color of ['green', 'red', 'blue']) {
    // область видимости блока for
    const message = 'Hi'
    console.
 
  log(color) // 'green', 'red', 'blue'
    console.log(message) // 'Hi', 'Hi', 'Hi'
}
console.log(color) // ReferenceError
console.log(message) // ReferenceError

Переменные color и message существуют только внутри блока for.

Тоже самое справедливо для инструкции while:

while (/* условие */) {
    // область видимости блока while
    const message = 'Hi'
    console.log(message) // 'Hi'
}
console.log(message) // ReferenceError

message, определенная в while, доступна только внутри данного цикла.

В JavaScript вы можете создавать самостоятельные блоки кода. Они также определяют собственную область видимости:

{
    const message = 'Hi'
    console.log(message) // 'Hi'
}
console.log(message) // ReferenceError

2.1. var не имеет блочной области видимости

Как мы видели в предыдущих примерах, блок кода создает область видимости для переменных, объявленных с помощью ключевых слов const и let. Однако это не работает для переменных, объявленных с помощью ключевого слова var.

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

if (true) {
    // область видимости блока if
    var count = 0
    console.log(count) // 0
}
console.log(count) // 0

Переменная count, как и ожидалось, доступна внутри блока if. Однако, она доступна и за пределами данного блока!

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

3. Область видимости функции

Функции в JavaScript создают область видимости для всех переменных, независимо от того, с помощью какого ключевого слова они объявлены (var, const или let).

Например:

function run() {
    // область видимости функции run()
    var message = 'Беги, Форрест, беги!'
    console.log(message)
}
run() // 'Беги, Форрест, беги!'
console.log(message) // ReferenceError

Функция run() создает область видимости. Переменная message доступна внутри функции, но недоступна снаружи.

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

function run() {
    // область видимости функции run()
    const two = 2
    let one = 1
    function run2() {}
    var run3 = () => {}
    console. log(two)
    console.log(one)
    console.log(run2)
    console.log(run3)
}
run() // 2 1 ƒ run2() {} () => {}
console.log(two) // ReferenceError
console.log(one) // ReferenceError
console.log(run2) // ReferenceError
console.log(run3) // ReferenceError

4. Область видимости модуля

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

Модуль circle создает константу pi (для внутреннего использования):

// область видимости модуля circle
const pi = 3.14
console.log(pi) // 3.14
// использование pi

Переменная pi объявляется внутри модуля circle и не экспортируется из него.

Затем модуль circle импортируется:

import './circle'
console.log(pi) // ReferenceError

Переменная pi недоступна за пределами модуля circle (до тех пор, пока она не будет экспортирована с помощью export).

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

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

5. Области видимости могут быть вложенными

Интересной особенностью областей видимости является то, что они могут быть вложены одна в другую.

В следующем примере функция run() создает область видимости, а внутри нее блок if создает еще одну область:

function run() {
    // область видимости функции run()
    const message = 'Беги, Форрест, беги!'
    if (true) {
        // область видимости блока if
        const friend = 'Бубба'
        console.log(message) // 'Беги, Форрест, беги!'
    }
    console.log(friend) // ReferenceError
}
run()

Область видимости блока if вложена в область видимости функции run().

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

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

Что насчет доступности переменных? Нужно запомнить простое правило:

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

Поэтому переменная message доступна внутри блока if.

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

Глобальная область видимости является самой внешней областью. Она доступна для любой внутренней или локальной области видимости. В браузере глобальной является область видимости, создаваемая при загрузке JavaScript-файла, указанного в атрибуте src тега script:

<script src="script.js">

// script.js
// глобальная область видимости
let counter = 1

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

Глобальная область видимости — это механизм, который позволяет среде выполнения JavaScript-кода (браузеру, Node.js) предоставлять приложениям хостовые (т. е. принадлежащие среде) объекты как глобальные переменные.

Например, window и document являются глобальными переменными (объектами), предоставляемыми браузером. В Node.js такой переменной является, например, объект process.

7. Лексическая область видимости

Определим две функции, одна из которых вложена в другую:

function outer() {
    // область видимости функции outer()
    let v = 'Я из области видимости функции outer()!'
    function inner() {
        // область видимости функции inner()
        console.log(v) // 'Я из области видимости функции outer()!'
    }
    return inner
}
const f = outer()
f()

Взгляните на последнюю строку: функция inner() вызывается за пределами области видимости функции outer(). Как JavaScript понимает, что значение, выводимое в консоль в функции inner(), принадлежит переменной v, объявленной в фукнции outer()?

Ответ: благодаря лексической области видимости.

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

Формальное определение лексической области гласит следующее:

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

В приведенном примере лексическая область видимости функции inner() состоит из области видимости функции outer().

Более того, inner() — это замыкание, поскольку в ней используется значение переменной из лексической области видимости.

8. Изоляция переменных

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

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

Например:

function foo() {
    // область видимости функции foo()
    let count = 1
    console.log(count) // 1
}
function bar() {
    // область видимости функции bar()
    let count = 2
    console.log(count) // 2
}
foo()
bar()

Заключение

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

В JavaScript области видимости создаются блоками, функциями и модулями.

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

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

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

Надеюсь статья была вам полезной. Благодарю за внимание.

11B: переменная область видимости | Computer Science Circles

Урок 11 состоит из трех частей A, B, C, которые можно выполнять в любом порядке.

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

Пример переменной области видимости

Для этого примера частью нашей программы будет следующая функция:

 def Square(x):
   значение = х * х
   возвращаемое значение 

Это функция, которая вычисляет квадрат числа x , например, квадрат(5) возвращает 25 . Теперь предположим, что мы вызываем Square из другой части программы, которая также использует переменную value для другой цели:

 # здесь начинается основная часть программы
значение = 17
пять в квадрате = квадрат (5)
печать (пять квадратов, значение) 

Вопрос, что будет напечатано в этом сценарии? Есть две возможности, если мы не знаем, как работает Python:

1. Одна из возможностей состоит в том, что Python распознает, что две переменные value должны быть каким-то образом «разделены». Таким образом, вызов в квадрате вернет 25, но значение value в основной части останется равным 17, и мы увидим вывод 25 17 .
2. Другая возможность состоит в том, что когда квадрат , выполняется, перезаписывает существующее значение значением на 25, и мы видим вывод 25 25 .

Посмотрим, что будет на самом деле!

Мы видим, что поведение Python соответствует варианту №1. На самом деле, всякий раз, когда вы вызываете функцию, вы не можете влиять на какие-либо переменные, определенные вне этой функции. Вместо этого любые операторы, присваивающие значения переменным, влияют только на «локальную» переменную, которая находится «внутри» вызова функции. причина того, что Python и большинство других языков работают таким образом, заключается в том, что он значительно упрощает написание длинных программ с множеством функций. В частности, когда мы определяем новую функцию, нам всегда разрешено использовать любые имена переменных внутри функции (включая распространенные, такие как result,   temp  и i ), даже если они используются где-то еще для других целей. .

Чтобы увидеть это подробнее, посмотрите на «Шаг 6 из 8» в визуализаторе. Обратите внимание, что есть два разных значение переменных: одна внутри функции квадрата и одна снаружи (в «глобальной» области).

Упражнение с множественным выбором: внутреннее и внешнее

Что выводит следующая программа?

 x = "внешний" 
 def xReplace(значение): 
 x = значение 
 xReplace("внутренний") 
 print(x) 

Ваш выбор: Выберите один внешнийвнутреннийПрограмма вызывает ошибку.

Правильно! Оператор x = значение влияет только на локальную версию переменной 9.0021 x внутри функции. Глобальная версия x не меняется. (Поэтому функция xReplace бесполезна и никогда не дает никакого эффекта.)

Еще одна концепция, аналогичная области действия , — это пространство имен ;  пространство имен похоже на область действия пакета. Таким образом, даже если вы импортируете пакет (например, math ), в котором где-то используется имя переменной x , оно не пересекается с переменной x , используемой вашей программой, поскольку они находятся в разных пространствах имен.

Правила области видимости: наблюдение

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

Пример

Чтение глобальной переменной из функции

favouriteTopping=’пепперони’ def orderПицца(n): print(«Хочу», str(n), favouriteTopping, «пицца») заказатьПиццы(3)

Здесь локальная область видимости не содержала переменную с именем favouriteTopping , , но это не вызвало ошибку . Правило Python для оценки переменных заключается в том, что если необходимо оценить переменную, которая не существует в локальной области видимости, она ищет ее в глобальной области видимости. В нашем случае он действительно нашел избранное, опережая в глобальной области видимости. (В более общем случае, когда одно тело функции вызывает другую функцию, у вас будет три области видимости; Python всегда сначала проверяет «самую локальную» область и переходит пошагово к глобальной области видимости, пока не будет найдена переменная.)

Два приведенных выше примера с orderPizzas и xReplace почти синтаксически идентичны. Почему Python создает новую локальную переменную x в xReplace , но не создает новую избраннуюВверх в orderPizzas ? Правило Python следующее: если вы только читаете переменную, то новая локальная переменная не создается; но если вы запишете переменную хотя бы один раз, то переменная будет рассматриваться как локальная во всем теле функции. (Это наиболее частая причина UnboundLocalError : см. эти два вопроса [1, 2] в официальной документации по Python. g  до 0 , но терпит неудачу). глобальный  Изменения Как и многие другие вещи, описанный выше нормальный поток работает в 99% всех ситуаций. Но в оставшемся 1% случаев вы действительно можете захотеть изменить глобальную переменную из функции. Python позволяет вам сделать это с помощью глобальный оператор . Это модификация более раннего примера xReplace . Обратите внимание, что мы объявляем переменную как global в функции. Это позволяет изменять глобальное значение внутри функции. Повторяю: внутри функции присвоение имени переменной, определенной в глобальной области, фактически создает отдельную новую переменную локальной области с тем же именем вместо изменения переменной глобальной области (например, resetToZero ). Если вы хотите обновить глобальную переменную, вы должны включить оператор global «variable-name»  внутри функции (например, фиксированный пример xReplace ). Затем Python понимает, что изменения в «имя переменной» в функции предназначены для ссылки на существующую переменную глобальной области видимости. Как мы упоминали ранее, чтение глобальной переменной не требует использования оператора global ; только пишет . На этом урок окончен! Переменные и область видимости — учебник по вычислительной биологии В главе 18 «Функции Python» мы узнали, что функция должна использовать только те переменные, которые либо были определены в блоке функции, либо переданы явно как параметры (Правило 1). Это правило тесно связано с нашим определением переменной в Python как имени, которое ссылается на некоторые данные. Это мощная концепция, позволяющая нам передавать параметры функциям и получать возвращаемые значения. В Питоне на один фрагмент данных может ссылаться несколько переменных . Переменные параметров — это новые имена для тех же данных. Мы можем изучить эту концепцию на простом примере. В этом примере кода мы создали один список, но мы связываем с ним два имени переменных: nums и numsb . Когда мы изменяем список через одно имя, изменение отражается через другое (мы можем изменять только данные, потому что списки изменяемы, но даже неизменяемые данные могут называться несколькими именами). То же самое происходит, когда мы используем параметр в функции. Давайте еще раз вернемся к функции gc_content() , которая использует написанную нами функцию base_composition() (но опустим ее для ясности). В этом листинге все имена переменных, принадлежащих функции, выделены красным цветом, тогда как другие «глобальные» имена переменных выделены фиолетовым цветом и подчеркнуты пунктирной линией. Согласно правилу 1, мы не должны видеть фиолетовые/подчеркнутые переменные в определении функции. Вне функции строковые данные "ACCCTAGACTG" были присвоены переменной seq3 , но внутри функции они были присвоены переменной seq . Внутри функции на значение данных 0,54 ссылалась переменная gc , а вне ее — seq3_gc . [1] Мы знаем, что мы можем получить доступ к переменной seq3 изнутри функции, даже если не должны. Но как насчет наоборот? Можем ли мы получить доступ к gc переменная, которая была определена внутри функции, вне функции? На самом деле, мы не можем. Приведенная выше строка print(gc) , даже после вычисления seq3_gc , выдаст ошибку NameError: имя 'gc' не определено . Эта ошибка возникает из-за того, что переменные имеют область действия , а область действия переменной gc ограничена с момента ее определения до конца функционального блока, в котором она определена (все переменные, выделенные красным цветом, разделяют эту функцию) . Переменные с ограниченной областью действия называются локальные переменные . Область переменной — это контекст, в котором ее можно использовать. Он определяет, «как долго живет переменная» или «где эта переменная существует». Переменная с ограниченной областью действия, как при выполнении функции, называется локальной переменной . После завершения вызова функции картина будет выглядеть примерно так: В конце концов сборщик мусора заметит, что никакие переменные не ссылаются на данные 2 , 4 и 11 , и он очистит их от ОЗУ, чтобы освободить место для новых данных. Поскольку область видимости говорит о переменных, она имеет мало общего с данными, на которые ссылается переменная, за исключением того, что данные удаляются сборщиком мусора, когда ни в одной текущей области видимости нет переменных, ссылающихся на эти данные. Тем не менее, поскольку переменная gc не находится в области видимости после завершения функции, мы не можем использовать ее вне функционального блока. Одна из особенно интересных и мощных особенностей локальных переменных заключается в том, что они существуют независимо от любых других переменных, которые могут существовать в то же время с тем же именем (иногда говорят, что они «затеняют» другие переменные с тем же именем). Рассмотрим следующий код: Как вы думаете, что напечатает последняя строка, print(gc) ? Если вы угадали "Мера оснований G и C в последовательности" , вы правы! Хотя функция gc_content() определяет свою собственную переменную gc , поскольку эта переменная является локальной, она не «наступает» на внешнюю переменную gc . Итого: Переменные, определенные в функции (и параметры функции), являются локальными по отношению к вызову функции. Эти локальные переменные «затеняют» любые другие переменные, которые могут существовать во время выполнения функции. Когда вызов функции завершается, локальные переменные забываются. Один из важных уроков масштаба — знать, когда это может привести к проблемам. Проще всего это увидеть, если бы мы сравнили работу области видимости с другим языком, в данном случае с C++. В C++ переменные объявляются вместе с их типами, а переменные, объявленные в блоке оператора if (или в любом другом блоке), также являются локальными для этого блока. Это означает, что они выходят за рамки , когда блок заканчивается. Если бы мы попытались использовать их вне блока, в котором они были объявлены, возникла бы ошибка. В Python, с другой стороны, переменные, объявленные в операторах if, блоках цикла for и блоках цикла while, не являются локальными переменными и остаются в области видимости вне блока. Таким образом, мы говорим, что C++ имеет область видимости «на уровне блоков», в то время как Python использует область видимости только на «функциональном уровне». Скобки на рисунке ниже иллюстрируют область действия некоторых переменных в эквивалентном коде C++ и Python. Поскольку C++ использует область видимости на уровне блоков, а x и y объявлены внутри блоков, мы не можем получить доступ к их содержимому за пределами этих блоков. Это может показаться преимуществом для Python, но в данном случае мы думаем, что C++ может быть прав. В конце концов, если бы нам требовалось для того, чтобы переменные y и z были доступны после блоков if в примере C++, мы могли бы объявить их вместе с x . Мы могли бы даже дать им значение по умолчанию для хранения, используя такие объявления, как int y = -1 и int z = -1 ; если эти переменные все еще содержат -1 после запуска блоков if, то мы знаем, что эти внутренние строки не выполнялись. Это было бы особенно полезно, если бы значение x не было установлено на пять, как здесь, а скорее зависит от входных данных. С другой стороны, в Python такой код может вызвать проблему. Если переменная x зависит от входных данных, то переменные y и z могут вообще никогда не устанавливаться, что в конечном итоге приведет к ошибке NameError при последующем доступе к ним. Мы уж точно не должны считать программу, которая иногда выдает ошибку, в зависимости от входных данных, очень хорошей! Вероятно, лучший способ решить проблему такого рода — представить, что Python использует область видимости на уровне блоков, объявляя переменные в самом широком блоке/уровне, на котором они будут использоваться. Нет — это хорошее значение по умолчанию, которое мы можем проверить позже, если мы хотим условно выполнить более поздний код на основе того, действительно ли переменные были установлены на что-то полезное: Этот код не сработает, независимо от значения x . Установка начальных значений для этих переменных на Нет перед блоками if также дает напоминание и визуальную подсказку о том, что эти переменные предназначены для использования вне вложенных блоков if и что мы должны проверить их содержимое, прежде чем использовать их позже. Таким образом, C++ и другие языки с блочной областью видимости поощряют «короткоживущие» переменные, что является хорошей мантрой программирования. Определение переменных только при необходимости и их использование в течение как можно более короткого времени помогает создавать более четкий, более модульный и даже более эффективный код (поскольку кратковременные переменные позволяют сборщику мусора очищать больше данных). В некотором смысле нарушение правила 1 для функций похоже на злоупотребление областью видимости переменных. Начинающим программистам часто легче избежать этих соглашений, установив большое количество переменных в начале программы, а затем получив доступ и установив их в различных точках программы. Это иногда в просторечии называют «спагетти-кодом», потому что дальние связи, создаваемые между различными областями кода, напоминают спагетти. Однако эта стратегия редко окупается. Как обсуждалось в главе 25 «Алгоритмы и структуры данных», локальные переменные и подобные концепции позволяют нам решать сложные задачи увлекательными и элегантными способами. Упражнения Создайте диаграмму ОЗУ/переменных, иллюстрирующую следующий сегмент кода, и используйте ее для объяснения вывода на печать. Создайте диаграмму ОЗУ/переменных, иллюстрирующую следующий сегмент кода, и используйте ее для объяснения вывода на печать. Выполните следующий код и создайте диаграмму ОЗУ/переменных для каждого момента достижения «#point». Оставить комментарий Добавить комментарий Отменить ответ Ваш адрес email не будет опубликован. Обязательные поля помечены * Комментарий * Имя * Email * Сайт