Was ist der Unterschied zwischen der Verwendung von "let" und "var"?

Question

ECMAScript 6 eingeführt die let Anweisung .

Ich habe gehört, dass man es als eine local Variable, aber ich bin mir immer noch nicht ganz sicher, warum sie sich anders verhält als die var Stichwort.

Was sind die Unterschiede? Wann sollte let verwendet werden anstelle von var ?

Answer 1

Mit ES6 wurden zwei neue Schlüsselwörter( lassen Sie y const ) abwechselnd zu var .

Wenn Sie eine Verzögerung auf Blockebene benötigen, können Sie let und const anstelle von var verwenden.

Die folgende Tabelle fasst den Unterschied zwischen var, let und const zusammen

Answer 2

Funktion VS-Blockumfang:

Der Hauptunterschied zwischen var y let ist, dass Variablen, die mit var sind funktionsabhängig . Funktionen, die mit let sind blockabhängig . Zum Beispiel:

function testVar () {
  if(true) {
    var foo = 'foo';
  }

  console.log(foo);
}

testVar();  
// logs 'foo'

function testLet () {
  if(true) {
    let bar = 'bar';
  }

  console.log(bar);
}

testLet(); 
// reference error
// bar is scoped to the block of the if statement 

Variablen mit var :

Wenn die erste Funktion testVar wird die Variable foo aufgerufen, die mit var ist auch außerhalb des if Erklärung. Diese Variable foo zur Verfügung stehen würde überall im Rahmen der testVar Funktion .

Variablen mit let :

Wenn die zweite Funktion testLet wird die Variable bar aufgerufen, die mit let ist nur innerhalb des if Erklärung. Da Variablen, die mit let sind blockabhängig (wobei ein Block der Code zwischen geschweiften Klammern ist, z. B. if{} , for{} , function{} ).

let Variablen werden nicht hochgezogen:

Ein weiterer Unterschied zwischen var y let sind Variablen mit deklariert mit let Lassen Sie sich nicht hochziehen . Dieses Verhalten lässt sich am besten an einem Beispiel erläutern:

Variablen mit let nicht hochgezogen werden:

console.log(letVar);

let letVar = 10;
// referenceError, the variable doesn't get hoisted

Variablen mit var tun hochgezogen werden:

console.log(varVar);

var varVar = 10;
// logs undefined, the variable gets hoisted

Global let sich nicht an den window :

Eine Variable, die mit let im globalen Bereich (d.h. Code, der sich nicht in einer Funktion befindet), wird nicht als Eigenschaft der globalen window Objekt. Ein Beispiel (dieser Code hat einen globalen Geltungsbereich):

var bar = 5;
let foo  = 10;

console.log(bar); // logs 5
console.log(foo); // logs 10

console.log(window.bar);  
// logs 5, variable added to window object

console.log(window.foo);
// logs undefined, variable not added to window object

Wann sollte let verwendet werden über var ?

Utilice let über var wann immer Sie können, weil es einfach spezifischer ist. Dadurch werden potenzielle Benennungskonflikte, die bei einer großen Anzahl von Variablen auftreten können, reduziert. var kann verwendet werden, wenn Sie wollen, dass eine globale Variable explizit in der window Objekt (überlegen Sie immer genau, ob dies wirklich notwendig ist).

Answer 3

let ist interessant, weil es uns erlaubt, so etwas zu tun:

(() => {
    var count = 0;

    for (let i = 0; i < 2; ++i) {
        for (let i = 0; i < 2; ++i) {
            for (let i = 0; i < 2; ++i) {
                console.log(count++);
            }
        }
    }
})();

Das Ergebnis ist die Zählung [0, 7].

.

(() => {
    var count = 0;

    for (var i = 0; i < 2; ++i) {
        for (var i = 0; i < 2; ++i) {
            for (var i = 0; i < 2; ++i) {
                console.log(count++);
            }
        }
    }
})();

Zählt nur [0, 1].

Answer 4

Es scheint auch, dass zumindest in Visual Studio 2015, TypeScript 1.5, "var" mehrere Deklarationen desselben Variablennamens in einem Block zulässt, während "let" dies nicht tut.

Dies wird keinen Kompilierfehler erzeugen:

var x = 1;
var x = 2;

Dies wird:

let x = 1;
let x = 2;

Answer 5

Wenn ich die technischen Daten richtig lese, dann let zum Glück kann auch genutzt werden, um zu vermeiden selbstaufrufende Funktionen verwendet, um nur private Mitglieder zu simulieren - ein beliebtes Entwurfsmuster, das die Lesbarkeit des Codes verschlechtert, die Fehlersuche erschwert und keinen wirklichen Schutz des Codes oder einen anderen Nutzen bietet - außer vielleicht den Wunsch nach Semantik zu befriedigen, also hören Sie auf, es zu verwenden. /rant

var SomeConstructor;

{
    let privateScope = {};

    SomeConstructor = function SomeConstructor () {
        this.someProperty = "foo";
        privateScope.hiddenProperty = "bar";
    }

    SomeConstructor.prototype.showPublic = function () {
        console.log(this.someProperty); // foo
    }

    SomeConstructor.prototype.showPrivate = function () {
        console.log(privateScope.hiddenProperty); // bar
    }

}

var myInstance = new SomeConstructor();

myInstance.showPublic();
myInstance.showPrivate();

console.log(privateScope.hiddenProperty); // error

Siehe ' Emulation privater Schnittstellen '