HINWEIS : Diese Frage wurde aus Sicht von ECMAScript Version 3 oder 5 gestellt. Die Antworten könnten mit der Einführung neuer Funktionen in der Version von ECMAScript 6 veraltet sein.

Was genau ist die Funktion des varSchlüsselworts in JavaScript und was ist der Unterschied zwischen

var someNumber = 2;
var someFunction = function() { doSomething; }
var someObject = { }
var someObject.someProperty = 5;

und

someNumber = 2;
someFunction = function() { doSomething; }
someObject = { }
someObject.someProperty = 5;

?

Wann würden Sie eines von beiden verwenden und warum / was macht es?

Wenn Sie sich im globalen Bereich befinden, gibt es keinen großen Unterschied. Lesen Sie Kangax ' Antwort zur Erklärung

Wenn Sie sich in einer Funktion befinden, varwird eine lokale Variable erstellt. "No var" sucht in der Bereichskette, bis die Variable gefunden wird oder der globale Bereich erreicht wird (an diesem Punkt wird sie erstellt):

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

Wenn Sie keine Aufgabe ausführen, müssen Sie Folgendes verwenden var:

var x; // Declare x

Es gibt einen Unterschied .

var x = 1 deklariert eine Variable x im aktuellen Bereich (auch als Ausführungskontext bezeichnet). Wenn die Deklaration in einer Funktion erscheint, wird eine lokale Variable deklariert. Wenn es sich im globalen Bereich befindet, wird eine globale Variable deklariert.

x = 1ist dagegen lediglich eine Eigenschaftszuweisung. Es wird zunächst versucht, eine Lösung xgegen die Bereichskette zu finden. Wenn es irgendwo in dieser Bereichskette gefunden wird, führt es eine Zuweisung durch. Wenn es nicht gefunden wird x, erstellt es nur dann eine xEigenschaft für ein globales Objekt (das ein Objekt der obersten Ebene in einer Bereichskette ist).

Beachten Sie nun, dass keine globale Variable deklariert wird, sondern eine globale Eigenschaft erstellt wird.

Der Unterschied zwischen den beiden ist subtil und kann verwirrend sein, es sei denn, Sie verstehen, dass Variablendeklarationen auch Eigenschaften erstellen (nur für ein Variablenobjekt) und dass jede Eigenschaft in Javascript (also ECMAScript) bestimmte Flags hat, die ihre Eigenschaften beschreiben - ReadOnly, DontEnum und Nicht löschen.

Da die Variablendeklaration eine Eigenschaft mit dem DontDelete-Flag erstellt, besteht der Unterschied zwischen var x = 1und x = 1(bei Ausführung im globalen Bereich) darin, dass die erstere - die Variablendeklaration - die DontDelete'able-Eigenschaft erstellt und die letztere nicht. Infolgedessen kann die über diese implizite Zuweisung erstellte Eigenschaft aus dem globalen Objekt gelöscht werden, und die erstere - die über die Variablendeklaration erstellte - kann nicht gelöscht werden.

Dies ist natürlich nur eine Theorie, und in der Praxis gibt es aufgrund verschiedener Fehler in Implementierungen (z. B. von IE) noch mehr Unterschiede zwischen den beiden .

Hoffe alles macht Sinn :)

[Update 16.12.2010]

In ES5 (ECMAScript 5; kürzlich standardisierte 5. Ausgabe der Sprache) gibt es einen sogenannten "strengen Modus" - einen Opt-In-Sprachmodus, der das Verhalten nicht deklarierter Zuweisungen geringfügig ändert. Im strengen Modus ist die Zuweisung zu einem nicht deklarierten Bezeichner ein ReferenceError . Der Grund dafür war, versehentliche Zuweisungen zu erfassen und die Schaffung unerwünschter globaler Eigenschaften zu verhindern. Einige der neueren Browser haben bereits damit begonnen, den strengen Modus zu unterstützen. Siehe zum Beispiel meine kompatible Tabelle .

Zu sagen, dass es der Unterschied zwischen " lokal und global " ist, ist nicht ganz richtig.

Es könnte besser sein, es als den Unterschied zwischen " lokal und am nächsten " zu betrachten. Der nächste kann sicherlich global sein, aber das wird nicht immer der Fall sein.

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

Wenn Javascript in einem Browser ausgeführt wird, ist Ihr gesamter Code von einer with-Anweisung umgeben, wie folgt:

with (window) {
    //Your code
}

Weitere Infos zu with- MDN

Da vareine Variable im aktuellen Bereich deklariert wird , gibt es keinen Unterschied zwischen der Deklaration var innerhalb des Fensters und der Deklaration überhaupt nicht.

Der Unterschied entsteht, wenn Sie sich nicht direkt im Fenster befinden, z. B. innerhalb einer Funktion oder innerhalb eines Blocks.

Mit varkönnen Sie externe Variablen mit demselben Namen ausblenden. Auf diese Weise können Sie eine "private" Variable simulieren, aber das ist ein anderes Thema.

Als Faustregel gilt, immer zu verwenden var, da sonst die Gefahr besteht, dass subtile Fehler auftreten.

EDIT: Nach den Kritiken, die ich erhalten habe, möchte ich Folgendes hervorheben:

• vardeklariert eine Variable im aktuellen Bereich
• Der globale Geltungsbereich ist window
• Nicht varimplizite Deklarationen varim globalen Bereich (Fenster) verwenden
• Das Deklarieren einer Variablen im globalen Bereich (Fenster) mit varist dasselbe wie das Weglassen.
• Das Deklarieren einer Variablen in Bereichen, die sich von der Verwendung von Fenstern unterscheiden, var ist nicht dasselbe wie das Deklarieren einer Variablen ohnevar
• Immer varexplizit deklarieren, da dies eine gute Praxis ist

Verwenden Sie immer das varSchlüsselwort, um Variablen zu deklarieren. Warum? Eine gute Codierungspraxis sollte an sich schon ein Grund genug sein, aber wenn sie weggelassen wird, bedeutet dies, dass sie im globalen Bereich deklariert ist (eine Variable wie diese wird als "implizite" globale bezeichnet). Douglas Crockford empfiehlt, niemals implizite Globale zu verwenden und gemäß den Apple JavaScript Coding Guidelines :

Jede Variable, die ohne das var Schlüsselwort erstellt wurde, wird im globalen Bereich erstellt und bei der Rückkehr der Funktion (da sie nicht außerhalb des Bereichs liegt) nicht als Müll gesammelt, was die Möglichkeit eines Speicherverlusts bietet.

Hier ist ein gutes Beispiel dafür, wie Sie davon abgehalten werden können, lokale Variablen nicht zu deklarieren mit var:

<script>
one();

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

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

( iwird bei jeder Iteration der Schleife zurückgesetzt, da sie nicht lokal in der forSchleife, sondern global deklariert wird ), was schließlich zu einer Endlosschleife führt

Ich würde sagen, es ist besser, varin den meisten Situationen zu verwenden.

Lokale Variablen sind immer schneller als die Variablen im globalen Bereich.

Wenn Sie keine varVariable deklarieren, befindet sich die Variable im globalen Bereich.

Für weitere Informationen können Sie in Google nach "Scope Chain JavaScript" suchen.

Nicht benutzen var!

varwar die Möglichkeit vor ES6, eine Variable zu deklarieren. Wir sind jetzt in der Zukunft , und Sie sollten als solche codieren.

Verwenden Sie constundlet

constsollte in 95% der Fälle verwendet werden. Dadurch kann sich die Variablenreferenz nicht ändern, sodass sich die Eigenschaften von Arrays, Objekten und DOM-Knoten ändern können und wahrscheinlich auch ändern sollten const.

letsollte für jede Variable verwendet werden, die eine Neuzuweisung erwartet. Dies schließt innerhalb einer for-Schleife ein. Wenn Sie jemals varName =über die Initialisierung hinaus schreiben , verwenden Sie let.

Beide haben Block-Level-Scoping, wie in den meisten anderen Sprachen erwartet.

ein weiterer Unterschied, z

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

während

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

Die Verwendung varist immer eine gute Idee, um zu verhindern, dass Variablen den globalen Bereich überladen und Variablen in Konflikt miteinander geraten, was zu unerwünschtem Überschreiben führt.

Ohne var- globale Variable.

Es wird dringend empfohlen, IMMER eine varAnweisung zu verwenden, da die globale Variable init im lokalen Kontext böse ist. Wenn Sie diesen schmutzigen Trick benötigen, sollten Sie am Anfang der Seite einen Kommentar schreiben:

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

Dies ist ein Beispielcode, den ich geschrieben habe, damit Sie dieses Konzept verstehen:

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 gab ein schönes Beispiel, das den praktischen Unterschied (und die Gefahr) zwischen varund nein zeigt var. Hier ist eine andere, ich finde diese besonders gefährlich, da der Unterschied nur in einer asynchronen Umgebung sichtbar ist, so dass er beim Testen leicht vorbeigehen kann.

Wie zu erwarten, die folgenden Snippet-Ausgaben ["text"]:

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

console.log(var_fun())

So auch das folgende Snippet (beachten Sie das fehlende letvorher array):

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

console.log(var_fun())

Das asynchrone Ausführen der Datenmanipulation führt immer noch zu demselben Ergebnis mit einem einzelnen Executor:

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

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

Aber verhält sich bei mehreren anders:

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

Verwenden Sie jedoch:

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

Als jemand, der versucht, dies zu lernen, sehe ich das so. Die obigen Beispiele waren für einen Anfänger vielleicht etwas zu kompliziert.

Wenn Sie diesen Code ausführen:

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

Die Ausgabe lautet wie folgt: false, false, true, true

Weil die Variablen in der Funktion als von denen außerhalb der Funktion getrennt angesehen werden, daher der Begriff lokale Variable, und dies lag daran, dass wir var in der Zuweisung verwendet haben. Wenn Sie die Variable in der Funktion entfernen, lautet sie jetzt wie folgt:

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

Die Ausgabe ist falsch, falsch, falsch, falsch

Dies liegt daran, dass anstatt eine neue Variable im lokalen Bereich oder in der lokalen Funktion zu erstellen, einfach die globalen Variablen verwendet und sie false zugewiesen werden.

Ich sehe, dass Leute verwirrt sind, wenn sie Variablen mit oder ohne var und innerhalb oder außerhalb der Funktion deklarieren . Hier ist ein tiefes Beispiel, das Sie durch diese Schritte führt:

Sehen Sie das Skript unten in Aktion hier bei 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);

Fazit

1. Unabhängig davon, ob mit oder ohne var (wie a, b) deklariert wird, wenn sie ihren Wert außerhalb der Funktion erhalten, behalten sie ihren Wert bei, und auch alle anderen Werte, die innerhalb verschiedener Funktionen durch das Skript hinzugefügt werden, bleiben erhalten.
2. Wenn die Variable innerhalb einer Funktion (wie c) ohne var deklariert wird, verhält sie sich wie die vorherige Regel und behält von nun an ihren Wert für alle Funktionen bei. Entweder hat es seinen ersten Wert in der Funktion testVar1 () erhalten, es behält den Wert bei und erhält einen zusätzlichen Wert in der Funktion testVar2 ()
3. Wenn die Variable nur innerhalb einer Funktion mit var deklariert wird (wie d in testVar1 oder testVar2), ist sie bei jedem Ende der Funktion undefiniert. Es wird also eine temporäre Variable in einer Funktion sein.

Wenn Sie in einem Code eine Variable verwenden, ohne var zu verwenden, wird automatisch der var var_name in den globalen Bereich eingefügt, z.

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

Neben dem Thema Scopes erwähnen einige Leute auch das Heben , aber niemand gab ein Beispiel. Hier ist eine für den globalen Geltungsbereich:

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

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

Ohne Verwendung von "var" können Variablen nur definieren, wenn ein Wert festgelegt wird. Zum Beispiel:

my_var;

kann nicht im globalen oder einem anderen Bereich arbeiten . Es sollte einen Wert haben wie:

my_var = "value";

Auf der anderen Seite können Sie ein vaiable like definieren;

var my_var;

Sein Wert ist undefined(Sein Wert ist nicht nullund es ist nicht gleich nullinteressant.).

Sie sollten das Schlüsselwort var verwenden, es sei denn, Sie möchten, dass die Variable im Browser an das Fensterobjekt angehängt wird. Hier ist ein Link, der das Scoping und den Unterschied zwischen glokalem Scoping und lokalem Scoping mit und ohne var-Schlüsselwort erklärt.

Wenn Variablen ohne Verwendung des Schlüsselworts var definiert werden, sieht es nach einer einfachen Zuweisungsoperation aus.

Wenn der Wert einer Variablen in Javascript zugewiesen wird, versucht der Interpreter zunächst, die „Variablendeklaration“ im selben Kontext / Bereich wie die Zuweisung zu finden. Wenn der Interpreter ausgeführt wird dummyVariable = 20, sucht er zu Beginn der Funktion nach der Deklaration von dummyVariable. (Da alle Variablendeklarationen vom Javascript-Interpreter an den Anfang des Kontexts verschoben werden und dies als Heben bezeichnet wird)

Vielleicht möchten Sie auch das Heben in Javascript betrachten