Jeśli jesteś w zasięgu globalnym, nie ma dużej różnicy. Przeczytaj odpowiedź Kangax w celu wyjaśnienia

Jeśli korzystasz z funkcji, var utworzy zmienną lokalną, „no var” będzie przeszukiwać łańcuch zasięgu, dopóki nie znajdzie zmiennej lub nie osiągnie zasięgu globalnego (w tym momencie ją utworzy ):

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

Jeśli nie robisz zadania, musisz użyć var:

var x; // Declare x

Jest różnica.

var x = 1 deklaruje zmienną x w bieżącym zakresie (czyli kontekście wykonania). Jeżeli deklaracja występuje w funkcji - deklarowana jest zmienna lokalna; jeśli ma zasięg globalny - deklarowana jest zmienna globalna.

x = 1 jest natomiast jedynie przeniesieniem własności. Najpierw próbuje rozwiązać x względem łańcucha zasięgu. Jeśli znajdzie go gdziekolwiek w tym łańcuchu zasięgu, wykonuje przypisanie; jeśli nie znajdzie x, dopiero wtedy tworzy właściwość x na obiekcie globalnym (który jest obiektem najwyższego poziomu w łańcuchu zasięgu).

Teraz zauważ, że nie deklaruje zmiennej globalnej, tworzy właściwość globalną.

Różnica między nimi jest subtelna i może być myląca, chyba że zrozumiesz, że deklaracje zmiennych tworzą również właściwości (tylko w obiekcie Variable) i że każda właściwość w JavaScript (no cóż, ECMAScript) ma pewne flagi opisujące ich właściwości - ReadOnly, DontEnum i DontDelete.

Ponieważ deklaracja zmiennej tworzy właściwość z flagą DontDelete, różnica pomiędzy var x = 1 i x = 1 (gdy jest wykonywana w zakresie globalnym) polega na tym, że pierwsza - deklaracja zmiennej - tworzy właściwość DontDelete'able, a druga nie. W rezultacie właściwość utworzoną poprzez to niejawne przypisanie można następnie usunąć z obiektu globalnego, natomiast tej pierwszej, utworzonej poprzez deklarację zmiennej, nie można usunąć.

Ale to oczywiście tylko teoria i w praktyce różnic między nimi jest jeszcze więcej z powodu różnych błędów w implementacjach (takich jak te z IE).

Mam nadzieję, że to wszystko ma sens :)

[Aktualizacja 2010/12/16]

W ES5 (ECMAScript 5; niedawno ujednolicony, 5. wydanie języka) istnieje tak zwany „tryb ścisły” — tryb języka opcjonalny, który nieznacznie zmienia zachowanie niezadeklarowanych przypisań. W trybie ścisłym przypisanie do niezadeklarowanego identyfikatora jest ReferenceError. Powodem tego było wyłapanie przypadkowych przypisań, zapobiegając tworzeniu niepożądanych właściwości globalnych. Niektóre z nowszych przeglądarek rozpoczęły już obsługę trybu ścisłego. Zobacz na przykład moją tabelę zgodności.

Twierdzenie, że jest to różnica między „lokalnym a globalnym”, nie jest do końca trafne.

Lepiej byłoby pomyśleć o tym jako o różnicy między „lokalnym a najbliższym”. Najbliższy z pewnością może mieć charakter globalny, ale nie zawsze tak będzie.

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

Kiedy JavaScript jest wykonywany w przeglądarce, cały kod jest otoczony instrukcją with, na przykład:

with (window) {
    //Your code
}

Więcej informacji na temat with - MDN

Ponieważ var deklaruje zmienną w bieżącym zakresie , nie ma różnicy pomiędzy zadeklarowaniem var wewnątrz okna a jej całkowitym brakiem.

Różnica pojawia się, gdy nie znajdujesz się bezpośrednio w oknie, np. przy oknie. wewnątrz funkcji lub wewnątrz bloku.

Użycie var pozwala ukryć zmienne zewnętrzne o tej samej nazwie. W ten sposób możesz symulować zmienną „prywatną”, ale to inny temat.

Ogólna zasada jest taka, aby zawsze używać var, ponieważ w przeciwnym razie istnieje ryzyko wprowadzenia subtelnych błędów.

EDYCJA: Po otrzymanej krytyce chciałbym podkreślić, co następuje:

• var deklaruje zmienną w bieżącym zakresie
• Zasięg globalny to window
• Nieużywanie var domyślnie deklaruje var w zakresie globalnym (okno)
• Deklarowanie zmiennej w zasięgu globalnym (oknie) przy użyciu var jest równoznaczne z jej pominięciem.
• Deklarowanie zmiennej w zakresach innych niż okno przy użyciu var to nie to samo, co deklarowanie zmiennej bez var
• Zawsze deklaruj var wyraźnie, ponieważ jest to dobra praktyka

Do deklarowania zmiennych zawsze używaj słowa kluczowego var. Dlaczego? Dobra praktyka kodowania powinna być wystarczającym powodem sama w sobie, ale pominięcie jej oznacza, że ​​jest ona zadeklarowana w zakresie globalnym (taka zmienna nazywana jest „implikowaną” wartością globalną). Douglas Crockford zaleca, aby nigdy nie używać domyślnych wartości globalnych i zgodnie z Wskazówki dotyczące kodowania JavaScript firmy Apple:

Każda zmienna utworzona bez słowa kluczowego var jest tworzona w zasięgu globalnym i nie jest wyrzucana do śmieci, gdy funkcja powraca (ponieważ nie wykracza poza zakres), co stwarza możliwość wycieku pamięci.

Oto całkiem dobry przykład tego, jak można zostać przyłapanym na niezadeklarowaniu zmiennych lokalnych za pomocą var:

<script>
one();

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

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

(i jest resetowany przy każdej iteracji pętli, ponieważ nie jest deklarowany lokalnie w pętli for, ale globalnie) ostatecznie skutkuje nieskończoną pętlą

Powiedziałbym, że w większości sytuacji lepiej jest używać var.

Zmienne lokalne są zawsze szybsze niż zmienne o zasięgu globalnym.

Jeśli nie użyjesz var do zadeklarowania zmiennej, zmienna będzie miała zasięg globalny.

Aby uzyskać więcej informacji, możesz wyszukać w Google „łańcuch zasięgu JavaScript”.

Nie używaj var!

var był sposobem deklarowania zmiennej w wersji wcześniejszej niż ES6. Jesteśmy teraz w przyszłości i powinieneś kodować jako taki.

Użyj const i let

const powinno być używane w 95% przypadków. Sprawia to, że odwołanie do zmiennej nie może się zmienić, a zatem właściwości tablicy, obiektu i węzła DOM mogą się zmienić i prawdopodobnie powinny wynosić const.

let należy zastosować w przypadku każdej zmiennej, która ma zostać ponownie przypisana. Obejmuje to pętlę for. Jeśli kiedykolwiek napiszesz varName = poza inicjalizacją, użyj let.

Oba mają zakres na poziomie bloku, zgodnie z oczekiwaniami w większości innych języków.

kolejna różnica, np

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

chwila

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

Użycie var jest zawsze dobrym pomysłem, aby zapobiec zaśmiecaniu zakresu globalnego przez zmienne i wzajemnym konfliktom zmiennych, powodującym niepożądane nadpisywanie.

Bez var - zmienna globalna.

Zdecydowanie zaleca się, aby ZAWSZE używać instrukcji var, ponieważ inicjowanie zmiennej globalnej w kontekście lokalnym jest złe. Ale jeśli potrzebujesz tej brudnej sztuczki, powinieneś napisać komentarz na początku strony:

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

Oto przykładowy kod, który napisałem, aby zrozumieć tę koncepcję:

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 podał ładny przykład pokazujący praktyczną różnicę (i niebezpieczeństwo) między var a nr var. Oto kolejny przypadek. Ten uważam za szczególnie niebezpieczny, ponieważ różnica jest widoczna tylko w środowisku asynchronicznym, więc może łatwo przemknąć podczas testowania.

Jak można się spodziewać, następujące wyniki fragmentu kodu ["text"]:

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

console.log(var_fun())

Podobnie wygląda następujący fragment (zwróć uwagę na brakujące let przed array):

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

console.log(var_fun())

Asynchroniczne wykonanie manipulacji danymi nadal daje ten sam wynik przy użyciu jednego modułu wykonującego:

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

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

Ale zachowuje się inaczej w przypadku wielu:

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

Używając jednak 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)})
})

Jako ktoś, kto próbuje się tego nauczyć, tak to widzę. Powyższe przykłady były może nieco zbyt skomplikowane dla początkującego.

Jeśli uruchomisz ten kod:

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

Dane wyjściowe będą brzmiały: fałsz, fałsz, prawda, prawda

Ponieważ widzi zmienne w funkcji jako oddzielne od tych na zewnątrz, stąd termin zmienna lokalna, a to dlatego, że użyliśmy var w przypisaniu. Jeśli usuniesz var z funkcji, teraz będzie ona brzmiała tak:

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

Dane wyjściowe to fałsz, fałsz, fałsz, fałsz

Dzieje się tak dlatego, że zamiast tworzyć nową zmienną w zakresie lokalnym lub funkcji, po prostu używa zmiennych globalnych i ponownie przypisuje im wartość false.

Widzę, że ludzie są zdezorientowani podczas deklarowania zmiennych z var lub bez niej, wewnątrz lub na zewnątrz funkcji. Oto szczegółowy przykład, który przeprowadzi Cię przez następujące kroki:

Zobacz poniższy skrypt w działaniu tutaj w 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);

Wniosek

1. Bez względu na to, czy są zadeklarowane z var czy bez (np. a, b), jeśli uzyskają swoją wartość poza funkcją, zachowają swoją wartość, a także wszelkie inne wartości dodane do różnych funkcji za pomocą skryptu zostaną zachowane.
2. Jeśli zmienna zostanie zadeklarowana bez var wewnątrz funkcji (np. c), będzie działać jak poprzednia reguła, od tej chwili zachowa swoją wartość we wszystkich funkcjach. Albo otrzymał swoją pierwszą wartość w funkcji testVar1(), nadal zachowuje tę wartość i otrzymuje dodatkową wartość w funkcji testVar2()
3. Jeśli zmienna jest zadeklarowana z var tylko wewnątrz funkcji (np. d w testVar1 lub testVar2), będzie ona niezdefiniowana za każdym razem, gdy funkcja się zakończy. Będzie to zatem zmienna tymczasowa w funkcji.

Wewnątrz kodu, jeśli używasz zmiennej bez użycia var, wtedy dzieje się automatycznie, że var nazwa_zmiennej jest umieszczana w zasięgu globalnym, np.:

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

Oprócz problemu z zakresami niektórzy wspominają także o podnoszeniu, ale nikt nie podał przykładu. Oto jeden dla zasięgu globalnego:

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

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

Bez użycia „var” zmienne można zdefiniować tylko wtedy, gdy ustawiona jest wartość. W przykładzie:

my_var;

nie może działać w zasięgu globalnym ani żadnym innym zakresie. Powinien mieć wartość taką jak:

my_var = "value";

Z drugiej strony możesz zdefiniować dostępne polubienie;

var my_var;

Jego wartość wynosi undefined (jego wartość nie wynosi null i nie jest równa null, co ciekawe.).

Powinieneś użyć słowa kluczowego var, chyba że chcesz mieć zmienną dołączoną do obiektu okna w przeglądarce. Oto link wyjaśniający zakres i różnica między zakresem glokalnym a zakresem lokalnym ze słowem kluczowym var i bez niego.

Kiedy zmienne są definiowane bez użycia słowa kluczowego var, wygląda to na prostą operację „przypisania”.

Kiedy wartość jest przypisana do zmiennej w JavaScript, interpreter najpierw próbuje znaleźć „deklarację zmiennej” w tym samym kontekście/zakresie, co przypisanie. Kiedy interpreter wykonuje dummyVariable = 20, szuka deklaracji dummyVariable na początku funkcji. (Ponieważ wszystkie deklaracje zmiennych są przenoszone na początek kontekstu przez interpreter JavaScript i nazywa się to podnoszeniem)

Możesz także przyjrzeć się podnoszenie javascript