Dacă sunteți în domeniul global, atunci nu este prea mare diferență. Citiți răspunsul Kangax pentru explicații

Dacă vă aflați într-o funcție, atunci var va crea o variabilă locală, „no var” va căuta în lanțul domeniului până când găsește variabila sau atinge domeniul global ( moment în care o va crea ):

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

Dacă nu faci o misiune, atunci trebuie să folosești var:

var x; // Declare x

Există o diferență.

var x = 1 declară variabila x în domeniul curent (alias contextul de execuție). Dacă declarația apare într-o funcție - este declarată o variabilă locală; dacă este în domeniul global - este declarată o variabilă globală.

x = 1, pe de altă parte, este doar o atribuire de proprietate. Mai întâi încearcă să rezolve x împotriva lanțului scope. Dacă îl găsește oriunde în lanțul respectiv, efectuează atribuirea; dacă nu găsește x, numai atunci creează proprietatea x pe un obiect global (care este un obiect de nivel superior într-un lanț de domeniu).

Acum, observați că nu declară o variabilă globală, ci creează o proprietate globală.

Diferența dintre cele două este subtilă și poate fi confuză, dacă nu înțelegeți că declarațiile de variabile creează și proprietăți (numai pe un obiect variabil) și că fiecare proprietate din Javascript (ei bine, ECMAScript) are anumite steaguri care descriu proprietățile lor - ReadOnly, DontEnum și DontDelete.

Deoarece declarația variabilei creează o proprietate cu indicatorul DontDelete, diferența dintre var x = 1 și x = 1 (când este executată în sfera globală) este că prima - declarația variabilei - creează proprietatea DontDelete, iar cea din urmă nu. În consecință, proprietatea creată prin această atribuire implicită poate fi apoi ștearsă din obiectul global, iar cea dintâi - cea creată prin declararea variabilei - nu poate fi ștearsă.

Dar aceasta este doar teorie, desigur, iar în practică există și mai multe diferențe între cele două, din cauza diferitelor erori în implementări (cum ar fi cele de la IE).

Sper ca totul are sens :)

[Actualizare 2010/12/16]

În ES5 (ECMAScript 5; standardizat recent, ediția a 5-a a limbajului) există așa-numitul „mod strict” - un mod de limbă opt-in, care modifică ușor comportamentul sarcinilor nedeclarate. În modul strict, atribuirea unui identificator nedeclarat este o ReferenceError. Motivul pentru aceasta a fost de a surprinde sarcini accidentale, prevenind crearea de proprietăți globale nedorite. Unele dintre browserele mai noi au început deja să accepte modul strict. Vedeți, de exemplu, my compat table.

A spune că este diferența dintre „local și global” nu este complet corect.

Ar fi mai bine să ne gândim la aceasta ca fiind diferența dintre „local și cel mai apropiat”. Cel mai apropiat poate fi cu siguranță global, dar nu va fi întotdeauna cazul.

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

Când Javascript este executat într-un browser, tot codul dvs. este înconjurat de o instrucțiune with, astfel:

with (window) {
    //Your code
}

Mai multe informații despre with - MDN

Deoarece var declară o variabilă în domeniul curent , nu există nicio diferență între a declara var în interiorul ferestrei și a nu o declara deloc.

Diferența vine atunci când nu ești direct în interiorul ferestrei, de ex. în interiorul unei funcţii sau în interiorul unui bloc.

Utilizarea var vă permite să ascundeți variabile externe care au același nume. În acest fel puteți simula o variabilă „privată”, dar acesta este un alt subiect.

O regulă generală este să folosiți întotdeauna var, pentru că altfel riscați să introduceți erori subtile.

EDIT: După criticile pe care le-am primit, aș dori să subliniez următoarele:

• var declară o variabilă în domeniul curent
• Domeniul de aplicare global este window
• Neutilizarea var declară implicit var în domeniul global (fereastră)
• Declararea unei variabile în domeniul global (fereastră) folosind var este același lucru cu omiterea acesteia.
• Declararea unei variabile în domenii diferite de fereastră folosind var nu este același lucru cu declararea unei variabile fără var
• Declarați întotdeauna var în mod explicit, deoarece este o practică bună

Utilizați întotdeauna cuvântul cheie var pentru a declara variabile. De ce? Buna practică de codificare ar trebui să fie un motiv suficient în sine, dar omiterea acesteia înseamnă că este declarată în domeniul global (o variabilă ca aceasta se numește globală „implicite”). Douglas Crockford recomandă să nu folosiți niciodată valori globale implicite și în conformitate cu Orientări de codare JavaScript Apple:

Orice variabilă creată fără cuvântul cheie var este creată la nivel global și nu este colectată de gunoi atunci când funcția revine (pentru că nu iese din domeniul de aplicare), prezentând oportunitatea unei scurgeri de memorie.

Iată un exemplu destul de bun despre cum poți fi prins de a nu declara variabile locale cu var:

<script>
one();

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

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

(i este resetat la fiecare iterație a buclei, deoarece nu este declarat local în bucla for, ci global) rezultând în cele din urmă în buclă infinită

Aș spune că este mai bine să folosiți var în majoritatea situațiilor.

Variabilele locale sunt întotdeauna mai rapide decât variabilele din domeniul global.

Dacă nu utilizați var pentru a declara o variabilă, variabila va fi în domeniul global.

Pentru mai multe informații, puteți căuta „scope chain JavaScript” în Google.

Nu folosi var!

var a fost modalitatea pre-ES6 de a declara o variabilă. Suntem acum în viitor și ar trebui să codificați ca atare.

Folosiți const și let

const ar trebui utilizat pentru 95% din cazuri. Face ca referința variabilei să nu se poată modifica, astfel încât proprietățile matricei, obiectului și nodului DOM se pot schimba și ar trebui probabil să fie const.

let ar trebui să fie utilizat pentru orice variabilă care se așteaptă să fie reatribuită. Aceasta include într-o buclă for. Dacă scrieți vreodată varName = dincolo de inițializare, utilizați let.

Ambele au domeniul de aplicare la nivel de bloc, așa cum era de așteptat în majoritatea celorlalte limbi.

alta diferenta de ex

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

in timp ce

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

Folosirea var este întotdeauna o idee bună pentru a preveni ca variabilele să aglomereze domeniul de aplicare global și variabilele să intre în conflict între ele, provocând suprascriere nedorită.

Fără var - variabilă globală.

Se recomandă să folosiți ÎNTOTDEAUNA instrucțiunea var, deoarece variabila globală init în context local - este rău. Dar, dacă aveți nevoie de acest truc murdar, ar trebui să scrieți un comentariu la începutul paginii:

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

Acesta este un exemplu de cod pe care l-am scris pentru a înțelege acest concept:

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 a dat un exemplu frumos care arată diferența practică (și pericolul) dintre var și nu var. Iată un altul, acesta îl găsesc deosebit de periculos, deoarece diferența este vizibilă doar într-un mediu asincron, așa că poate scăpa cu ușurință în timpul testării.

După cum v-ați aștepta la următoarele ieșiri de fragment ["text"]:

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

console.log(var_fun())

La fel și următorul fragment (rețineți let lipsă înainte de array):

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

console.log(var_fun())

Executarea asincronă a manipulării datelor produce în continuare același rezultat cu un singur executor:

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

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

Dar se comportă diferit cu mai multe:

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

Folosind let totuși:

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

Ca cineva care încearcă să învețe asta, așa văd eu. Exemplele de mai sus au fost poate puțin prea complicate pentru un începător.

Dacă rulați acest cod:

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

Rezultatul va fi: fals, false, true, true

Deoarece vede variabilele din funcție ca fiind separate de cele din afara acesteia, de unde termenul de variabilă locală și asta pentru că am folosit var în atribuire. Dacă eliminați var-ul din funcție, acum se citește astfel:

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

Rezultatul este fals, fals, false, false

Acest lucru se datorează faptului că, în loc să creeze o nouă variabilă în domeniul sau în funcție locală, pur și simplu folosește variabilele globale și le reatribuie la false.

Văd că oamenii sunt confuzi când declară variabile cu sau fără var și în interiorul sau în afara funcției. Iată un exemplu profund care vă va ghida prin acești pași:

Vezi scriptul de mai jos în acțiune aici la 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);

Concluzie

1. Indiferent dacă sunt declarate cu sau fără var (cum ar fi a, b), dacă își obțin valoarea în afara funcției, își vor păstra valoarea și, de asemenea, orice alte valori care sunt adăugate în interiorul diferitelor funcții prin intermediul scriptului sunt păstrate.
2. Dacă variabila este declarată fără var în interiorul unei funcții (cum ar fi c), aceasta va acționa ca regula anterioară, își va păstra valoarea pentru toate funcțiile de acum înainte. Fie că a primit prima valoare în funcția testVar1(), încă păstrează valoarea și obține o valoare suplimentară în funcția testVar2()
3. Dacă variabila este declarată cu var numai în interiorul unei funcții (cum ar fi d în testVar1 sau testVar2), aceasta va fi nedefinită ori de câte ori funcția se termină. Deci va fi o variabilă temporară într-o funcție.

În interiorul unui cod, dacă utilizați o variabilă fără a utiliza var, atunci ceea ce se întâmplă este că varul var_name este plasat automat în domeniul global, de exemplu:

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

Pe lângă problemele legate de domeniul de aplicare, unii oameni menționează și ascensiunea, dar nimeni nu a dat un exemplu. Iată unul pentru domeniul global:

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

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

Fără a utiliza „var” variabilele pot defini numai atunci când setați o valoare. De exemplu:

my_var;

nu poate funcționa în sfera globală sau orice alt domeniu. Ar trebui să aibă o valoare ca:

my_var = "value";

Pe de altă parte, puteți defini un like disponibil;

var my_var;

Valoarea sa este undefined (Valoarea sa nu este null și nu este egală cu null în mod interesant.).

Ar trebui să utilizați cuvântul cheie var, cu excepția cazului în care intenționați să atașați variabila obiectului fereastră în browser. Iată un link care explică domeniul de aplicare și diferența dintre delimitarea globală și delimitarea locală cu și fără cuvânt cheie var.

Când variabilele sunt definite fără utilizarea cuvântului cheie var, ceea ce arată este o operație simplă de „atribuire”.

Când valoarea este atribuită unei variabile în javascript, interpretul încearcă mai întâi să găsească „declarația variabilei” în același context/sfera de aplicare ca cel al atribuirii. Când interpretul execută dummyVariable = 20, caută declarația dummyVariable la începutul funcției. (Deoarece toate declarațiile de variabile sunt mutate la începutul contextului de către interpretul javascript și aceasta se numește ridicare)

De asemenea, vă recomandăm să vă uitați la hoisting în javascript