Какова цель ключевого слова var и когда я должен его использовать (или опустить)?


1543

ПРИМЕЧАНИЕ . Этот вопрос был задан с точки зрения ECMAScript версии 3 или 5. Ответы могут устареть с появлением новых функций в выпуске ECMAScript 6.

Что именно является функцией varключевого слова в JavaScript, и в чем разница между

var someNumber = 2;
var someFunction = function() { doSomething; }
var someObject = { }
var someObject.someProperty = 5;

а также

someNumber = 2;
someFunction = function() { doSomething; }
someObject = { }
someObject.someProperty = 5;

?

Когда бы вы использовали один из них, и почему / что он делает?


3
При связывании объявлений var влияет ли поведение на перевод строки после запятой? var x = 1, y = 2, [return] z = 3;
Альфабраво

4
Отказ от использования «var» также оставляет вас уязвимыми в случае, если выбранное вами имя переменной окажется ранее определенной глобальной переменной. Смотрите мой путь скорби здесь: stackoverflow.com/questions/16704014/…
Скотт С. Уилсон

5
Сообщение в блоге meloncard @Ray Toal (определенно заслуживающее прочтения) переместилось на blog.safeshepherd.com/23/how-one-missing-var-ruined-our-launch
Гефест

Я никогда не думал, что стихотворение может вдохновить меня на размышления о программной проблеме
Феликс Ганьон-Гренье,

1
@Gibolt, но посмотрите на дату вопроса, это своего рода несправедливый вызов вопроса 2009 года, чтобы сказать это. Несмотря на то, что он по-прежнему действителен, как и на текущую дату, для удобства обслуживания существует множество не «современного JS» кода.
Андре Фигейредо

Ответы:


1356

Если вы находитесь в глобальном масштабе, то особой разницы нет. Прочитайте ответ Кангакса для объяснения

Если вы находитесь в функции, то varсоздадите локальную переменную, «no var» будет искать цепочку областей видимости, пока не найдет переменную или не достигнет глобальной области видимости (в этот момент она ее создаст):

// These are both globals
var foo = 1;
bar = 2;

function()
{
    var foo = 1; // Local
    bar = 2;     // Global

    // Execute an anonymous function
    (function()
    {
        var wibble = 1; // Local
        foo = 2; // Inherits from scope above (creating a closure)
        moo = 3; // Global
    }())
}

Если вы не выполняете задание, вам нужно использовать var:

var x; // Declare x

31
«Не очень ли большая разница» == «Нет разницы»?
Алекс

65
Ну, на самом деле да, есть разница :) Важна ли эта разница - другой вопрос. Смотрите мой ответ ниже: stackoverflow.com/questions/1470488/…
kangax

4
Я думаю, что это может быть точкой Алекса, поэтому он написал это, используя оператор «равно»!
Джеймс Бедфорд

18
Это похоже на стрельбу из самозарядного ружья ... Забудьте поместить переменную перед своей переменной и в конечном итоге измените переменную где-нибудь в цепочке областей действия ... Попробуйте убедить Java / C / Python / и т.д. Разработчик, что JavaScript стоит. Ха! Подводные камни в C / C ++ выглядят неплохо. Представьте себе необходимость отладки JavaScript ... И некоторые люди, конечно, делают это. И так много кода (и не просто кода, заметь) написано на JavaScript ...
Альбус Дамблдор

6
Если вы находитесь в глобальном масштабе, то нет никакой разницы. >> Есть разница, которая объясняется в ответе ниже
Макс Корецкий

746

Там разница .

var x = 1 объявляет переменную x в текущей области видимости (или контекст выполнения). Если объявление появляется в функции - объявляется локальная переменная; если это в глобальной области видимости - объявлена ​​глобальная переменная.

x = 1с другой стороны, это просто присвоение свойства. Сначала он пытается разрешить xцепочку областей видимости. Если он находит его где-нибудь в этой цепочке областей действия, он выполняет присваивание; если он не находит x, только тогда он создает xсвойство для глобального объекта (который является объектом верхнего уровня в цепочке областей действия).

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

Разница между этими двумя тонкими и может сбить с толку, если вы не понимаете, что объявления переменных также создают свойства (только для объекта переменной) и что каждое свойство в Javascript (ну, ECMAScript) имеет определенные флаги, которые описывают их свойства - ReadOnly, DontEnum и DontDelete.

Поскольку объявление переменной создает свойство с флагом DontDelete, разница между var x = 1и x = 1(при выполнении в глобальной области видимости) заключается в том, что первый - объявление переменной - создает свойство DontDelete'able, а второй - нет. Как следствие, свойство, созданное с помощью этого неявного присвоения, затем может быть удалено из глобального объекта, а прежнее - созданное с помощью объявления переменной - не может быть удалено.

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

Надеюсь, все это имеет смысл :)


[Обновление 2010/12/16]

В ES5 (ECMAScript 5; недавно стандартизированная, 5-я редакция языка) существует так называемый «строгий режим» - языковой режим opt-in, который немного меняет поведение необъявленных назначений. В строгом режиме присвоение необъявленного идентификатора является ReferenceError . Основанием для этого было отловить случайные присваивания, предотвращающие создание нежелательных глобальных свойств. Некоторые из новых браузеров уже начали активную поддержку строгого режима. Смотрите, например, мою таблицу сравнения .


Если я правильно помню, я думаю, что однажды нашел способ получить deleteпеременную, объявленную var, с некоторым evalвзломом. Если я помню точную уловку, я отправлю здесь.
Башня

3
@Mageek Возможно, он говорит о переменных, объявленных eval, которые можно удалить. Я написал пост в блоге об этом однажды.
Кангакс

1
Немного не в тему, но упомяну это здесь для справки. «let» очень похож на «var» и поддерживается в Mozilla. Основное отличие состоит в том, что область видимости переменной var представляет собой всю включающую функцию, где «let» ограничена ее блоком
mac

@kangax, что, если последние две строки примеров Алекса были смешаны: var someObject = {}а someObject.someProperty = 5? Станет ли somePropertyглобальным, а объект, к которому он принадлежит, останется локальным?
snapfractalpop

1
Имя спецификации для того, что @kangax называет флагом DontDelete, является настраиваемым (= false) , вы можете прочитать об этом в отношении Object.definePropertyиObject.getOwnPropertyDescriptor
Paul S.

137

Сказать, что разница между « локальным и глобальным » не совсем точно.

Возможно, лучше думать об этом как о разнице между « местным и ближайшим ». Ближайший может быть глобальным, но это не всегда так.

/* global scope */
var local = true;
var global = true;

function outer() {
    /* local scope */
    var local = true;
    var global = false;

    /* nearest scope = outer */
    local = !global;

    function inner() {
        /* nearest scope = outer */
        local = false;
        global = false;

        /* nearest scope = undefined */
        /* defaults to defining a global */
        public = global;
    }
}

3
Разве не ближайшая сфера, outerгде вы определяете var global = false;?
Снексе

@Snekse: «ближайший» не применяется, когда <code> var global = false; </ code> объявлен. В этом объявлении «global» помещается в область видимости external (), потому что в объявлении используется «var». Поскольку 'var' не используется в inner (), он изменит значение на следующем уровне вверх, который является external ().
Митч

Интересно, изменится ли ваш комментарий, если вы измените эту строку, и var global = local;в этом случае ближний объем локального будет «локальным» внешним объемом, который активно определяется. Хотя становится странным, если вы измените эту же строку, и var global = globalв этом случае ближайшая область при поиске значения globalбудет выше уровня глобальной области окна.
Снексе

80

Когда Javascript выполняется в браузере, весь ваш код окружен оператором with, например:

with (window) {
    //Your code
}

Более подробная информация о with- MDN

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

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

Использование varпозволяет скрыть внешние переменные с одинаковыми именами. Таким образом, вы можете смоделировать «приватную» переменную, но это уже другая тема.

Эмпирическое правило всегда следует использовать var, потому что в противном случае вы рискуете внести незначительные ошибки.

РЕДАКТИРОВАТЬ: После того, как я получил критику, я хотел бы подчеркнуть следующее:

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

1
Я не отрицал вас, но область видимости, вероятно, лучше слова, чем окно. У тебя все объяснения немного тупые.
Роберт Харви

4
Я просто называю вещи своим именем, вы хотите назвать это «глобальной областью действия», это нормально, но на стороне клиента, по соглашению, это объект окна, который является последним элементом цепочки областей действия, поэтому вы можете вызывать каждый Функция и каждый объект в окне без записи "окна".
kentaromiura

2
+1 это действительно хорошее объяснение - я раньше не слышал, чтобы проблема var / no var была оформлена (без каламбура), как это раньше.
Дуги

Большая часть этого ответа устарела letв ES6.
Эван Кэрролл

3
@EvanCarroll Этот ответ также технически неверен, так как пропущенный var не объявляет никакую переменную, вместо этого он создает удаляемое свойство для глобального объекта, кроме того, в режиме ES5 «использовать строгий» большая часть ответа, очевидно, неверна, также пусть wasn ' Это даже не рассматривалось в этом ответе, поскольку во время вопроса не было никакой ссылки на версию javascript (добавленную вчера), которая подразумевала, что эталонным стандартом (в то время) был ECMA 262 3rd Edition.
кентаромиура

43

Всегда используйте varключевое слово для объявления переменных. Почему? Хорошая практика кодирования должна быть достаточной причиной сама по себе, но ее опущение означает, что она объявлена ​​в глобальной области видимости (такая переменная называется «подразумеваемой» глобальной). Дуглас Крокфорд рекомендует никогда не использовать подразумеваемые глобальные переменные , и согласно Руководству Apple по кодированию JavaScript :

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


17
«Хорошая практика кодирования» никогда не должна быть достаточной причиной сама по себе. Это равносильно тому, что «некоторые ребята в Интернете сказали, что так должен выглядеть мой код». Это даже менее верно, чем «мой учитель сказал», если только кто-то хотя бы смутно не понимает причину, лежащую в основе правила.
Чао

@cHao Я думаю, что good coding practiceэто всегда достаточная причина, если это рекомендуемая лучшая практика, которой пользуются несколько авторов Javascript.
Крис С

8
@ChrisS: нет, «хорошая практика кодирования» сама по себе не является причиной. Причина это считается хорошей практикой является то , что имеет значение. Если эти авторы не скажут вам, почему они это рекомендуют, их рекомендации не должны иметь никакого значения. Если вы не согласны с причинами, вы можете считать это плохим советом. И если вы будете следовать этому, даже не спросив почему, именно так начинается грузовой культ.
Цао

30

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

<script>
one();

function one()
{
    for (i = 0;i < 10;i++)
    {
        two();
        alert(i);
    }
}

function two()
{
    i = 1;
}
</script>

( iсбрасывается на каждой итерации цикла, так как он не объявляется локально в forцикле, но глобально), что в итоге приводит к бесконечному циклу


Хлоп! Я могу только представить все ошибки, которые могли быть вызваны этой опечаткой.
BonsaiOak

2
мне любопытно, почему вы передаете я в качестве аргумента для двух ()? (внутри цикла for) это избыточно?
Калин

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

Баг или фича?
TheMaster

13

Я бы сказал, что лучше использовать varв большинстве ситуаций.

Локальные переменные всегда быстрее, чем переменные в глобальной области видимости.

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

Для получения дополнительной информации вы можете выполнить поиск «JavaScript цепочки областей действия» в Google.


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

@RyuKaplan - эй, это правда? Я попробовал поискать в Google и не смог получить никакой информации по этому вопросу! У вас есть источник полномочий для этого утверждения? Thx
Майк Грызун

@RyuKaplan Разбор / компиляция отличается от фактического запуска кода.
Gcampbell

11

Не используйте var!

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

Используйте constиlet

constследует использовать в 95% случаев. Это делает так, чтобы ссылка на переменную не могла изменяться, поэтому свойства массива, объекта и узла DOM могут изменяться и, вероятно, должны быть такими const.

letследует использовать для любой переменной, ожидающей переназначения. Это включает в себя цикл for. Если вы когда-нибудь пишете varName =за инициализацией, используйте let.

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


2
Замените все, что вы 'var' на 'const' (заменить все). Вы быстро заметите, где находятся ваши переназначенные переменные. Если у вас их слишком много, вы, вероятно, закодируете анти-шаблонно: большинство переназначаемых переменных могут быть встроены в замыкания или как свойства объекта. Если у вас есть несколько: используйте «пусть» для них. Наконец, если некоторые переменные вообще не делаются с помощью var, они останутся необъявленными и все еще присутствуют в глобальном пространстве, будьте осторожны. Что касается комментария @Gibolt «внутри цикла for», также рекомендуется избегать таких циклов в «95% случаев» ;-): методы массива хороши.
allez l'OM

Говоря, что const следует использовать в 95% случаев, кажется, что мы уходим от хорошей практики и в догму.
Агамемн

9

другая разница, например

var a = a || [] ; // works 

пока

a = a || [] ; // a is undefined error.

1
Не могли бы вы объяснить, почему это работает в случае переменной, определенной с помощью 'var', и переменной, не определенной с помощью var? Создается ли переменная перед оценкой правой части присваивания в случае var?
Мэтт

6
@Lucek, потому что var aон поднимается в верхнюю часть области и устанавливается в значение null, которое объявляет, но не инициализирует переменную, тогда в присваивании у вас есть ссылка на неопределенную переменную null, которая оценивается как false, и присваивает присвоение значение []. В последнем у вас есть назначение на имущество aсобственности a. Вы можете присвоить свойству, которое не существует, - создавая его по назначению, но вы не можете прочитать из свойства, которое не существует, без получения ReferenceErrorвашего ответа.
Эван Кэрролл

1
@EvanCarroll: он поднимается в верхнюю часть области видимости и устанавливается в неопределенное значение вместо нулевого.
Mithunsatheesh

8

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


8

Без var- глобальная переменная.

Настоятельно рекомендуется ВСЕГДА использовать varоператор, потому что глобальная переменная init в локальном контексте - это зло. Но, если вам нужен этот подвох, вы должны написать комментарий в начале страницы:

/* global: varname1, varname2... */

3

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

var foo = 5; 
bar = 2;     
fooba = 3;

// Execute an anonymous function
(function() {    
    bar = 100;             //overwrites global scope bar
    var foo = 4;           //a new foo variable is created in this' function's scope
    var fooba = 900;       //same as above
    document.write(foo);   //prints 4
    document.write(bar);   //prints 100
    document.write(fooba); //prints 900
})();

document.write('<br/>');
document.write('<br/>');
document.write(foo);       //prints 5
document.write(bar);       //prints 100
document.write(fooba);     //prints 3

2
Функция ни в коем случае не является «анонимной». На самом деле, он назван настолько явно, насколько это возможно.
Инго Бюрк

Спасибо за редактирование вашего ответа в ответ на комментарий Инго Бюрка, чтобы сделать «анонимную функцию» фактически анонимной.
Дейв Бертон,

3

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

Как и следовало ожидать следующие фрагменты вывода ["text"]:

function var_fun() {
  let array = []
  array.push('text')
  return array
}

console.log(var_fun())

Как и следующий фрагмент (обратите внимание на отсутствующий letранее array):

function var_fun() {
  array = []
  array.push('text')
  return array
}

console.log(var_fun())

Выполнение манипулирования данными в асинхронном режиме по-прежнему дает тот же результат с одним исполнителем:

function var_fun() {
  array = [];
  return new Promise(resolve => resolve()).then(() => {
    array.push('text')
    return array
  })
}

var_fun().then(result => {console.log(result)})

Но ведет себя по-разному с несколькими:

function var_fun() {
  array = [];
  return new Promise(resolve => resolve()).then(() => {
    array.push('text')
    return array
  })
}

[1,2,3].forEach(i => {
  var_fun().then(result => {console.log(result)})
})

Используя let однако:

function var_fun() {
  let array = [];
  return new Promise(resolve => resolve()).then(() => {
    array.push('text')
    return array
  })
}

[1,2,3].forEach(i => {
  var_fun().then(result => {console.log(result)})
})


Спасибо за пример @thisismydesign! Что касается последних двух примеров, почему предпоследний пример регистрирует массив из 3 элементов с текстом, написанным трижды, тогда как последний пример регистрирует «текст» только один раз для каждого элемента в массиве? (Я понимаю, что последний объявляет «массив» как переменную и поэтому находится в локальной области видимости, в то время как в предпоследнем примере это опускается, что делает «массив» частью подразумеваемой глобальной области видимости.) Но почему, как это влияет на вывод? Это потому, что forEach "i" перебирает функцию и все глобальные переменные?
Почти Питт

2

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

Если вы запустите этот код:

var local = true;
var global = true;


function test(){
  var local = false;
  var global = false;
  console.log(local)
  console.log(global)
}

test();

console.log(local);
console.log(global);

Вывод будет выглядеть как: ложь, ложь, правда, правда

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

var local = true;
var global = true;


function test(){
  local = false;
  global = false;
  console.log(local)
  console.log(global)
}

test();

console.log(local);
console.log(global);

Выход ложный, ложный, ложный, ложный

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


2

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

Смотрите скрипт ниже в действии здесь на jsfiddle

a = 1;// Defined outside the function without var
var b = 1;// Defined outside the function with var
alert("Starting outside of all functions... \n \n a, b defined but c, d not defined yet: \n a:" + a + "\n b:" + b + "\n \n (If I try to show the value of the undefined c or d, console.log would throw 'Uncaught ReferenceError: c is not defined' error and script would stop running!)");

function testVar1(){
    c = 1;// Defined inside the function without var
    var d = 1;// Defined inside the function with var
    alert("Now inside the 1. function: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n d:" + d);

    a = a + 5;
    b = b + 5;
    c = c + 5;
    d = d + 5;

    alert("After added values inside the 1. function: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n d:" + d);
};


testVar1();
alert("Run the 1. function again...");
testVar1();

function testVar2(){
    var d = 1;// Defined inside the function with var
    alert("Now inside the 2. function: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n d:" + d);

    a = a + 5;
    b = b + 5;
    c = c + 5;
    d = d + 5;

    alert("After added values inside the 2. function: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n d:" + d);
};

testVar2();

alert("Now outside of all functions... \n \n Final Values: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n You will not be able to see d here because then the value is requested, console.log would throw error 'Uncaught ReferenceError: d is not defined' and script would stop. \n ");
alert("**************\n Conclusion \n ************** \n \n 1. No matter declared with or without var (like a, b) if they get their value outside the function, they will preserve their value and also any other values that are added inside various functions through the script are preserved.\n 2. If the variable is declared without var inside a function (like c), it will act like the previous rule, it will preserve its value across all functions from now on. Either it got its first value in function testVar1() it still preserves the value and get additional value in function testVar2() \n 3. If the variable is declared with var inside a function only (like d in testVar1 or testVar2) it will will be undefined whenever the function ends. So it will be temporary variable in a function.");
alert("Now check console.log for the error when value d is requested next:");
alert(d);

Вывод

  1. Независимо от того, объявлено ли с помощью var или без него (например, a, b), если они получат свое значение вне функции, они сохранят свое значение, а также будут сохранены любые другие значения, добавленные в различные функции через скрипт.
  2. Если переменная объявлена ​​без var внутри функции (например, c), она будет действовать как предыдущее правило, теперь она будет сохранять свое значение во всех функциях. Либо он получил свое первое значение в функции testVar1 (), но все равно сохраняет значение и получает дополнительное значение в функции testVar2 ().
  3. Если переменная объявлена ​​с помощью var только внутри функции (как d в testVar1 или testVar2), она будет неопределенной при завершении функции. Так что это будет временная переменная в функции.

Спасибо, что нашли время, чтобы создать пример для демонстрации этой темы. В приведенном выше коде пропущена часть ниже, так что вы можете отредактировать свой ответ: a = 1; // Определено вне функции без var var b = 1; // Определено вне функции с помощью var alert («Запуск вне всех функций» ... \ n \ na, b определено, но c, d еще не определено: \ na: "+ a +" \ nb: "+ b +" \ n \ n (Если я попытаюсь показать значение неопределенного c или d, console.log выдаст ошибку «Uncaught ReferenceError: c не определено», и скрипт прекратит работу!) ");
Санкофа

1

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

someFunction() {
    var a = some_value; /*a has local scope and it cannot be accessed when this
    function is not active*/
    b = a; /*here it places "var b" at top of script i.e. gives b global scope or
    uses already defined global variable b */
}

1

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

console.log(noErrorCase);
var noErrorCase = "you will reach that point";

console.log(runTimeError);
runTimeError = "you won't reach that point";


0

Без использования «var» переменные можно определять только при заданном значении. В примере:

my_var;

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

my_var = "value";

С другой стороны, вы можете определить vaiable как;

var my_var;

Его значение равно undefined(его значение не равно nullи оно не равно nullинтересно).


my_var;на самом деле является действительным выражением оператора.
лексикоре

Это допустимое утверждение, если переменная определена ранее. В противном случае выдается ошибка «... не определено».
Умут

3
Это допустимый оператор независимо от того, была ли переменная определена ранее или нет. :) Допустимое утверждение может выдать ошибку, но это не сделает утверждение недействительным.
лексикоре

Я запутался в этом. Что является действительным утверждением? И можете ли вы привести пример неверного утверждения?
Умут

Я должен извиниться - слишком много грамматики ECMAScript в последнее время. my_var;является допустимым выражением выражения . /my_var;будет неверным утверждением. Но, как я уже сказал, это грамматическая казуистика, извиняюсь, мой комментарий был на самом деле неуместным.
лексикоре

0

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

Когда переменные определяются без использования ключевого слова var, это выглядит как простая операция «присваивания».

Когда значение присваивается переменной в javascript, интерпретатор сначала пытается найти «объявление переменной» в том же контексте / области, что и назначение. Когда переводчик выполняетdummyVariable = 20 , он ищет объявление dummyVariable в начале функции. (Поскольку все объявления переменных перемещаются в начало контекста интерпретатором javascript, это называется подъемом)

Вы также можете посмотреть на подъем в JavaScript

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.