Если вы находитесь в глобальном масштабе, особой разницы нет. Прочтите ответ 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).

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

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

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

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

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

/* 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 выполняется в браузере, весь ваш код окружается оператором with, например:

with (window) {
    //Your code
}

Дополнительная информация о with - MDN

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

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

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

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

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

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

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

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

<script>
one();

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

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

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

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

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

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

Для получения дополнительной информации вы можете выполнить поиск «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, потому что инициализация глобальной переменной в локальном контексте - зло. Но, если вам нужен этот подвох, вы должны написать комментарий в начале страницы:

/* 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 и no 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)})
})

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

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

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

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

var my_var;

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

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

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

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

Вы также можете ознакомиться с подъемом в javascript