javascript - support - unterschied var let const




Was ist der Unterschied zwischen "let" und "var", um eine Variable in JavaScript zu deklarieren? (18)

let

Bereich blockieren

Variablen, die mit dem Schlüsselwort let deklariert wurden, haben einen Blockbereich, dh sie sind nur in dem Block verfügbar , in dem sie deklariert wurden.

Auf oberster Ebene (außerhalb einer Funktion)

Auf der obersten Ebene erstellen mit let deklarierte Variablen keine Eigenschaften für das globale Objekt.

var globalVariable = 42;
let blockScopedVariable = 43;

console.log(globalVariable); // 42
console.log(blockScopedVariable); // 43

console.log(this.globalVariable); // 42
console.log(this.blockScopedVariable); // undefined

In einer Funktion

In einer Funktion (aber außerhalb eines Blocks) hat let den gleichen Gültigkeitsbereich wie var .

(() => {
  var functionScopedVariable = 42;
  let blockScopedVariable = 43;

  console.log(functionScopedVariable); // 42
  console.log(blockScopedVariable); // 43
})();

console.log(functionScopedVariable); // ReferenceError: functionScopedVariable is not defined
console.log(blockScopedVariable); // ReferenceError: blockScopedVariable is not defined

In einem Block

Variablen, die mit let innerhalb eines Blocks deklariert wurden, können außerhalb dieses Blocks nicht aufgerufen werden.

{
  var globalVariable = 42;
  let blockScopedVariable = 43;
  console.log(globalVariable); // 42
  console.log(blockScopedVariable); // 43
}

console.log(globalVariable); // 42
console.log(blockScopedVariable); // ReferenceError: blockScopedVariable is not defined

In einer Schleife

Mit let in loops deklarierte Variablen können nur innerhalb dieser Schleife referenziert werden.

for (var i = 0; i < 3; i++) {
  var j = i * 2;
}
console.log(i); // 3
console.log(j); // 4

for (let k = 0; k < 3; k++) {
  let l = k * 2;
}
console.log(typeof k); // undefined
console.log(typeof l); // undefined
// Trying to do console.log(k) or console.log(l) here would throw a ReferenceError.

Loops mit Verschlüssen

Wenn Sie in einer Schleife let statt var , erhalten Sie bei jeder Iteration eine neue Variable. Das bedeutet, dass Sie einen Verschluss innerhalb einer Schleife sicher verwenden können.

// Logs 3 thrice, not what we meant.
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0);
}

// Logs 0, 1 and 2, as expected.
for (let j = 0; j < 3; j++) {
  setTimeout(() => console.log(j), 0);
}

Temporale Totzone

Auf die mit let deklarierten Variablen kann aufgrund der temporären Totzone nicht zugegriffen werden, bevor sie deklariert werden. Wenn Sie dies versuchen, wird ein Fehler ausgegeben.

console.log(noTDZ); // undefined
var noTDZ = 43;
console.log(hasTDZ); // ReferenceError: hasTDZ is not defined
let hasTDZ = 42;

Keine erneute Deklaration

Sie können dieselbe Variable nicht mehrmals mit let deklarieren. Sie können eine Variable auch nicht mit let deklarieren let die dieselbe Kennung wie eine andere Variable hat, die mit var deklariert wurde.

var a;
var a; // Works fine.

let b;
let b; // SyntaxError: Identifier 'b' has already been declared

var c;
let c; // SyntaxError: Identifier 'c' has already been declared

const

const ist ziemlich ähnlich wie let - es hat einen Blockbereich und hat TDZ. Es gibt jedoch zwei Dinge, die sich unterscheiden.

Keine Neuzuweisung

Mit const deklarierte Variablen können nicht erneut zugewiesen werden.

const a = 42;
a = 43; // TypeError: Assignment to constant variable.

Beachten Sie, dass dies nicht bedeutet, dass der Wert unveränderlich ist. Ihre Eigenschaften können noch geändert werden.

const obj = {};
obj.a = 42;
console.log(obj.a); // 42

Wenn Sie ein unveränderliches Objekt haben möchten, sollten Sie Object.freeze() .

Initialisierer ist erforderlich

Sie müssen immer einen Wert angeben, wenn Sie eine Variable mit const deklarieren.

const a; // SyntaxError: Missing initializer in const declaration

ECMAScript 6 führte die let Anweisung ein . Ich habe gehört, dass es als "lokale" Variable beschrieben wird, aber ich bin immer noch nicht ganz sicher, wie es sich anders verhält als das Schlüsselwort var .

Was sind die Unterschiede? Wann sollte über var ?


Funktions-VS-Blockumfang:

Der wesentliche Unterschied zwischen varund letist , dass Variablen deklariert mit varsind Funktion scoped . Funktionen, die mit deklariert letsind , haben Blockbereich . 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 testVaraufgerufen wird, ist die mit deklarierte Variable foo varauch außerhalb der ifAnweisung zugänglich . Diese Variable foosteht im Rahmen der Funktion überall zur Verfügung .testVar

Variablen mit let:

Wenn die zweite Funktion testLetaufgerufen wird, ist die mit deklarierte Variablenleiste letnur innerhalb der ifAnweisung zugänglich . Da mit deklarierten Variablen letsind Block scoped (wobei ein Block ist der Code zwischen geschweiften Klammern z if{}, for{}, function{}).

let Variablen werden nicht gehisst:

Ein weiterer Unterschied zwischen varund letist Variablen mit erklärte mit let nicht hochgezogen bekommen . Ein Beispiel ist der beste Weg, um dieses Verhalten zu veranschaulichen:

Variablen mit let nicht gehisst werden:

console.log(letVar);

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

Variablen mit var do werden gehisst:

console.log(varVar);

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

Global letwird nicht gebunden an window:

Eine letim globalen Gültigkeitsbereich deklarierte Variable (dh Code, der nicht in einer Funktion enthalten ist) wird nicht als Eigenschaft für das globale windowObjekt hinzugefügt . Zum Beispiel (dieser Code liegt im 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übergebraucht werden var?

Verwenden Sie letover, varwann immer Sie können, weil es einfach spezifischer ist. Dies reduziert mögliche Namenskonflikte, die bei einer großen Anzahl von Variablen auftreten können. varkann verwendet werden, wenn eine globale Variable explizit auf dem windowObjekt sein soll (immer sorgfältig prüfen, ob dies wirklich erforderlich ist).


Der Hauptunterschied ist der Unterschied des Bereichs , während let nur innerhalb des von ihm deklarierten Bereichs verfügbar sein kann. Wie in for loop kann auf var beispielsweise außerhalb der Schleife zugegriffen werden. Aus der Dokumentation im MDN (Beispiele auch aus MDN):

Mit let können Sie Variablen deklarieren, deren Umfang auf den Block, die Anweisung oder den Ausdruck beschränkt ist, für den sie verwendet werden. Dies unterscheidet sich vom Schlüsselwort var , das eine Variable global oder lokal für eine ganze Funktion definiert, unabhängig vom Blockumfang.

Von let deklarierte Variablen haben den Block, in dem sie definiert sind, sowie in den enthaltenen Unterblöcken. Auf diese Weise funktioniert var sehr ähnlich. Der Hauptunterschied besteht darin, dass der Gültigkeitsbereich einer var- Variablen die gesamte umgebende Funktion ist:

function varTest() {
  var x = 1;
  if (true) {
    var x = 2;  // same variable!
    console.log(x);  // 2
  }
  console.log(x);  // 2
}

function letTest() {
  let x = 1;
  if (true) {
    let x = 2;  // different variable
    console.log(x);  // 2
  }
  console.log(x);  // 1
}`

Auf der obersten Ebene von Programmen und Funktionen erstellt let im Gegensatz zu var keine Eigenschaft für das globale Objekt. Zum Beispiel:

var x = 'global';
let y = 'global';
console.log(this.x); // "global"
console.log(this.y); // undefined

Bei Verwendung innerhalb eines Blocks darf der Gültigkeitsbereich der Variablen auf diesen Block begrenzt werden. Beachten Sie den Unterschied zwischen var, dessen Gültigkeitsbereich innerhalb der Funktion liegt, in der er deklariert ist.

var a = 1;
var b = 2;

if (a === 1) {
  var a = 11; // the scope is global
  let b = 22; // the scope is inside the if-block

  console.log(a);  // 11
  console.log(b);  // 22
} 

console.log(a); // 11
console.log(b); // 2

Vergessen Sie auch nicht, dass die ECMA6-Funktion noch nicht vollständig unterstützt wird. Es empfiehlt sich daher, sie immer unter Verwendung von Babel usw. auf ECMA5 umzurüsten


Der Unterschied ist der Umfang. var ist auf den nächstgelegenen Funktionsblock beschränkt und let auf den nächstgelegenen umgebenden Block, der kleiner sein kann als ein Funktionsblock. Beide sind global, wenn sie sich außerhalb eines Blocks befinden.

Mit let deklarierte Variablen sind auch nicht zugänglich, bevor sie in ihrem umgebenden Block deklariert werden. Wie in der Demo zu sehen ist, wird eine ReferenceError-Ausnahme ausgelöst.

Demo :

var html = '';

write('#### global ####\n');
write('globalVar: ' + globalVar); //undefined, but visible

try {
  write('globalLet: ' + globalLet); //undefined, *not* visible
} catch (exception) {
  write('globalLet: exception');
}

write('\nset variables');

var globalVar = 'globalVar';
let globalLet = 'globalLet';

write('\nglobalVar: ' + globalVar);
write('globalLet: ' + globalLet);

function functionScoped() {
  write('\n#### function ####');
  write('\nfunctionVar: ' + functionVar); //undefined, but visible

  try {
    write('functionLet: ' + functionLet); //undefined, *not* visible
  } catch (exception) {
    write('functionLet: exception');
  }

  write('\nset variables');

  var functionVar = 'functionVar';
  let functionLet = 'functionLet';

  write('\nfunctionVar: ' + functionVar);
  write('functionLet: ' + functionLet);
}

function blockScoped() {
  write('\n#### block ####');
  write('\nblockVar: ' + blockVar); //undefined, but visible

  try {
    write('blockLet: ' + blockLet); //undefined, *not* visible
  } catch (exception) {
    write('blockLet: exception');
  }

  for (var blockVar = 'blockVar', blockIndex = 0; blockIndex < 1; blockIndex++) {
    write('\nblockVar: ' + blockVar); // visible here and whole function
  };

  for (let blockLet = 'blockLet', letIndex = 0; letIndex < 1; letIndex++) {
    write('blockLet: ' + blockLet); // visible only here
  };

  write('\nblockVar: ' + blockVar);

  try {
    write('blockLet: ' + blockLet); //undefined, *not* visible
  } catch (exception) {
    write('blockLet: exception');
  }
}

function write(line) {
  html += (line ? line : '') + '<br />';
}

functionScoped();
blockScoped();

document.getElementById('results').innerHTML = html;
<pre id="results"></pre>

Global:

Sie sind sehr ähnlich, wenn sie außerhalb eines Funktionsblocks verwendet werden.

let me = 'go';  // globally scoped
var i = 'able'; // globally scoped

Mit let definierte globale Variablen werden jedoch nicht als Eigenschaften für das globale window wie die mit var definierten hinzugefügt.

console.log(window.me); // undefined
console.log(window.i); // 'able'

Funktion:

Sie sind identisch, wenn sie in einem Funktionsbaustein so verwendet werden.

function ingWithinEstablishedParameters() {
    let terOfRecommendation = 'awesome worker!'; //function block scoped
    var sityCheerleading = 'go!'; //function block scoped
}

Block:

Hier ist der Unterschied. let ist nur in der for() Schleife sichtbar und var ist für die gesamte Funktion sichtbar.

function allyIlliterate() {
    //tuce is *not* visible out here

    for( let tuce = 0; tuce < 5; tuce++ ) {
        //tuce is only visible in here (and in the for() parentheses)
        //and there is a separate tuce variable for each iteration of the loop
    }

    //tuce is *not* visible out here
}

function byE40() {
    //nish *is* visible out here

    for( var nish = 0; nish < 5; nish++ ) {
        //nish is visible to the whole function
    }

    //nish *is* visible out here
}

Redeclaration:

Im strikten Modus können Sie dieselbe Variable im selben Gültigkeitsbereich erneut deklarieren. Auf der anderen Seite let nicht:

'use strict';
let me = 'foo';
let me = 'bar'; // SyntaxError: Identifier 'me' has already been declared
'use strict';
var me = 'foo';
var me = 'bar'; // No problem, `me` is replaced.

Es gibt einige subtile Unterschiede - let Scoping-Verhalten sich mehr wie das variable Scoping in mehr oder weniger jeder anderen Sprache verhalten.

ZB deckt es den umgebenden Block ab. Sie existieren nicht, bevor sie deklariert werden usw.

Es ist jedoch erwähnenswert, dass let nur ein Teil neuerer Javascript-Implementierungen ist und unterschiedliche Browserunterstützung bietet.


Hier ist ein Beispiel für den Unterschied zwischen den beiden (Unterstützung gerade für Chrome gestartet):

Wie Sie sehen, hat die Variable var j immer noch einen Wert außerhalb des for-Loop-Bereichs (Block Scope), die let i Variable ist jedoch außerhalb des for-Loop-Bereichs undefiniert.

"use strict";
console.log("var:");
for (var j = 0; j < 2; j++) {
  console.log(j);
}

console.log(j);

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

console.log(i);


Hier ist eine Erklärung des let Schlüsselworts mit einigen Beispielen.

lass sehr wie var arbeiten. Der Hauptunterschied besteht darin, dass der Gültigkeitsbereich einer var-Variablen die gesamte einschließende Funktion ist

Diese Tabelle auf Wikipedia zeigt, welche Browser Javascript 1.7 unterstützen.

Beachten Sie, dass dies nur von Mozilla- und Chrome-Browsern unterstützt wird. IE, Safari und möglicherweise andere nicht.



let kann auch verwendet werden, um Probleme mit Verschlüssen zu vermeiden. Es bindet neue Werte, anstatt eine alte Referenz zu behalten, wie in den folgenden Beispielen gezeigt.

DEMO

for(var i = 1; i < 6; i++) {
  document.getElementById('my-element' + i)
    .addEventListener('click', function() { alert(i) })
}

Der obige Code demonstriert ein klassisches Problem beim Schließen von JavaScript. Der Verweis auf die i Variable wird im Klick-Handler-Abschluss gespeichert und nicht auf den tatsächlichen Wert von i .

Jeder einzelne Click-Handler verweist auf dasselbe Objekt, da es nur ein Counter-Objekt gibt, das 6 enthält, sodass Sie bei jedem Klick sechs erhalten.

Eine allgemeine Problemumgehung besteht darin, diese Funktion in eine anonyme Funktion zu packen und i als Argument zu übergeben. Solche Probleme können jetzt auch vermieden werden, indem stattdessen var wie im folgenden Code gezeigt verwendet wird.

DEMO (Getestet in Chrome und Firefox 50)

'use strict';

for(let i = 1; i < 6; i++) {
  document.getElementById('my-element' + i)
    .addEventListener('click', function() { alert(i) })
}

var ist eine globale Gültigkeitsbereichsvariable.

letund constist Blockumfang.

test.js

{
    let l = 'let';
    const c = 'const';
    var v = 'var';
    v2 = 'var 2';
}

console.log(v, this.v);
console.log(v2, this.v2);
console.log(l); // ReferenceError: l is not defined
console.log(c); // ReferenceError: c is not defined


Es scheint auch, dass zumindest in Visual Studio 2015 TypeScript 1.5 "var" mehrere Deklarationen desselben Variablennamens in einem Block zulässt und "let" keine.

Dies erzeugt keinen Kompilierungsfehler:

var x = 1;
var x = 2;

Dieser Wille:

let x = 1;
let x = 2;

In diesem Artikel wird der Unterschied zwischen var, let und const klar definiert

const ist ein Signal, dass die Kennung nicht erneut zugewiesen wird.

letist ein Signal, dass die Variable neu zugewiesen werden kann, wie z. B. ein Zähler in einer Schleife oder ein Werteaustausch in einem Algorithmus. Es signalisiert auch, dass die Variable nur in dem Block verwendet wird, in dem sie definiert ist. Dies ist nicht immer die gesamte enthaltende Funktion.

varist jetzt das schwächste Signal, das verfügbar ist, wenn Sie eine Variable in JavaScript definieren. Die Variable kann neu zugewiesen werden oder nicht, und die Variable kann für eine gesamte Funktion oder nur für den Zweck eines Blocks oder einer Schleife verwendet werden oder nicht.

https://medium.com/javascript-scene/javascript-es6-var-let-or-const-ba58b8dcde75#.esmkpbg9b


Wie oben erwähnt:

Der Unterschied ist der Umfang. varerstreckt sich auf den nächstgelegenen Funktionsblock und letauf den nächstgelegenen Umschließungsblock , der kleiner als ein Funktionsblock sein kann. Beide sind global, wenn sie sich außerhalb eines Blocks befinden. Sehen wir uns ein Beispiel an:

Beispiel 1:

In meinen beiden Beispielen habe ich eine Funktion myfunc. myfuncenthält eine Variable myvargleich 10. In meinem ersten Beispiel überprüfe ich, ob myvar10 ( myvar==10) gleich ist. Wenn ja, deklariere ich eine Variable myvar(jetzt habe ich zwei Myvar-Variablen) mit varSchlüsselwort und weise einen neuen Wert (20) zu. In der nächsten Zeile drucke ich den Wert auf meine Konsole. Nach dem Bedingungsblock drucke ich den Wert von erneut myvarauf meiner Konsole. Wenn Sie sich die Ausgabe von ansehen myfunc, myvarhat der Wert 20.

Beispiel 2: In meinem zweiten Beispiel vardeklariere ich anstelle von Schlüsselwort in meinem Bedingungsblock myvardas letSchlüsselwort. Wenn ich jetzt anrufe, myfuncbekomme ich zwei verschiedene Ausgänge: myvar=20und myvar=10.

Der Unterschied ist also sehr einfach, dh der Umfang.


Überprüfen Sie diesen Link in MDN

let x = 1;

if (x === 1) {
let x = 2;

console.log(x);
// expected output: 2
}

console.log(x);
// expected output: 1

Der Unterschied liegt im scope der mit jedem deklarierten Variablen.

In der Praxis hat der unterschiedliche Umfang eine Reihe nützlicher Konsequenzen:

  1. letVariablen sind nur in ihrem nächsten umschließenden Block ( { ... }) sichtbar .
  2. letVariablen sind nur in Codezeilen verwendbar, die nach der Deklaration der Variablen auftreten (obwohl sie angehoben sind !).
  3. letVariablen können nicht durch ein nachfolgendes varoder neu deklariert werden let.
  4. Globale letVariablen werden nicht zum globalen windowObjekt hinzugefügt .
  5. letVariablen sind bei Schließungen einfach zu verwenden (sie verursachen keine Race-Bedingungen ).

Die durch letdie Einschränkung auferlegten Einschränkungen verringern die Sichtbarkeit der Variablen und erhöhen die Wahrscheinlichkeit, dass unerwartete Namenskollisionen früh gefunden werden. Auf diese Weise können Variablen und deren reachability leichter verfolgt und begründet werden (Unterstützung bei der Rückforderung nicht genutzten Speichers).

Daher ist letes weniger wahrscheinlich, dass Variablen Probleme verursachen, wenn sie in großen Programmen verwendet werden oder wenn unabhängig entwickelte Frameworks auf neue und unerwartete Weise kombiniert werden.

varkann dennoch nützlich sein, wenn Sie sicher sind, dass Sie den Single-Binding-Effekt bei der Verwendung eines Abschlusses in einer Schleife (# 5) oder zum Deklarieren von extern sichtbaren globalen Variablen in Ihrem Code (# 4) erzielen möchten. varFür Exporte kann die Verwendung von for ersetzt werden, wenn Sie exportaus dem Transpilerraum in die Kernsprache migriert werden.

Beispiele

1. Keine Verwendung außerhalb des nächsten umschließenden Blocks: Dieser Codeblock löst einen Referenzfehler aus, da die zweite Verwendung von xaußerhalb des Blocks erfolgt, in dem er deklariert ist mit let:

{
    let x = 1;
}
console.log(`x is ${x}`);  // ReferenceError during parsing: "x is not defined".

Im Gegensatz dazu das gleiche Beispiel mit varWerken.

2. Keine Verwendung vor Deklaration:
Dieser Codeblock wirft ein, ReferenceErrorbevor der Code ausgeführt werden kann, da er verwendet xwird, bevor er deklariert wird:

{
    x = x + 1;  // ReferenceError during parsing: "x is not defined".
    let x;
    console.log(`x is ${x}`);  // Never runs.
}

Im Gegensatz dazu varläuft das gleiche Beispiel mit Parses und Runs, ohne dass es Ausnahmen gibt.

3. Keine Redeclaration: Der folgende Code zeigt, dass eine mit deklarierte Variable letspäter nicht erneut deklariert werden kann:

let x = 1;
let x = 2;  // SyntaxError: Identifier 'x' has already been declared

4. Globals nicht angehängt an window:

var button = "I cause accidents because my name is too common.";
let link = "Though my name is common, I am harder to access from other JS files.";
console.log(link);  // OK
console.log(window.link);  // undefined (GOOD!)
console.log(window.button);  // OK

5. Einfache Verwendung mit Verschlüssen: Variablen, die mit deklariert wurden, varfunktionieren nicht gut mit Verschlüssen in Schleifen. Hier ist eine einfache Schleife, die die Folge von Werten ausgibt, die die Variable izu verschiedenen Zeitpunkten hat:

for (let i = 0; i < 5; i++) {
    console.log(`i is ${i}`), 125/*ms*/);
}

Im Einzelnen gibt dies aus:

i is 0
i is 1
i is 2
i is 3
i is 4

In JavaScript verwenden wir Variablen zu einem wesentlich späteren Zeitpunkt als bei ihrer Erstellung. Wenn wir dies demonstrieren, indem wir die Ausgabe mit einer Schließung verzögern, die übergeben wird an setTimeout:

for (let i = 0; i < 5; i++) {
    setTimeout(_ => console.log(`i is ${i}`), 125/*ms*/);
}

... die Ausgabe bleibt unverändert, solange wir dabei bleiben let. Wenn wir dagegen verwendet hätten var i:

for (var i = 0; i < 5; i++) {
    setTimeout(_ => console.log(`i is ${i}`), 125/*ms*/);
}

... die Schleife gibt fünfmal unerwartet "i is 5" aus:

i is 5
i is 5
i is 5
i is 5
i is 5

Einige Hacks mit let:

1

    let statistics = [16, 170, 10];
    let [age, height, grade] = statistics;

    console.log(height)

2

    let x = 120,
    y = 12;
    [x, y] = [y, x];
    console.log(`x: ${x} y: ${y}`);

3.

    let node = {
                   type: "Identifier",
                   name: "foo"
               };

    let { type, name, value } = node;

    console.log(type);      // "Identifier"
    console.log(name);      // "foo"
    console.log(value);     // undefined

    let node = {
        type: "Identifier"
    };

    let { type: localType, name: localName = "bar" } = node;

    console.log(localType);     // "Identifier"
    console.log(localName);     // "bar"

Getter und Setter mit let:

let jar = {
    numberOfCookies: 10,
    get cookies() {
        return this.numberOfCookies;
    },
    set cookies(value) {
        this.numberOfCookies = value;
    }
};

console.log(jar.cookies)
jar.cookies = 7;

console.log(jar.cookies)

Wenn ich die Spezifikationen richtig gelesen habe, kann man let dankenswerterweise auch dazu beitragen, selbst aufzurufende Funktionen zu vermeiden, mit denen nur private Mitglieder simuliert werden - ein beliebtes Entwurfsmuster, das die Lesbarkeit von Code verringert, das Debuggen verkompliziert und keinen wirklichen Code-Schutz oder andere Vorteile bietet - es sei denn, man kann damit zufrieden sein Verlangen nach Semantik, also hör auf damit zu arbeiten. /schimpfen

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 ' Private Schnittstellen emulieren '


let ist ein Teil von es6. Diese Funktionen erklären den Unterschied auf einfache Weise.

function varTest() {
  var x = 1;
  if (true) {
    var x = 2;  // same variable!
    console.log(x);  // 2
  }
  console.log(x);  // 2
}

function letTest() {
  let x = 1;
  if (true) {
    let x = 2;  // different variable
    console.log(x);  // 2
  }
  console.log(x);  // 1
}




let