Js сделать переменную глобальной. JavaScript. Переменные (глобальные, локальные, константы). Побочный эффект забытой декларации var

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

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

Что такое глобальные переменные? Рассмотрим пример...

var global = 21 ; /* Создаем Глобальную переменную */

function myFun () /* Создаем функцию, которая выводит на экран переменную */
{
document.write (global );
}

myFun (); /* Вызываем функцию */

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

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

Что такое локальные переменные? И снова рассмотрим пример...

function myFun _2 () /* Создаем функцию */
{

var local = 42 ;
document.write (local );
}

myFun _2(); /* Вызываем функцию */

Этот пример иллюстрирует создание локальной переменной local . Она локальная, так как создана внутри функции . И только внутри нее может использоваться.

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

function myFun _2 () /* Создаем функцию */
{

var local = 42 ; /* Создаем Локальную переменную */
document.write (local );
}

document.write (local ); /* Пробуем вывести Локальную переменную за пределами функции */

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

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

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

Все это относится к самым начальным, базовым знаниям языка. Без понимания всего этого вы не сможете двигаться дальше и развивать свои навыки программирования в js. К тому же ключевые понятия вам пригодятся не только в данной специализации, а еще и вообще в IT-шной области. Ну что ж, приступим!

Что из себя представляет переменная и как она создается?

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

Переменных может быть огромное количество и все они должны быть с уникальным именем.

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

Кстати, старайтесь с самого первого дня, с первого вашего кода называть элементы логичными и понятными именами. Потому что далее, когда вы будете работать с увесистыми программами, спустя какой-то промежуток времени вы не вспомните, что означает, к примеру, «aa1» или «perem3».

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

Нотацию прочитал, теперь вернемся к объявлению переменных.

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

var text = “Hello, user!”

После этого обращение к text происходит без «var»:

text = “New text.”

В этом случае значение перезапишется.

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

1 2 3 4

var text = “Hello, user!”; alert(text); // выведет “Hello, user!” text= “New text!”; alert(text); // выведет “New text!”

var text = “Hello, user!”; alert(text); // выведет “Hello, user!” text= “New text!”; alert(text); // выведет “New text!”

Особенности глобальных объектов

Все созданные объекты в js-коде делятся на глобальные и локальные. Выше я объяснил, в чем заключается разница между ними. А теперь подробнее разберем глобальные объекты.

Ими являются все функции и переменные, которые объявлены в основном полотне кода, т.е. не внутри каких-то функций. Все они в js автоматически становятся свойствами глобального объекта, который в браузерах явно доступен под словом window. Рассмотрим пример.

var price = 145; // создаем глобальную переменную

alert (window.price); // ответ: 145

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

Подводные камни и область видимости

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

function test() { p = 2; return p; } alert(p); // undefined p = “важный текст”; alert(p); // выведет «важный текст» test(); // вызываем функцию alert(p); // выведет 2

Изначально в функции test я инициализировал локальную переменную со значением 2, а после создал глобальную текстовую переменную, хранящую в себе какие-то важные данные.

И вот тут выскакивает вот та «подводная глыба».

Во-первых, из-за того, что я воспользовался созданием элементов по правилам устаревшего стандарта JavaScript, все переменные “p” были созданы только в момент присвоения (при использовании директивы var переменные создаются сразу со значением undefined, а во время инициализации через «=» значение перезаписывается).

Во-вторых, в этом случае для присвоения значения неявно созданным элементам в js используется существующая или создается новая глобальная переменная. Поэтому в приведенном примере после вызова функции test значение глобальной «p» затерлось.

Во избежание «крушения» всегда используйте ключевое слово var. Тогда все объекты будут объявляться явно и создаваться новые.

Вот исправленный пример:

function test() { var p = 2; alert (p); return p; } alert(p); // undefined var p = "важный текст"; alert(p); // выведет «важный текст» test(); // вызываем функцию, в этом случае выведет 2 alert(p); // выведет «важный текст»

Вот теперь код отрабатывает верно. Как вы заметили, область видимости локальной «p» находится в пределах функции test, а глобальной – во всем остальном коде.

Несколько слов о константах

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

Константа – это вид переменной, значение которой неизменное.

По правилам синтаксиса в js их название всегда пишется строчными (большими) буквами. Например,

var MAIN_COLOR = “#fff”

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

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

В JavaScript , существует две области видимости: локальная и глобальная. Зависит от того, где объявлена переменная, внутри функции или вне функции.

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

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

Глобальные переменные в JavaScript

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

Var russia; russia = "Россия"; function getValueRussia() { alert(russia); } getValueRussia();

Здесь russia — это глобальная переменная, так как она объявлена вне функции. Чтобы доказать что переменная глобальная, мы обратились к ней изнутри пользовательской функции getValueRussia() , с помощью функции alert() которая вывела на экран значение переменной russia .

Локальные переменные в JavaScript

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

Function getValueRussia() { var russia; russia = "Россия"; } alert(russia);

В данном примере, ничего не произойдет (окошко с надписью «Россия» , не появится) , а если просмотреть скрипт через консоль, то он сообщит нам том что переменная russia — не определена (undefined), это означает что функция alert() (размещённая вне функции), не видит переменную russia , которую создали внутри функции.

Function getValueRussia() { var russia; russia = "Россия"; alert(russia); } getValueRussia();

Разместив функцию alert() внутри функции и затем вызвав функцию getValueRussia() , мы увидим окошко с надписью «Россия» . Данные примеры показывают нам, что к локальным переменным можно обращаться только внутри функции, в которой они созданы.

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

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

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

В программном коде верхнего уровня сослаться на глобальный объект можно также посредством ключевого слова this:

Alert(this === window); // true

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

Var num = 10; alert(window.num); // 10

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

Window.num = 10; alert(num); // 10

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

Var num = 10; alert(num); // 10 alert(window.num); // 10. Тоже самое, что и alert(num);

Если глобальная переменная объявляется с помощью ключевого слова var или let , создаётся ненастраиваемое свойство, т. е. свойство, которое невозможно удалить с помощью оператора delete:

Var num = 10; alert(delete num); // false, переменная не удалена

Если необъявленной переменной присвоить некоторое значение, интерпретатор JavaScript автоматически создаст глобальную переменную. Переменные созданные таким способом, становятся обычными, настраиваемыми свойствами глобального объекта, т. е. могут быть удалены с помощью оператора delete:

Num = 10; alert(delete num); // true, переменная удалена

Методы Метод Описание

decodeURI()	Возвращает строку, содержащую URI в декодированном виде.
decodeURIComponent()	Возвращает строку, содержащую часть URI в декодированном виде.
encodeURI()	Возвращает строку, содержащую URI в закодированном виде.
encodeURIComponent()	Возвращает строку, содержащую часть URI в закодированном виде.
eval()	Функция eval() выполняет код, переданный ей в виде строки. Код, переданный функции, выполняется в той области видимости, где была вызвана функция.
isFinite()	Преобразует аргумент в число (если это необходимо) и возвращает true, если аргумент содержит любое значение отличное от NaN, положительной и отрицательной бесконечности. В этих трех случаях возвращает false.
isNaN()	Определяет является передаваемый аргумент значением NaN или нет.
parseFloat()	Анализирует строковый аргумент и возвращает число с плавающей точкой или NaN.
parseInt()	Анализирует строковый аргумент и возвращает целое число или NaN.

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

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

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

• Время на изучение и понимание проблемы.
• Время на понимание кода, который является источником проблемы.

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

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

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

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

Легко поддерживаемый код имеет следующие признаки:

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

Минимизация использования глобальных переменных

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

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

Var myglobal = "hello"; console.log(myglobal); // "hello" console.log(window.myglobal); // "hello" console.log(window["myglobal"]); // "hello" console.log(this.myglobal); // "hello"

Проблемы с глобальными переменными

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

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

• Другие библиотеки JavaScript.
• Скрипты партнеров по рекламе.
• Код для отслеживания пользователей и аналитики.
• Разные виджеты, кнопки и плагины.

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

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

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

Function sum(x, y) { // плохо: подразумеваемое глобальное result = x + y; return result; }

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

Правило минимизации заключается в определении переменных с помощью директивы var . Ниже приводится улучшенная версия функции sum() :

Function sum(x, y) { var result = x + y; return result; }

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

// плохо, не надо использовать function foo() { var a = b = 0; // ... }

Если вы удивлены происходящим, то дело здесь в вычислениях справа-налево. Сначала выполняется выражение b = 0 , и поэтому переменная b не будет объявлена. Возвращаемое значение выражения будет 0, и оно присваивается новой локальной переменной a , которая объявлена директивой var. Такое определение переменных эквивалентно следующей записи:

Var a = (b = 0);

Если вы уже объявили переменные, то цепочное представление будет отлично работать и не создаст нежелательных глобальных переменных:

Function foo() { var a, b; a = b = 0; // обе переменных являются локальными }

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

Побочный эффект забытой декларации var

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

• Глобальная переменная, объявленная декларацией var (созданная в программе вне функций) не может быть удалена.
• Подразумеваемая глобальная переменная, созданная без объявления (вне зависимости от места создания) может быть удалена.

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

// определяем три глобальных переменных var global_var = 1; global_novar = 2; // плохо (function () { global_fromfunc = 3; // плохо }()); // Пробуем удалить delete global_var; // false delete global_novar; // true delete global_fromfunc; // true // Проверка удаления typeof global_var; // "number" typeof global_novar; // "undefined" typeof global_fromfunc; // "undefined"

Доступ к глобальному объекту

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

Var global = (function () { return this; }());

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

Шаблон одного объявления var

Использование одного объявления var вверху вашей функции является очень полезной практикой. Такой метод имеет следующие преимущества:

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

Шаблон с одним объявлением var выглядит следующим образом:

Function func() { var a = 1, b = 2, sum = a + b, myobject = {}, i, j; // Код функции... }

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

Также можно выполнить операцию при объявлении переменной, например, sum = a + b из предыдущего кода примера. Другим рабочим примером служит оперирование с DOM. Вы можете назначать ссылки на элементы DOM локальным переменным при объявлении:

Function updateElement() { var el = document.getElementById("result"), style = el.style; // выполняем операции с el и style... }

Подъем: проблема с разбросанными декларациями var

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

// плохо myname = "global"; // глобальная переменная function func() { alert(myname); // "undefined" var myname = "local"; alert(myname); // "local" } func();

В данном примере ожидается, что первый вызов функции alert() выдаст сообщение “global”, а второй - “local.” Разумное ожидание, так как при первом вызове локальная переменная myname не объявлена, и функция должна использовать глобальную переменную myname . Но в действительности все работает иначе. Первый вызов функции alert() выдаст “undefined” потому, что myname рассматривается как объявленная локальная переменная в функции (хотя объявление будет позже). Все объявления переменных поднимаются вверх функции. Следовательно, чтобы избежать такого типа ошибок, нужно объявлять все переменные вверху функции.

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

Myname = "global"; // глобальная переменная function func() { var myname; // то же, что и -> var myname = undefined; alert(myname); // "undefined" myname = "local"; alert(myname); // "local" } func();

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