Переменные

Объявление переменных

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

Var i; var sum;

Один раз использовав ключевое слово var, можно объявить несколько переменных:

Объявление переменных можно совмещать с их инициализацией:

Var message = "привет"; var i = 0, j = 0, k = 0;

Если начальное значение в инструкции var не задано, то переменная объявляется, но ее начальное значение остается неопределенным (undefined), пока не будет изменено программой.

Если вы имеете опыт использования языков программирования со статическими типами данных, таких как C# или Java, то можете заметить, что в объявлениях переменных в языке JavaScript отсутствует объявление типа. Переменные в языке JavaScript могут хранить значения любых типов. Например, в JavaScript допускается присвоить некоторой переменной число, а затем этой же переменной присвоить строку:

Var i = 10; i = "hello";

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

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

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

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

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

Var result = "global"; function getResult() { var result = "local"; return result; }; console.log(getResult()); // Отобразит "local"

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

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

Вот именно с этим мы с вами и будем разбираться в этом уроке.

Глобальная переменная

К глобальным относятся все переменные, которые вы создаете вне функции. И обязательно надо создавать переменную через ключевое слово var, если этого не сделать то переменная будет видна везде в программе и более того при включенном режиме strict mode это вызовет ошибку. Для того чтобы включить режим strict mode достаточно в начале вашего сценария написать строку «use strict». Это будет указывать интерпретатору JavaScript, что надо строго соблюдать стандарт JavaScript. Вот пример с использованием глобальной переменной

Var a =6; //глобальная переменная function double() { return alert(a*a); //использование глобальной переменной } double();

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

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

Var a =6; function double() { a = 5; //меняем значение глобальной переменной в функции return alert(a*a); } double(a); //вызываем функцию document.write(a); //значение глобальной переменной

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

Локальная переменная.

Когда вы объявляете переменную в функции, то она становится локальной и к ней можно получить доступ только из функции. Стоит заметить, что операторы if/else , for, while, do…while не влияют на область видимость переменных.

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

Function double() { var a =6; return alert(a*a); } double(); document.write(a); //пытаемся обратиться к локальной переменной

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

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

Var a =7; function double() { var a =6; return alert(a*a); } document.write(a);

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

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

Итоги.

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

Из функции можно получить доступ к глобальной переменной и изменить ее значение.

Продолжаем изучать тему функций в 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”

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

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