Объявление переменных без ключевого слова var

Побочные эффекты при забывании var

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

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

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

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

// define three globals
var global_var = 1;
global_novar = 2; // antipattern
(function () {
   global_fromfunc = 3; // antipattern
}());
// attempt to delete
delete global_var; // false
delete global_novar; // true
delete global_fromfunc; // true
// test the deletion
typeof global_var; // "number"
typeof global_novar; // "undefined"
typeof global_fromfunc; // "undefined"

В строгом режиме ES5 присваивание необъявленным переменным (например, двум антишаблонам в предыдущем фрагменте) вызовет ошибку.

Шаблоны JavaScript, Стоян Стефанов (O’Reilly). Copyright 2010 Yahoo!, Inc., 9780596806750.

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

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

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

Объявление переменной внутри функции без использования var, let или const внутри функции не более полезно, чем объявление этой переменной с помощью var, let или const. И, как отмечалось в предыдущих ответах на этот вопрос, локальные неявные глобальные объявления функций могут сбивать с толку и вызывать проблемы вне области действия функции, в которой они были объявлены.

Я хотел бы поговорить о некоторых тонкостях, которые отсутствуют в цитате w3schools и в предыдущих ответах на этот вопрос.

Прежде всего, если вы никогда не вызываете функцию, генерирующую неявные глобальные переменные, вы не будете генерировать никакие неявные глобальные переменные. Это тонкое отличие от цитаты w3schools, потому что оно бросает вызов разделу «всегда» их утверждения.

function generateImplicitGlobals(){
  x = "x";
  window.y = "y";
}

// before calling the generateImplicitGlobals function, we can safely see that the x and y properties of the window object are both undefined:
console.log("before calling the generateImplicitGlobals function, properties x and y of the window object are: " + window.x + " and " + window.y);

// before calling the generateImplicitGlobals function, we can test for the existence of global variables x and y; note that we get errors instead of undefined for both.
try{
  console.log("before calling the generateImplicitGlobals function, x is: " + x);
}
catch(e){
  console.log("before calling the generateImplicitGlobals function, an attempt to reference some global variable x produces " + e);
}

try{
  console.log("before calling the generateImplicitGlobals function, y is: " + y);
}
catch(e){
  console.log("before calling the generateImplicitGlobals function, an attempt to reference the global variable b also produces " + e);
}

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

function generateImplicitGlobals(){
  x = "x";
  window.y = "y";
  console.log("inside the function, x and window.x are: " + x + " and " + window.x);
  console.log("inside the function, y and window.y are: " + y + " and " + window.y);
}

// now, call the generator, and see what happens locally and globally.
generateImplicitGlobals();
console.log("after calling the generateImplicitGlobals function, x, window.x, y, and window.y are: " + x + ", " + window.x + ", " + y + ", and " + window.y);

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

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

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

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

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

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

Как упоминалось выше, вы можете совершить ошибку, просто неправильно написав свои переменные, и решением является ключевое слово "use strict";
Если это ключевое слово объявлено, вы получите ошибку: Uncaught ReferenceError: foo is not defined.

Это также относится к защищенному коду:
1. При написании защищенного кода мы не хотим, чтобы к нашим переменным обращались где-либо, кроме того места, где они были фактически объявлены. Не объявляйте глобальные переменные без надобности.
2. Всегда внимательно читайте предупреждения и устраняйте их. Используйте "use strict";, JSlint и другие инструменты, чтобы увидеть и устранить предупреждение, чтобы сделать ваш код лучше.

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

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

Присвоение нового значения именованному аргументу временно заменяет его для текущей области (и производных областей).

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

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

  function noVars(a1,/*vars=*/v1,v2,v3) {
    if (noVars.lastA1===a1) return noVars.lastAnswer;

    noVars.lastA1=a1;

    v1=a1*a1;
    v2=v1*v1;
    v3=v2*v2*v2;

    noVars.lastAnswer = a1+v1+v2+v3;

    return noVars.lastAnswer;
  }

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

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

это также будет работать:

  var noVars = function (a1,/*vars=*/v1,v2,v3) {
    if (noVars.lastA1===a1) return noVars.lastAnswer;

    noVars.lastA1=a1;

    v1=a1*a1;
    v2=v1*v1;
    v3=v2*v2*v2;

    noVars.lastAnswer = a1+v1+v2+v3;

    return noVars.lastAnswer;
  };