Js глобальная переменная в функции. JavaScript: Глобальный объект. Особенности глобальных объектов

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

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

В 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, переменная удалена

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

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

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

var x = 5; let d = 8; function displaySquare(){ var z = x * x; console.log(z); }

Здесь переменные x и d являются глобальными. Они доступны из любого места программы.

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

Переменная, определенная внутри функции, является локальной:

Function displaySquare(){ var z = 10; console.log(z); let b = 8; console.log(b); }

Переменные z и b являются локальными, они существуют только в пределах функции. Вне функции их нельзя использовать:

Function displaySquare(){ var z = 10; console.log(z); } console.log(z); //ошибка, так как z не определена

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

Что если у нас есть две переменных - одна глобальная, а другая локальная, которые имеют одинаковое имя:

Var z = 89; function displaySquare(){ var z = 10; console.log(z); // 10 } displaySquare(); // 10

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

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

Let z = 10; function displayZ(){ let z = 20; { let z = 30; console.log("Block:", z); } console.log("Function:", z); } displayZ(); console.log("Global:", z);

Здесь внутри функции displayZ определен блок кода, в котором определена переменная z. Она скрывает глобальную переменную и переменную z, определенную на уровне функции. В реальной программе блок мог быть предеставлять вложенную функцию, блок цикла for или конструкции if. Но в любом случае такой блок определяет новую область видимости, вне которого переменная не существует.

И в данном случае мы получим следующий консольный вывод:

Block: 30 Function: 20 Global: 10

С помощью оператора var мы не можем определить одновременно переменную с одним и тем же именем и в функции, и в блоке кода в этой функции:

Function displaySquare(){ var z = 20; { var z = 30; // Ошибка! Переменная z уже определена console.log("Block:", z); } console.log("Function:", z); }

То есть с помощью var мы можем определить переменную с одним именем либо на уровне функции, либо на уровне блока кода.

Все, что относится к оператору let, относится и к оператору const, который позволяет определить константы. Блоки кода задают область видимости констант, а константы, определенные на вложенных блоках кода, скрывают внешние константы с тем же именем:

Const z = 10; function displayZ(){ const z = 20; { const z = 30; console.log("Block:", z); // 30 } console.log("Function:", z); // 20 } displayZ(); console.log("Global:", z); // 10

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

Function bar(){ foo = "25"; } bar(); console.log(foo); // 25

Несмотря на то, что вне функции bar переменная foo нигде не определяется, тем не менее она доступна вне функции во внешнем контексте.

Иначе было бы если бы мы не только присваивали значение переменной, но и определяли бы ее:

Function bar(){ var foo = "25"; } bar(); console.log(foo); // ошибка

Определение глобальных переменных в функциях может вести к потенциальным ошибкам. Чтобы их избежать используется строгий режим или strict mode:

"use strict"; function bar(){ foo = "25"; } bar(); console.log(foo);

В этом случае мы получим ошибку SyntaxError: Unexpected identifier , которая говорит о том, что переменная foo не определена.

Установить режим strict mode можно двумя способами:

добавить выражение "use strict" в начало кода JavaScript, тогда strict mode будет применяться для всего кода

добавить выражение "use strict" в начало тела функции, тогда strict mode будет применяться только для этой функции

Переменные и константы в JavaScript. Объявление переменных и присвоение им значений. Переменные глобальные и локальные. Использование констант.

Имена переменных в JavaScript могут состоять из букв, цифр, знака $ и знака _, причем имя переменной не может начинаться с цифры. Имейте в виду, что JavaScript чувствителен к регистру букв, и переменные a1 и A1 - это разные переменные. Кириллицу использовать не рекомендуется, хотя это возможно.
Переменные в JavaScript объявляются ключевым словом var:

Var Peremennaya_1 var Peremennaya_2

Использовать переменные в JavaScript без объявления не рекомендуется. Это возможно, но может привести к ошибкам.

Присвоение значения объявленным переменным в JavaScript:

Peremennaya_1 = 25 Peremennaya_2 = "Присваиваемый текст заключаем в прямые кавычки"

Можно присваивать значение переменным сразу при объявлении:

Var Peremennaya_1 = 25 var Peremennaya_2 = "Присваиваемый текст заключаем в прямые кавычки"

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

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

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

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

Var DRUG_CHELOVEKA = "Собака"

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

В JavaScript константы можно перезаписывать, как переменные, но если это делать, тогда теряется смысл констант.

hello = Hello ; //задаем глобальную переменную и проверяем ее
document . writeln (->1 + hello + every one
); //->1 Hello every one

if(true )
//if(false)
{
var hello = Hello Dolly and ; //это тоже глобальная
world = world ; //глобальная
var cont = , we continue //глобальная
document . writeln (->1.2 + hello + world + cont +
);
//1.2 Hello Dolly and world, we continue
}
document . writeln (->2 + hello + world + cont +
);
//->2 Hello Dolly and world, we continue

->1 Hello every one
->1.2 Hello Dolly and world, we continue
->2 Hello Dolly and world, we continue

Таким образом, получается, что на глобальную область использование var никак не влияет. Переменная, упомянутая в script вне процедур считается глобальной даже, если она заключения в скобочки {} блока if while for и других области останется глобальной даже внутри циклов

Выводы, кратко

• для переменных используемых в зоне глобальной видимости не важно наличие var.
• Блоки после if while for не создают локальной зоны видимости, (как это происходит в других языках)

boy = Jhone ;
did = kills Kenny ; //итак мы имеем 2 глобальных переменных
function doit ()
{
//уже прошла печать --1, и мы меняем данные меняем данные
var boy = Gary ; //создаем локаль
did = helps Anny ; //изменяем глобаль
;
document . writeln (--2 + boy + + did +
);
//--2 Gary helps Anny
;
//теперь внутри функции зададим локальную и глобальные переменные
var good = he was a good boy
; //локаль!
bad = he likes a bad girls
; //глобаль
}
;
document . writeln (--1 + boy + + did +
);
//--1 Jhone kills Kenny
doit ();
//--2 Gary helps Anny
document . writeln (--3 + boy + + did +
);
//--3 Jhone helps Anny
;
if(! true )
//if(!false)
{
document . writeln (--4 + good );
//выполнение этого блока вызовет ошибку.
//мы сейчас находимся вне локальной области видимости
//функции doit(), поэтому для нас заданной через var
//переменной good просто не существует
}
document . writeln (--5 + bad );
//--5 he likes a bad girls

1 Jhone kills Kenny
--2 Gary helps Anny
--3 Jhone helps Anny
--5 he likes a bad girls

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

• Яваскрип сильно отличается от си уже тем что только(?) внутри функции возможны локальные переменные.
• использование var или не использование в глобальной области видимости зависит только от вашего личного опыта. Но по мне так лучше не ленится. в перле это называется use strict

Важно. Во-первых, “вары” нельзя удалить (с помощью delete). Во-вторых, их конкретизация происходит на “нулевой строке” (до начала работы “построчно”), где им сразу же присваивается значение undefined, и только потом переменная может получить (а может не получить) новое значение:

var glb_1 = 1;
if (false) {var glb_2 = 2; glb_3 = 3;}

alert(glb_1) // конкретизирована и получила значение 1
alert(glb_2) // конкретизировна и получила значение ‘undefined’
alert(glb_3) // вообще не переменная (нет 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 . Еще раз озвучим его суть: если мы создаем переменную внутри какой-либо функции, то она является локальной, и работать с ней мы сможем только внутри этой функции.

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