Fácil de entender os comandos Let e Const

As variáveis declaradas por let e const são válidas apenas dentro do bloco de código.

 {let a = 10; var b = 1;} a // referenceError: a não é definido.b // 1

Nenhuma promoção variável

As variáveis devem ser usadas após a declaração, caso contrário, será relatado um erro.

 var tmp = 123; if (true) {tmp = 'abc'; // ReferenceErrorlet tmp;}

Declarações repetidas não são permitidas

 // função de erro () {let a = 10; var a = 1;}

Escopo no nível do bloco

 função f () {console.log ('estou fora!'); } (function () {if (false) {// Repita a função da função f () {console.log ('eu estou dentro!');}} f ();} ()); // estou dentro! ES5 Função Promoção // Estou lá fora! ES6 Escopo no nível do bloco

comando const

Declare uma constante somente leitura. Uma vez declarado, o valor da constante não pode ser alterado.

Depois que uma variável é declarada, ela deve ser inicializada imediatamente e não pode ser deixada para ser atribuída posteriormente.

Variáveis globais declaradas por LET Command, Const Command e Class Command, não pertencem às propriedades do objeto global.

 var a = 1; // Se no ambiente Repl do nó, ele pode ser escrito como global.a // ou usando um método geral, pode ser escrito como este.awindow.a // 1Let b = 1; Window.b // indefinido

Em seguida, apresentarei o comando const do ES6 para você separadamente

JS, que sempre foi centrado na ECMA, nunca teve o conceito de constantes, e o ES6 compensou essa falha;

 const foo = 'foo'; foo = 'bar'; // typeError: atribuição à variável constante.

O exemplo acima declara uma constante do tipo básico. Se você tentar modificar o valor inicial, será relatado um erro; Se for um valor do tipo de referência, também se aplica, mas uma coisa precisa receber atenção, dê um exemplo:

 const foo = []; foo = [1]; // atribuição a variável constante.

Um erro normal, sem problemas, olhe novamente:

 const foo = [1,2,3]; foo [1] = 4; console.log (foo) // [1, 4, 3]

Por que não há erro nisso? E pode ser modificado com sucesso? A diferença entre esses dois exemplos é que o primeiro mudou o conteúdo correspondente do ponteiro (precisa estar familiarizado com o tipo de referência JS) e o último ainda não mudou o apontamento, mas o conteúdo do objeto apontador mudou. Para Foo, sou apenas um ponteiro responsável por apontar para o objeto correspondente. Quanto ao conteúdo do objeto, não me importo com meus negócios, para que eu possa modificá -lo; Se não quero que o conteúdo mude, posso usar outro método;

 const foo = object.freeze ([1,2,3]); foo [1] = 4; console.log (foo) // [1, 2, 3]

Dessa forma, você não precisa se preocupar em ser modificado;