Самый быстрый способ выучить английский язык
Раздел: Сайтостроение / JavaScript /
Область видимости переменных в JavaScript
В этой статье я продолжу разговор о переменных в JavaScript. Слишком углубляться в этот вопрос не буду - в следующих статьях перейду к другой теме. Однако область видимости - это важная часть знаний о переменных. Это то, что должен понимать даже начинающий программист. Поэтому совсем обойти этот вопрос было бы неправильным. Ну а если вы хотите знать всё о переменных, то советую обратить внимание на полноценный обучающий курс:
>>> JavaScript, jQuery и Ajax с нуля до гуру >>>
Область видимости переменной
Область видимости (scope) переменной – это та часть программы, для которой эта переменная определена. То есть та часть программы, где эта переменная “видна” и может быть использована программистом.
Глобальные переменные имеют глобальную область видимости – они определены для всей программы на JavaScript, и, соответственно, могут использоваться в любом месте программы.
Локальные переменные объявляются внутри функции, и видны только внутри (в теле) этой функции. Эти переменные имеют локальную область видимости.
Параметры функций также считаются локальными переменными, определенными только в теле этой функции.
Если у нас есть глобальная переменная Х, а также есть функция, в которой определена локальная переменная с таким же именем Х, то в теле функции будет использоваться именно локальная переменная Х, так как в теле функции локальные переменные имеют преимущество перед глобальными.
В следующем примере будет напечатана фраза “Локальная переменная”:
var Х = "Глобальная переменная";
function CheckScope()
{
//Объявление локальной переменной с тем же именем
var Х = "Локальная переменная";
//Используется локальная переменная, а не глобальная
document.write(Х);
}
CheckScope(); //Выведет фразу "Локальная переменная"
При объявлении глобальной переменной инструкцию var можно не использовать, но при объявлении локальных переменных она обязательна.
Если этого не сделать, то программа может отработать “неожиданно”:
var X = "Глобальная переменная";
function CheckScope()
{
//Попытка объявление локальной переменной
//с тем же именем без использования var
X = "Локальная переменная";
//Используется локальная переменная, а не глобальная
document.write(X);
}
//Выведет фразу "Глобальная переменная"
document.write(X);
//Выведет фразу "Локальная переменная"
//и изменит глобальную переменную Х
CheckScope();
//Выведет фразу "Локальная переменная"
document.write(X);
В этом примере мы “случайно” изменили глобальную переменную, что в большом сценарии может привести к большим неприятностям и труднонаходимым ошибкам.
Функции обычно не знают, какие переменные объявлены в глобальной области видимости и/или для чего они нужны. Поэтому функция, которая использует глобальную переменную вместо локальной, может изменить значение, необходимое какой-либо другой части программы.
СОВЕТ:
Чтобы избежать подобных казусов, объявляйте все переменные с помощью
инструкции var.
Функции могут быть вложены друг в друга. Каждая функция имеет собственную локальную область видимости, поэтому может быть несколько вложенных уровней локальных областей видимости (когда одна область видимости вложена в другую). То есть переменная, объявленная во вложенной функции В, также не будет видна в функции А, как и переменная из функции А не будет видна в сценарии. Например:
var Z = "Глобальная область видимости ";
function A()
{
//Объявление локальной переменной с тем же именем
Z = "Локальная область видимости ";
function B()
{
//Объявление локальной переменной с тем же именем
//во вложенной функции
Z = "Вложенная область видимости ";
//Используется локальная переменная вложенной
//функции В, а не локальная переменная функции А
document.write(Z);
}
B();
}
A(); //Выведет фразу "Вложенная область видимости"
Блочная область видимости
В отличие от таких языков, как C, C++ и Java, в JavaScript нет области видимости на уровне блоков. Все переменные, объявленные внутри функции, независимо от того, где именно это сделано, определены во всей функции.
В следующем примере переменные i, j и k имеют одинаковые области видимости: все три определены во всем теле функции. Это было бы не так, если бы код был написан на C, C++ или Java:
function test(o)
{
var i = 0; //i определена во всей функции
if (o == 0)
{
var j = 0; //j определена везде, а не только в блоке IF
for(var k = 0; k < 10; k++)
{ //k определена везде, не только в цикле
document.write(k);
}
document.write(k); //k все еще определена: печатается 10
}
//j определена, но может быть не инициализирована
document.write(j);
}
Следствием того, что в JavaScript переменные, объявленные в функции, определены во всей функции, может быть “неожиданное” поведение сценария:
var Y = "Глобальная";
function F()
{
alert(Y); //Показывает "undefined", а не "Глобальная".
var Y = "Локальная"; //Переменная инициализируется здесь,
//но определена она везде в функции.
alert(Y); //Показывает "Локальная"
}
F();
На первый взгляд, вызов первого alert() в функции
напечатает «Глобальная», потому что инструкция var,
которая объявляет локальную переменную, еще не была выполнена. Однако согласно
описанному выше правилу локальная переменная определена во всем теле
функции, значит, глобальная переменная с тем же именем скрыта во
всем теле функции. Хотя локальная переменная определена везде, до
выполнения инструкции var она не инициализирована. Поэтому функция
F в предыдущем примере сначала выведет слово "undefined".
СОВЕТ:
Чтобы избежать неожиданностей, подобных описанной выше, всегда объявляйте все локальные переменные в начале функции.
Неопределенные переменные
Из приведённых выше примеров можно сделать вывод, что в JavaScript имеется два вида неопределенных переменных.
Первый – это переменная, которая нигде не объявлена. Попытка прочитать значение необъявленной переменной приведет к ошибке времени выполнения. Необъявленные переменные не определены, потому что они просто не существуют. Я уже говорил, что попытка присвоить значение необъявленной переменной не приведёт к ошибке - просто при присваивании такая переменная неявно объявляется как глобальная.
Неинициализированные переменные
Второй вид неопределенных переменных – переменная, которая была объявлена, но значение ей нигде не присваивалось. Если прочитать значение одной из таких переменных, то будет получено значение undefined (значение по умолчанию для переменных в JavaScript).
Такие переменные называются неинициализированными (unassigned). Это название используется, чтобы отличить их от тех переменных, которые вообще не объявлялись и не существуют.
И хотя это не всё, что можно рассказать о переменных в JavaScript, я пока на этом разговор о них заканчиваю, чтобы читатель не слишком заскучал...
Ну и как всегда напоминаю, что эта статья - лишь капля из моря знаний, полностью погрузиться в которое можно здесь:
>>> JavaScript, jQuery и Ajax с нуля до гуру >>>