Javascript - "let" mot-clé vs mot clé "var"

Question

En javascript 1,7 let mot-clé a été ajoutée. J'ai entendu dire qu'il décrit comme un "local" de la variable, mais je ne suis pas encore tout à fait sûr de savoir comment il se comporte différemment de la var mot-clé.

Quelles sont les différences entre les deux? Quand doit - let être utilisées au cours d' var?

Answer 1

La différence est portée. var est portée la plus proche de bloc de fonction (ou global si à l'extérieur d'un bloc de fonction), et let est portée la plus proche enfermant bloc (ou global si à l'extérieur d'un bloc), qui peut être plus petite qu'un bloc de fonction.

Aussi, à l'instar var, les variables déclarées avec let sont visibles avant qu'ils ne soient déclarés dans leur bloc enfermant, comme montré dans la démo.

Démo: (Firefox Uniquement)

Mondial:

Ils sont identiques lorsqu'il est utilisé comme cela, en dehors d'un bloc de fonction.

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

Fonction:

Ils sont identiques lorsqu'il est utilisé comme cela, dans un bloc de fonction.

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

Bloc:

Là est la différence. let n'est visible que dans l' for() boucle et var est visible à l'ensemble de la fonction.

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

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

En outre:

let peut également être utilisé pour créer son propre bloc enfermant.

function conjunctionJunctionWhatsYour() {
    //sNotGetCrazy is *not* visible out here

    let( sNotGetCrazy = 'now' ) {
        //sNotGetCrazy is only visible in here
    };

    //sNotGetCrazy is *not* visible out here
};

Answer 2

Voici une explication de l' let mot-clé avec quelques exemples.

laissez fonctionne très bien comme var. La principale différence est que la portée d'une variable var est l'ensemble de la fonction englobante

Ce tableau sur Wikipedia montre que les navigateurs en charge Javascript 1.7.

Notez que seuls les navigateurs Mozilla support. IE, Safari, Chrome, etc ne sont pas.

Answer 3

Il ya quelques différences subtiles -- Laissez la portée se comporte davantage comme variable de portée de n'en plus ou moins n'importe quelle autre langue-par exemple. il étendues à l'affichage de bloc, ils n'existent pas avant qu'ils ne soient déclarés, etc

Toutefois, il est intéressant de noter que laisser Mozilla extension, ne fait partie d'aucun standard (EcmaScript est la norme, le JavaScript est le mozilla mise en œuvre, l'histoire est un peu alambiquée, mais c'est comment ça se passe), et donc, let est disponible uniquement dans firefox et d'autres navigateurs basés sur mozilla.

Answer 4

Voici un exemple intéressant à ajouter sur ce que les autres ont déjà écrit. Supposons que vous voulez construire un tableau de fonctions, adderFunctions, où chaque fonction prend un seul argument Nombre et renvoie la somme de l'argument et de la fonction de l'index dans le tableau. En essayant de générer adderFunctions avec une boucle à l'aide de l' var mot-clé provoque des problèmes:

var size = 1000;
var adderFunctions = new Array(size);
var result;

for (var i = 0; i < size; i++) {
  var value = i;
  adderFunctions[i] = function(x) {
    return x + value;
  };
}

result = adderFunctions[12](8);

console.log(result === 20); // => false
console.log(result === 107); // => true
console.log(value); // => 999

Le processus ci-dessus n'est pas de générer le tableau désiré fonctions, car values'champ d'application s'étend au-delà de l' for bloc. Maintenant, essayez de le même à l'aide de l'Harmonie (ECMAScript 6) spec et l' let mot-clé:

const size = 1000;
let adderFunctions = new Array(size);
let result;

for (let i = 0; i < size; i++) {
  let value = i;
  adderFunctions[i] = (x) => x + value;
}

result = adderFunctions[12](8);

console.log(result === 20); // => true
console.log(value); // => ReferenceError: value is not defined

Cette fois, values'champ d'application est limité à l' for bloc et adderFunctions contient la fonction souhaitée à chaque index.

Answer 5

Droit maintenant, vous devriez presque jamais utiliser let, parce que vous ne pouvez pas compter sur elle étant entièrement pris en charge encore à l'état sauvage.

Je sais que c'est pas le genre de réponse que vous recherchez, mais c'est probablement la considération la plus importante. Si vous disposez d'un déploiement où vous savez que tout le monde obtient 1,7, alors vous êtes un veinard.