let
===

Declara uma variável local no escopo do bloco atual, opcionalmente iniciando-a com um valor.

Sintaxe
-------

Definição `let`:
```

let var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]];
```


Expressão `let`:
```

let (var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]]) expression;
```


Instrução `let`:
```

let (var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]]) statement;
```

### Parâmetros

| Parameter | Description |
| --- | --- |
| `var1`, `var2`, …, `varN` | Nome da variável. Pode ser qualquer identificador válido. |
| `value1`, `value2`, …, `valueN` | Valor inicial da variável. Pode ser qualquer expressão válida. |
| `expression` | Qualquer expressão válida. |
| `statement` | Qualquer instrução válida. |

Descrição
---------

`let` permite que você declare variáveis limitando seu escopo no bloco, instrução, ou em uma expressão na qual ela é usada. Isso é inverso da keyword `var` (en-US), que define uma variável globalmente ou no escopo inteiro de uma função, independentemente do escopo de bloco.

**Nota:** **Nota do tradutor:** o trecho acima: "independentemente do escopo de bloco", na verdade, significa dizer que variáveis declaradas dentro de blocos internos da função, por exemplo, são vinculadas no escopo da função, não no bloco no qual elas são declaradas. Se isso parece confuso - e realmente é -, apenas entenda que, ao contrário do que se poderia supor, em Javascript blocos não possuem escopo como em outras linguagens, somente funções têm! Isso quer dizer que mesmo uma váriavel definida com a keyword `var` dentro de um bloco de instrução `if`, será visível no resto inteiro da função.

Escopo de bloco
---------------

Variáveis declaradas com `let` são "içadas" para começo do bloco em que elas são definidas (isso é conhecido também pelo termo, hoisting).

Redeclaração de uma mesma variável num mesmo escopo de bloco causa um `TypeError` (en-US).


```js
if (x) {
  let foo;
  let foo; // Emite um TypeError.
}
```


No entanto, corpos de funções não possuem essa limitação!


```js
function do\_something() {
  let foo;
  let foo; // Isso funciona.
}
```


**Aviso:** **Atenção:** Os rascunhos do ECMAScript 6 (desde abril de 2012) tornam este comportamento ilegal. Isso significa, provavelmente, que as futuras versões do JavaScript levantarão um `TypeError` (en-US). Então, se você faz isso, deveria evitar essa prática!

Você pode encontrar erros em instruções `switch` (en-US) porque existe apenas um bloco subjacente.


```js
switch (x) {
  case 0:
    let foo;
    break;

  case 1:
    let foo; // TypeError para a redeclaração.
    break;
}
```

Exemplos
--------

Uma *expressão let* limita o escopo de uma variável declarada somente para aquela expressão.


```js
var a = 5;
let(a = 6) alert(a); // 6
alert(a); // 5
```


Usada dentro de um bloco, *let* limita os escopo das variáveis para aquele bloco. Observe a diferença entre *var* em que o escopo é definido dentro da função onde é declarada


```js
var a = 5;
var b = 10;

if (a === 5) {
  let a = 4; // O escopo é dentro do bloco if
  var b = 1; // O escopo é dentro da função

  console.log(a); // 4
  console.log(b); // 1
}

console.log(a); // 5
console.log(b); // 1
```


É possível usar a keyword *let* para vincular variáveis localmente no escopo de loops em vez de usar uma variável global (definida usando *var*) para isso.


```js
for (let i = 0; i < 10; i++) {
  alert(i); // 1, 2, 3, 4 ... 9
}

alert(i); // i não está definida
```

Veja também
-----------

* `var` (en-US)
* `const` (en-US)
* Novidades do JavaScript 1.7