Quelle est la différence de performances entre «let» et «var» en JavaScript?


Réponse 1:

1. let est introduit dans es6 pour simplifier la portée de la variable. let est utilisé lorsqu'il y a une utilisation limitée de ces variables. Dites, pour les boucles, tandis que les boucles ou à l'intérieur de la portée des conditions if, etc.

ex :: for (let i = 0; i <10; i ++) {console.log (i)} // ici i est limité à for block block.

si vous essayez de l'imprimer en dehors du bloc de boucle for, il générera une erreur.

mais si vous avez utilisé var au lieu de laisser, il affichera i à l'intérieur et à l'extérieur de la boucle for.

2) les variables déclarées par var ont une portée de fonction et sont hissées vers le haut. Cela signifie qu'une variable peut être utilisée avant d'être déclarée. les variables let ne peuvent pas être utilisées avant la déclaration.

3) les variables * * ne peuvent pas être re-déclarées tandis que la variable var peut être re-déclarée dans la même portée.

ex ::

// en utilisant var

var a = "hi";

var a = "bonjour"; // remplacé facilement

// en utilisant let

soit b = "salut";

laissez b = "bonjour" // cela générera une erreur car ‘b est déjà déclaré’.

PS: vous pouvez essayer l'exemple ci-dessus dans votre console de navigateur pour bien le comprendre.


Réponse 2:

La différence est la portée. var est limité au bloc fonctionnel le plus proche et let est limité au bloc englobant le plus proche, qui peut être plus petit qu'un bloc fonctionnel. Les deux sont globaux si en dehors de tout bloc.

De plus, les variables déclarées avec let ne sont pas accessibles avant d'être déclarées dans leur bloc englobant. Comme vu dans la démo, cela lèvera une exception ReferenceError.

Global:

Ils sont très similaires lorsqu'ils sont utilisés comme ceci en dehors d'un bloc fonctionnel.

laissez-moi = 'aller'; // portée mondiale
var i = 'capable'; // portée mondiale

Cependant, les variables globales définies avec let ne seront pas ajoutées en tant que propriétés sur l'objet fenêtre global comme celles définies avec var.

console.log (window.me); // indéfini
console.log (window.i); // 'capable'

Une fonction:

Ils sont identiques lorsqu'ils sont utilisés comme ceci dans un bloc fonction.

function ingWithinEstablishedParameters () {
    laissez terOfRecommendation = 'super travailleur!'; // bloc fonctionnel délimité
    var sityCheerleading = 'allez!'; // bloc fonctionnel délimité
}

Bloquer:

Voici la différence. let n'est visible que dans la boucle for () et var est visible pour toute la fonction.

function allyIlliterate () {
    // tuce n'est * pas * visible ici

    for (let tuce = 0; tuce <5; tuce ++) {
        // tuce est uniquement visible ici (et dans les parenthèses for ())
        // et il y a une variable tuce distincte pour chaque itération de la boucle
    }

    // tuce n'est * pas * visible ici
}

fonction byE40 () {
    // nish * est * visible ici

    pour (var nish = 0; nish <5; nish ++) {
        // nish est visible par toute la fonction
    }

    // nish * est * visible ici
}

Redéclaration:

En supposant un mode strict, var vous permettra de re-déclarer la même variable dans la même portée. Par contre, ne voulons pas:

«utiliser strictement»;
laissez-moi = 'foo';
laissez-moi = 'bar'; // SyntaxError: l'identifiant «moi» a déjà été déclaré
«utiliser strictement»;
var me = 'foo';
var me = 'bar'; // Pas de problème, «moi» est remplacé.

Source: Quelle est la différence entre utiliser "let" et "var" pour déclarer une variable?


Réponse 3:

La principale différence entre les mots clés «let» et «var» en JavaScript est

portée

  • Le let vous permet de déclarer des variables dont la portée est limitée au bloc, à l'instruction ou à l'expression sur laquelle il est utilisé. Le mot-clé var, qui définit une variable globalement ou localement à une fonction entière quelle que soit la portée du bloc. "Var" est étendue au bloc fonctionnel le plus proche et «let» est étendue au bloc englobant le plus proche, qui peut être plus petit qu'un bloc fonctionnel. Les deux sont globales si en dehors de tout bloc. De plus, les variables déclarées avec «let» ne sont pas accessibles avant d'être déclarées dans leur bloc englobant. Comme vu dans la démo, cela lèvera une exception d'erreur de référence.

Considérez l'extrait de code suivant

Exemple 1: variable déclarée comme var

function nodeSimplified () {
  var a = 10;
  console.log (a); // sortie 10
  si vrai){
   var a = 20;
   console.log (a); // sortie 20
  }
  console.log (a); // sortie 20
}

Exemple 2: variable déclarée comme let

function nodeSimplified () {
  soit a = 10;
  console.log (a); // sortie 10
  si vrai){
   soit a = 20;
   console.log (a); // sortie 20
  }
  console.log (a); // sortie 10
}

Objet de fenêtre globale

Même si la variable let est définie globalement comme la variable var, la variable let ne sera pas ajoutée à l'objet de fenêtre globale.

Exemple les deux variables sont déclarées globalement ici

var varVariable = "c'est une variable var";

let letVariable = "c'est une variable let";

Voyons quelles sorties var et let variable vont générer

console.log (window.varVariable); // c'est une variable var

console.log (window.letVariable); //indéfini

Ainsi, les variables ne sont pas accessibles dans l'objet fenêtre car elles ne sont pas accessibles globalement.

A2A: - Abhinn Krishn (अभिन्न कृष्ण)

#ENJOY CODING


Réponse 4:

A2A

La différence entre let et var est de la portée. var est limité au bloc fonctionnel le plus proche et let est limité au bloc englobant le plus proche, qui peut être plus petit qu'un bloc fonctionnel. Les deux sont globaux si en dehors de tout bloc.

De plus, les variables déclarées avec let ne sont pas accessibles avant d'être déclarées dans leur bloc englobant. Comme vu dans la démo, cela lèvera une exception ReferenceError.

Global:

Ils sont très similaires lorsqu'ils sont utilisés comme ceci en dehors d'un bloc fonctionnel.

laissez-moi = 'aller'; // portée mondiale
var i = 'capable'; // portée mondiale

Cependant, les variables globales définies avec let ne seront pas ajoutées en tant que propriétés sur l'objet fenêtre global comme celles définies avec var.

console.log (window.me); // indéfini
console.log (window.i); // 'capable'

Une fonction:

Ils sont identiques lorsqu'ils sont utilisés comme ceci dans un bloc fonction.

function ingWithinEstablishedParameters () {
    laissez terOfRecommendation = 'super travailleur!'; // bloc fonctionnel délimité
    var sityCheerleading = 'allez!'; // bloc fonctionnel délimité
}

Bloquer:

Voici la différence. let n'est visible que dans la boucle for () et var est visible pour toute la fonction.

function allyIlliterate () {
    // tuce n'est * pas * visible ici

    for (let tuce = 0; tuce <5; tuce ++) {
        // tuce est uniquement visible ici (et dans les parenthèses for ())
        // et il y a une variable tuce distincte pour chaque itération de la boucle
    }

    // tuce n'est * pas * visible ici
}

fonction byE40 () {
    // nish * est * visible ici

    pour (var nish = 0; nish <5; nish ++) {
        // nish est visible par toute la fonction
    }

    // nish * est * visible ici
}

Redéclaration:

En supposant un mode strict, var vous permettra de re-déclarer la même variable dans la même portée. Par contre, ne voulons pas:

«utiliser strictement»;
laissez-moi = 'foo';
laissez-moi = 'bar'; // SyntaxError: l'identifiant «moi» a déjà été déclaré
«utiliser strictement»;
var me = 'foo';
var me = 'bar'; // Pas de problème, «moi» est remplacé.

Cette réponse n'a pas été écrite par moi. Cette réponse vient d'ici: Quelle est la différence entre utiliser "let" et "var" pour déclarer une variable en JavaScript?

Je n'aurais pas pu l'expliquer mieux que cela, donc je l'ai ajouté ici pour que les gens le voient.


Réponse 5:

A2A

La différence entre let et var est de la portée. var est limité au bloc fonctionnel le plus proche et let est limité au bloc englobant le plus proche, qui peut être plus petit qu'un bloc fonctionnel. Les deux sont globaux si en dehors de tout bloc.

De plus, les variables déclarées avec let ne sont pas accessibles avant d'être déclarées dans leur bloc englobant. Comme vu dans la démo, cela lèvera une exception ReferenceError.

Global:

Ils sont très similaires lorsqu'ils sont utilisés comme ceci en dehors d'un bloc fonctionnel.

laissez-moi = 'aller'; // portée mondiale
var i = 'capable'; // portée mondiale

Cependant, les variables globales définies avec let ne seront pas ajoutées en tant que propriétés sur l'objet fenêtre global comme celles définies avec var.

console.log (window.me); // indéfini
console.log (window.i); // 'capable'

Une fonction:

Ils sont identiques lorsqu'ils sont utilisés comme ceci dans un bloc fonction.

function ingWithinEstablishedParameters () {
    laissez terOfRecommendation = 'super travailleur!'; // bloc fonctionnel délimité
    var sityCheerleading = 'allez!'; // bloc fonctionnel délimité
}

Bloquer:

Voici la différence. let n'est visible que dans la boucle for () et var est visible pour toute la fonction.

function allyIlliterate () {
    // tuce n'est * pas * visible ici

    for (let tuce = 0; tuce <5; tuce ++) {
        // tuce est uniquement visible ici (et dans les parenthèses for ())
        // et il y a une variable tuce distincte pour chaque itération de la boucle
    }

    // tuce n'est * pas * visible ici
}

fonction byE40 () {
    // nish * est * visible ici

    pour (var nish = 0; nish <5; nish ++) {
        // nish est visible par toute la fonction
    }

    // nish * est * visible ici
}

Redéclaration:

En supposant un mode strict, var vous permettra de re-déclarer la même variable dans la même portée. Par contre, ne voulons pas:

«utiliser strictement»;
laissez-moi = 'foo';
laissez-moi = 'bar'; // SyntaxError: l'identifiant «moi» a déjà été déclaré
«utiliser strictement»;
var me = 'foo';
var me = 'bar'; // Pas de problème, «moi» est remplacé.

Cette réponse n'a pas été écrite par moi. Cette réponse vient d'ici: Quelle est la différence entre utiliser "let" et "var" pour déclarer une variable en JavaScript?

Je n'aurais pas pu l'expliquer mieux que cela, donc je l'ai ajouté ici pour que les gens le voient.


Réponse 6:

A2A

La différence entre let et var est de la portée. var est limité au bloc fonctionnel le plus proche et let est limité au bloc englobant le plus proche, qui peut être plus petit qu'un bloc fonctionnel. Les deux sont globaux si en dehors de tout bloc.

De plus, les variables déclarées avec let ne sont pas accessibles avant d'être déclarées dans leur bloc englobant. Comme vu dans la démo, cela lèvera une exception ReferenceError.

Global:

Ils sont très similaires lorsqu'ils sont utilisés comme ceci en dehors d'un bloc fonctionnel.

laissez-moi = 'aller'; // portée mondiale
var i = 'capable'; // portée mondiale

Cependant, les variables globales définies avec let ne seront pas ajoutées en tant que propriétés sur l'objet fenêtre global comme celles définies avec var.

console.log (window.me); // indéfini
console.log (window.i); // 'capable'

Une fonction:

Ils sont identiques lorsqu'ils sont utilisés comme ceci dans un bloc fonction.

function ingWithinEstablishedParameters () {
    laissez terOfRecommendation = 'super travailleur!'; // bloc fonctionnel délimité
    var sityCheerleading = 'allez!'; // bloc fonctionnel délimité
}

Bloquer:

Voici la différence. let n'est visible que dans la boucle for () et var est visible pour toute la fonction.

function allyIlliterate () {
    // tuce n'est * pas * visible ici

    for (let tuce = 0; tuce <5; tuce ++) {
        // tuce est uniquement visible ici (et dans les parenthèses for ())
        // et il y a une variable tuce distincte pour chaque itération de la boucle
    }

    // tuce n'est * pas * visible ici
}

fonction byE40 () {
    // nish * est * visible ici

    pour (var nish = 0; nish <5; nish ++) {
        // nish est visible par toute la fonction
    }

    // nish * est * visible ici
}

Redéclaration:

En supposant un mode strict, var vous permettra de re-déclarer la même variable dans la même portée. Par contre, ne voulons pas:

«utiliser strictement»;
laissez-moi = 'foo';
laissez-moi = 'bar'; // SyntaxError: l'identifiant «moi» a déjà été déclaré
«utiliser strictement»;
var me = 'foo';
var me = 'bar'; // Pas de problème, «moi» est remplacé.

Cette réponse n'a pas été écrite par moi. Cette réponse vient d'ici: Quelle est la différence entre utiliser "let" et "var" pour déclarer une variable en JavaScript?

Je n'aurais pas pu l'expliquer mieux que cela, donc je l'ai ajouté ici pour que les gens le voient.


Réponse 7:

A2A

La différence entre let et var est de la portée. var est limité au bloc fonctionnel le plus proche et let est limité au bloc englobant le plus proche, qui peut être plus petit qu'un bloc fonctionnel. Les deux sont globaux si en dehors de tout bloc.

De plus, les variables déclarées avec let ne sont pas accessibles avant d'être déclarées dans leur bloc englobant. Comme vu dans la démo, cela lèvera une exception ReferenceError.

Global:

Ils sont très similaires lorsqu'ils sont utilisés comme ceci en dehors d'un bloc fonctionnel.

laissez-moi = 'aller'; // portée mondiale
var i = 'capable'; // portée mondiale

Cependant, les variables globales définies avec let ne seront pas ajoutées en tant que propriétés sur l'objet fenêtre global comme celles définies avec var.

console.log (window.me); // indéfini
console.log (window.i); // 'capable'

Une fonction:

Ils sont identiques lorsqu'ils sont utilisés comme ceci dans un bloc fonction.

function ingWithinEstablishedParameters () {
    laissez terOfRecommendation = 'super travailleur!'; // bloc fonctionnel délimité
    var sityCheerleading = 'allez!'; // bloc fonctionnel délimité
}

Bloquer:

Voici la différence. let n'est visible que dans la boucle for () et var est visible pour toute la fonction.

function allyIlliterate () {
    // tuce n'est * pas * visible ici

    for (let tuce = 0; tuce <5; tuce ++) {
        // tuce est uniquement visible ici (et dans les parenthèses for ())
        // et il y a une variable tuce distincte pour chaque itération de la boucle
    }

    // tuce n'est * pas * visible ici
}

fonction byE40 () {
    // nish * est * visible ici

    pour (var nish = 0; nish <5; nish ++) {
        // nish est visible par toute la fonction
    }

    // nish * est * visible ici
}

Redéclaration:

En supposant un mode strict, var vous permettra de re-déclarer la même variable dans la même portée. Par contre, ne voulons pas:

«utiliser strictement»;
laissez-moi = 'foo';
laissez-moi = 'bar'; // SyntaxError: l'identifiant «moi» a déjà été déclaré
«utiliser strictement»;
var me = 'foo';
var me = 'bar'; // Pas de problème, «moi» est remplacé.

Cette réponse n'a pas été écrite par moi. Cette réponse vient d'ici: Quelle est la différence entre utiliser "let" et "var" pour déclarer une variable en JavaScript?

Je n'aurais pas pu l'expliquer mieux que cela, donc je l'ai ajouté ici pour que les gens le voient.


Réponse 8:

A2A

La différence entre let et var est de la portée. var est limité au bloc fonctionnel le plus proche et let est limité au bloc englobant le plus proche, qui peut être plus petit qu'un bloc fonctionnel. Les deux sont globaux si en dehors de tout bloc.

De plus, les variables déclarées avec let ne sont pas accessibles avant d'être déclarées dans leur bloc englobant. Comme vu dans la démo, cela lèvera une exception ReferenceError.

Global:

Ils sont très similaires lorsqu'ils sont utilisés comme ceci en dehors d'un bloc fonctionnel.

laissez-moi = 'aller'; // portée mondiale
var i = 'capable'; // portée mondiale

Cependant, les variables globales définies avec let ne seront pas ajoutées en tant que propriétés sur l'objet fenêtre global comme celles définies avec var.

console.log (window.me); // indéfini
console.log (window.i); // 'capable'

Une fonction:

Ils sont identiques lorsqu'ils sont utilisés comme ceci dans un bloc fonction.

function ingWithinEstablishedParameters () {
    laissez terOfRecommendation = 'super travailleur!'; // bloc fonctionnel délimité
    var sityCheerleading = 'allez!'; // bloc fonctionnel délimité
}

Bloquer:

Voici la différence. let n'est visible que dans la boucle for () et var est visible pour toute la fonction.

function allyIlliterate () {
    // tuce n'est * pas * visible ici

    for (let tuce = 0; tuce <5; tuce ++) {
        // tuce est uniquement visible ici (et dans les parenthèses for ())
        // et il y a une variable tuce distincte pour chaque itération de la boucle
    }

    // tuce n'est * pas * visible ici
}

fonction byE40 () {
    // nish * est * visible ici

    pour (var nish = 0; nish <5; nish ++) {
        // nish est visible par toute la fonction
    }

    // nish * est * visible ici
}

Redéclaration:

En supposant un mode strict, var vous permettra de re-déclarer la même variable dans la même portée. Par contre, ne voulons pas:

«utiliser strictement»;
laissez-moi = 'foo';
laissez-moi = 'bar'; // SyntaxError: l'identifiant «moi» a déjà été déclaré
«utiliser strictement»;
var me = 'foo';
var me = 'bar'; // Pas de problème, «moi» est remplacé.

Cette réponse n'a pas été écrite par moi. Cette réponse vient d'ici: Quelle est la différence entre utiliser "let" et "var" pour déclarer une variable en JavaScript?

Je n'aurais pas pu l'expliquer mieux que cela, donc je l'ai ajouté ici pour que les gens le voient.


Réponse 9:

A2A

La différence entre let et var est de la portée. var est limité au bloc fonctionnel le plus proche et let est limité au bloc englobant le plus proche, qui peut être plus petit qu'un bloc fonctionnel. Les deux sont globaux si en dehors de tout bloc.

De plus, les variables déclarées avec let ne sont pas accessibles avant d'être déclarées dans leur bloc englobant. Comme vu dans la démo, cela lèvera une exception ReferenceError.

Global:

Ils sont très similaires lorsqu'ils sont utilisés comme ceci en dehors d'un bloc fonctionnel.

laissez-moi = 'aller'; // portée mondiale
var i = 'capable'; // portée mondiale

Cependant, les variables globales définies avec let ne seront pas ajoutées en tant que propriétés sur l'objet fenêtre global comme celles définies avec var.

console.log (window.me); // indéfini
console.log (window.i); // 'capable'

Une fonction:

Ils sont identiques lorsqu'ils sont utilisés comme ceci dans un bloc fonction.

function ingWithinEstablishedParameters () {
    laissez terOfRecommendation = 'super travailleur!'; // bloc fonctionnel délimité
    var sityCheerleading = 'allez!'; // bloc fonctionnel délimité
}

Bloquer:

Voici la différence. let n'est visible que dans la boucle for () et var est visible pour toute la fonction.

function allyIlliterate () {
    // tuce n'est * pas * visible ici

    for (let tuce = 0; tuce <5; tuce ++) {
        // tuce est uniquement visible ici (et dans les parenthèses for ())
        // et il y a une variable tuce distincte pour chaque itération de la boucle
    }

    // tuce n'est * pas * visible ici
}

fonction byE40 () {
    // nish * est * visible ici

    pour (var nish = 0; nish <5; nish ++) {
        // nish est visible par toute la fonction
    }

    // nish * est * visible ici
}

Redéclaration:

En supposant un mode strict, var vous permettra de re-déclarer la même variable dans la même portée. Par contre, ne voulons pas:

«utiliser strictement»;
laissez-moi = 'foo';
laissez-moi = 'bar'; // SyntaxError: l'identifiant «moi» a déjà été déclaré
«utiliser strictement»;
var me = 'foo';
var me = 'bar'; // Pas de problème, «moi» est remplacé.

Cette réponse n'a pas été écrite par moi. Cette réponse vient d'ici: Quelle est la différence entre utiliser "let" et "var" pour déclarer une variable en JavaScript?

Je n'aurais pas pu l'expliquer mieux que cela, donc je l'ai ajouté ici pour que les gens le voient.


Réponse 10:

A2A

La différence entre let et var est de la portée. var est limité au bloc fonctionnel le plus proche et let est limité au bloc englobant le plus proche, qui peut être plus petit qu'un bloc fonctionnel. Les deux sont globaux si en dehors de tout bloc.

De plus, les variables déclarées avec let ne sont pas accessibles avant d'être déclarées dans leur bloc englobant. Comme vu dans la démo, cela lèvera une exception ReferenceError.

Global:

Ils sont très similaires lorsqu'ils sont utilisés comme ceci en dehors d'un bloc fonctionnel.

laissez-moi = 'aller'; // portée mondiale
var i = 'capable'; // portée mondiale

Cependant, les variables globales définies avec let ne seront pas ajoutées en tant que propriétés sur l'objet fenêtre global comme celles définies avec var.

console.log (window.me); // indéfini
console.log (window.i); // 'capable'

Une fonction:

Ils sont identiques lorsqu'ils sont utilisés comme ceci dans un bloc fonction.

function ingWithinEstablishedParameters () {
    laissez terOfRecommendation = 'super travailleur!'; // bloc fonctionnel délimité
    var sityCheerleading = 'allez!'; // bloc fonctionnel délimité
}

Bloquer:

Voici la différence. let n'est visible que dans la boucle for () et var est visible pour toute la fonction.

function allyIlliterate () {
    // tuce n'est * pas * visible ici

    for (let tuce = 0; tuce <5; tuce ++) {
        // tuce est uniquement visible ici (et dans les parenthèses for ())
        // et il y a une variable tuce distincte pour chaque itération de la boucle
    }

    // tuce n'est * pas * visible ici
}

fonction byE40 () {
    // nish * est * visible ici

    pour (var nish = 0; nish <5; nish ++) {
        // nish est visible par toute la fonction
    }

    // nish * est * visible ici
}

Redéclaration:

En supposant un mode strict, var vous permettra de re-déclarer la même variable dans la même portée. Par contre, ne voulons pas:

«utiliser strictement»;
laissez-moi = 'foo';
laissez-moi = 'bar'; // SyntaxError: l'identifiant «moi» a déjà été déclaré
«utiliser strictement»;
var me = 'foo';
var me = 'bar'; // Pas de problème, «moi» est remplacé.

Cette réponse n'a pas été écrite par moi. Cette réponse vient d'ici: Quelle est la différence entre utiliser "let" et "var" pour déclarer une variable en JavaScript?

Je n'aurais pas pu l'expliquer mieux que cela, donc je l'ai ajouté ici pour que les gens le voient.


Réponse 11:

A2A

La différence entre let et var est de la portée. var est limité au bloc fonctionnel le plus proche et let est limité au bloc englobant le plus proche, qui peut être plus petit qu'un bloc fonctionnel. Les deux sont globaux si en dehors de tout bloc.

De plus, les variables déclarées avec let ne sont pas accessibles avant d'être déclarées dans leur bloc englobant. Comme vu dans la démo, cela lèvera une exception ReferenceError.

Global:

Ils sont très similaires lorsqu'ils sont utilisés comme ceci en dehors d'un bloc fonctionnel.

laissez-moi = 'aller'; // portée mondiale
var i = 'capable'; // portée mondiale

Cependant, les variables globales définies avec let ne seront pas ajoutées en tant que propriétés sur l'objet fenêtre global comme celles définies avec var.

console.log (window.me); // indéfini
console.log (window.i); // 'capable'

Une fonction:

Ils sont identiques lorsqu'ils sont utilisés comme ceci dans un bloc fonction.

function ingWithinEstablishedParameters () {
    laissez terOfRecommendation = 'super travailleur!'; // bloc fonctionnel délimité
    var sityCheerleading = 'allez!'; // bloc fonctionnel délimité
}

Bloquer:

Voici la différence. let n'est visible que dans la boucle for () et var est visible pour toute la fonction.

function allyIlliterate () {
    // tuce n'est * pas * visible ici

    for (let tuce = 0; tuce <5; tuce ++) {
        // tuce est uniquement visible ici (et dans les parenthèses for ())
        // et il y a une variable tuce distincte pour chaque itération de la boucle
    }

    // tuce n'est * pas * visible ici
}

fonction byE40 () {
    // nish * est * visible ici

    pour (var nish = 0; nish <5; nish ++) {
        // nish est visible par toute la fonction
    }

    // nish * est * visible ici
}

Redéclaration:

En supposant un mode strict, var vous permettra de re-déclarer la même variable dans la même portée. Par contre, ne voulons pas:

«utiliser strictement»;
laissez-moi = 'foo';
laissez-moi = 'bar'; // SyntaxError: l'identifiant «moi» a déjà été déclaré
«utiliser strictement»;
var me = 'foo';
var me = 'bar'; // Pas de problème, «moi» est remplacé.

Cette réponse n'a pas été écrite par moi. Cette réponse vient d'ici: Quelle est la différence entre utiliser "let" et "var" pour déclarer une variable en JavaScript?

Je n'aurais pas pu l'expliquer mieux que cela, donc je l'ai ajouté ici pour que les gens le voient.


Réponse 12:

A2A

La différence entre let et var est de la portée. var est limité au bloc fonctionnel le plus proche et let est limité au bloc englobant le plus proche, qui peut être plus petit qu'un bloc fonctionnel. Les deux sont globaux si en dehors de tout bloc.

De plus, les variables déclarées avec let ne sont pas accessibles avant d'être déclarées dans leur bloc englobant. Comme vu dans la démo, cela lèvera une exception ReferenceError.

Global:

Ils sont très similaires lorsqu'ils sont utilisés comme ceci en dehors d'un bloc fonctionnel.

laissez-moi = 'aller'; // portée mondiale
var i = 'capable'; // portée mondiale

Cependant, les variables globales définies avec let ne seront pas ajoutées en tant que propriétés sur l'objet fenêtre global comme celles définies avec var.

console.log (window.me); // indéfini
console.log (window.i); // 'capable'

Une fonction:

Ils sont identiques lorsqu'ils sont utilisés comme ceci dans un bloc fonction.

function ingWithinEstablishedParameters () {
    laissez terOfRecommendation = 'super travailleur!'; // bloc fonctionnel délimité
    var sityCheerleading = 'allez!'; // bloc fonctionnel délimité
}

Bloquer:

Voici la différence. let n'est visible que dans la boucle for () et var est visible pour toute la fonction.

function allyIlliterate () {
    // tuce n'est * pas * visible ici

    for (let tuce = 0; tuce <5; tuce ++) {
        // tuce est uniquement visible ici (et dans les parenthèses for ())
        // et il y a une variable tuce distincte pour chaque itération de la boucle
    }

    // tuce n'est * pas * visible ici
}

fonction byE40 () {
    // nish * est * visible ici

    pour (var nish = 0; nish <5; nish ++) {
        // nish est visible par toute la fonction
    }

    // nish * est * visible ici
}

Redéclaration:

En supposant un mode strict, var vous permettra de re-déclarer la même variable dans la même portée. Par contre, ne voulons pas:

«utiliser strictement»;
laissez-moi = 'foo';
laissez-moi = 'bar'; // SyntaxError: l'identifiant «moi» a déjà été déclaré
«utiliser strictement»;
var me = 'foo';
var me = 'bar'; // Pas de problème, «moi» est remplacé.

Cette réponse n'a pas été écrite par moi. Cette réponse vient d'ici: Quelle est la différence entre utiliser "let" et "var" pour déclarer une variable en JavaScript?

Je n'aurais pas pu l'expliquer mieux que cela, donc je l'ai ajouté ici pour que les gens le voient.