ПРИМІТКА . Це питання було задано з точки зору версії 3 або 5. ECMAScript. Відповіді можуть застаріти, якщо з'явиться нові можливості у випуску 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;

?

Коли ви використовуєте будь-який, і чому / що це робить?

Якщо ви перебуваєте в глобальному масштабі, то різниці немає. Прочитайте відповідь Kangax для пояснення

Якщо ви знаходитесь у функції, тоді 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

Є різниця .

var x = 1 декларує змінну x в поточному обсязі (він же контекст виконання). Якщо декларація з'являється у функції - оголошується локальна змінна; якщо це в глобальному масштабі - оголошується глобальна змінна.

x = 1з іншого боку, це лише призначення власності. Спочатку вона намагається вирішити xпроти сфери застосування. Якщо він знайде його де-небудь у цьому діапазоні, він виконує завдання; якщо він не знаходить x, тільки тоді він створює xвластивість для глобального об'єкта (який є об'єктом верхнього рівня в ланцюзі області).

Тепер зауважте, що вона не оголошує глобальну змінну, вона створює глобальну властивість.

Різниця між ними є тонкою і може бути заплутаною, якщо ви не розумієте, що декларації змінних також створюють властивості (лише на змінному об'єкті) і що кожна властивість у Javascript (ну, ECMAScript) має певні прапори, що описують їх властивості - ReadOnly, DontEnum та DontDelete.

Оскільки декларація змінної створює властивість за допомогою прапора DontDelete, різниця між var x = 1та x = 1(при виконанні в глобальному масштабі) полягає в тому, що колишня заява про змінну - створює властивість DontDelete'able, а остання - ні. Як наслідок, властивість, створене за допомогою цього неявного призначення, може бути видалено із глобального об'єкта, а попереднє - створене за допомогою змінної декларації - неможливо видалити.

Але це, звичайно, лише теорія, і на практиці є ще більше відмінностей між ними , через різні помилки у впровадженні (наприклад, у IE).

Сподіваюся, це все має сенс:)

[Оновлення 16.12.2010]

У ES5 (ECMAScript 5; нещодавно стандартизована, 5-е видання мови) існує так званий "суворий режим" - режим мовлення, який трохи змінює поведінку незадекларованих завдань. У жорсткому режимі присвоєння незадекларованому ідентифікатору є ReferenceError . Обґрунтуванням цього було прийняття випадкових завдань, запобігання створенню небажаних глобальних властивостей. Деякі нові браузери вже почали прокручувати підтримку суворого режиму. Дивіться, наприклад, мою таблицю compat .

Скажімо, що різниця між " локальним та глобальним " не зовсім точна.

Можливо, буде краще подумати про це як про різницю між " місцевим та найближчим ". Найближчі, безумовно, можуть бути глобальними, але це не завжди так.

/* 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;
    }
}

Коли Javascript виконується в браузері, весь ваш код оточений оператором a, наприклад:

with (window) {
    //Your code
}

Більше інформації про with- MDN

Оскільки varоголошує змінну в поточній області , немає різниці між тим, як оголосити var всередині вікна і взагалі не оголосити його.

Різниця виникає, коли ви не знаходитесь безпосередньо у вікні, наприклад, всередині функції або всередині блоку.

Використання varдозволяє приховати зовнішні змінні, що мають однакове ім'я. Таким чином ви можете імітувати "приватну" змінну, але це вже інша тема.

Основне правило - завжди використовувати var, оскільки в іншому випадку ви ризикуєте ввести непомітні помилки.

EDIT: Після критики, яку я отримав, я хочу наголосити на наступному:

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

Завжди використовуйте varключове слово для оголошення змінних. Чому? Хороша практика кодування повинна бути достатньою причиною сама по собі, але, опускаючи її, це означає, що вона оголошена в глобальному масштабі (така змінна називається "загальною" глобальною). Дуглас Крокфорд рекомендує ніколи не використовувати маються на увазі глобалі , а відповідно до Правил кодування Apple JavaScript :

Будь-яка змінна, створена без var ключового слова, створюється в глобальному масштабі і не збирається сміттям, коли функція повертається (бо вона не виходить із сфери застосування), представляючи можливість витоку пам'яті.

Ось досить хороший приклад того, як ви можете потрапити назовні через недекларування локальних змінних за допомогою var:

<script>
one();

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

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

( iскидається при кожній ітерації циклу, оскільки вона не оголошується локально в forциклі, а глобально), врешті-решт, це призводить до нескінченного циклу

Я б сказав, що краще використовувати varв більшості ситуацій.

Локальні змінні завжди швидші за змінні в глобальному масштабі.

Якщо ви не використовуєте varдля оголошення змінної, змінна буде в глобальному масштабі.

Для отримання додаткової інформації можна шукати "JavaScript ланцюга JavaScript" в Google.

Не використовуйте var!

varбув способом оголошення змінної перед ES6. Ми зараз у майбутньому , і ви повинні кодувати як таке.

Використовуйте constіlet

constслід використовувати в 95% випадків. Це робить його таким чином, що змінна посилання не може змінюватися, таким чином, властивості вузла масиву, об'єкта та DOM можуть змінюватися і, ймовірно, повинні бути const.

letслід використовувати для будь-якої змінної, яка очікує перепризначення. Це включає в себе цикл for. Якщо ви коли-небудь пишете varName =поза ініціалізацією, використовуйте let.

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

інша різниця, наприклад

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

поки

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

Використання varзавжди є хорошою ідеєю, щоб запобігти захаращуванню глобальної області застосування змінних, а змінні не конфліктувати між собою, викликаючи небажане перезапис.

Без var- глобальна змінна.

Настійно рекомендуємо ЗАВЖДИ використовувати varоператор, тому що init глобальна змінна в локальному контексті - це зло. Але, якщо вам потрібен цей брудний трюк, слід написати коментар на початку сторінки:

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

Це приклад коду, який я написав для вас, щоб зрозуміти цю концепцію:

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

@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)})
})

Використання нехай:

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)})
})

Як хтось намагається дізнатися це, я так це бачу. Наведені вище приклади були, можливо, трохи надто складними для початківця.

Якщо ви запускаєте цей код:

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);

Вихід буде читати як: false, false, true, true

Оскільки він бачить змінні функції як окремі від тих, що знаходяться поза нею, отже, термін локальна змінна, і це було тому, що ми використовували var у призначенні. Якщо ви віднімете 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.

Я бачу, що люди плутаються, коли оголошують змінні з або без 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), вона буде невизначена, коли функція закінчується. Так це буде тимчасовою змінною у функції.

Всередині коду, якщо ви використовуєте змінну без використання 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 */
}

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

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

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

Без використання змінних "var" можна визначити лише тоді, коли встановлено значення. Наприклад:

my_var;

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

my_var = "value";

З іншого боку, ви можете визначити змінну як;

var my_var;

Його значення є undefined(Його значення немає, nullі це не дорівнює nullцікаво).

Ви повинні використовувати ключове слово var, якщо ви не маєте права додавати змінну до об'єкта вікна в браузері. Ось посилання, що пояснює масштабність та різницю між глобальним масштабуванням та локальним масштабуванням із ключовим словом та без нього.

Коли змінні визначаються без використання ключового слова var, це виглядає як проста операція "призначення".

Коли значення присвоюється змінній у javascript, інтерпретатор спочатку намагається знайти "змінну декларацію" в тому ж контексті / області, що і в призначенні. Коли інтерпретатор виконує dummyVariable = 20, він шукає оголошення манекенаVariable на початку функції. (Оскільки всі мінливі декларації переміщуються на початок контексту за допомогою інтерпретатора JavaScript, і це називається підйомом)

Ви також можете подивитися на підйомники в JavaScript