The let statement declares a block scope local variable, optionally initializing it to a value.


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


var1, var2, …, varN
Variable name. It can be any legal identifier.
value1, value2, …, valueN
Initial value of the variable. It can be any legal expression.


let allows you to declare variables that are limited in scope to the block, statement, or expression on which it is used. This is unlike the var keyword, which defines a variable globally, or locally to an entire function regardless of block scope.

Scoping rules

Variables declared by let have as their scope the block in which they are defined, as well as in any contained sub-blocks . In this way, let works very much like var. The main difference is that the scope of a var variable is the entire enclosing function:

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

Cleaner code in inner functions

let sometimes makes the code cleaner when inner functions are used.

var list = document.getElementById("list");

for (let i = 1; i <= 5; i++) {
  let item = document.createElement("li");
  item.appendChild(document.createTextNode("Item " + i));

  item.onclick = function (ev) {
    console.log("Item " + i + " is clicked.");

The example above works as intended because the five instances of the (anonymous) inner function refer to five different instances of the variable i. Note that it does not work as intended if you replace let with var, since all of the inner functions would then return the same final value of i: 6. Also, we can keep the scope around the loop cleaner by moving the code that creates the new elements into the scope of each loop.

At the top level of programs and functions, let, unlike var, does not create a property on the global object. For example:

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

Emulating private interfaces

In dealing with constructors it is possible to use the let statement in order to create a private interface without using closures:

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


console.log(privateScope.hiddenProperty); // error

Temporal dead zone and errors with let

Redeclaring the same variable within the same function or block scope raises a SyntaxError.

if (x) {
  let foo;
  let foo; // SyntaxError thrown.

In ECMAScript 2015, let will hoist the variable to the top of the block. However, referencing the variable in the block before the variable declaration results in a ReferenceError. The variable is in a "temporal dead zone" from the start of the block until the declaration is processed.

function do_something() {
  console.log(foo); // ReferenceError
  let foo = 2;

You may encounter errors in switch statements because there is only one underlying block.

switch (x) {
  case 0:
    let foo;
  case 1:
    let foo; // SyntaxError for redeclaration.

Using let with a variable name that is the same as a parameter passed to a function will result in undefined inside a for loop.

function go(n){
  for (let n of n.a) {


Another example

When used inside a block, let limits the variable's scope to that block. Note the difference between var whose scope is inside the function where it is declared.

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

Non-standard let extensions

let blocks

let blocks support has been dropped in Gecko 44 (bug 1167029).

The let block provides a way to associate values with variables within the scope of a block, without affecting the values of like-named variables outside the block.


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


The let block provides local scoping for variables. It works by binding zero or more variables in the lexical scope of a single block of code; otherwise, it is exactly the same as a block statement. Note in particular that the scope of a variable declared inside a let block using var is still the same as if it had been declared outside the let block; such variables still have function scoping. When using the let block syntax, the parentheses following let are required. Failure to include them will result in a syntax error.


var x = 5;
var y = 0;

let (x = x+10, y = 12) {
  console.log(x+y); // 27

console.log(x + y); // 5

The rules for the code block are the same as for any other code block in JavaScript. It may have its own local variables established using the let declarations.

Scoping rules

The scope of variables defined using let is the let block itself, as well as any inner blocks contained inside it, unless those blocks define variables by the same names.

let expressions

let expression support has been dropped in Gecko 41 (bug 1023609).

The let expression lets you establish variables scoped only to a single expression.


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


You can use let to establish variables that are scoped only to a single expression:

var a = 5;
let(a = 6) console.log(a); // 6
console.log(a); // 5

Scoping rules

Given a let expression:

let (<var>decls</var>) <var>expr</var>

There is an implicit block created around expr.


A explanation of why the name "let" was chosen can be found here.


Specification Status Comment
ECMAScript 2015 (6th Edition, ECMA-262)
The definition of 'Let and Const Declarations' in that specification.
Standard Initial definition. Does not specify let expressions or let blocks.
ECMAScript 2017 Draft (ECMA-262)
The definition of 'Let and Const Declarations' in that specification.

Browser compatibility

Feature Chrome Edge Firefox (Gecko) Internet Explorer Opera Safari
Basic support 41.0 12 44 (44) 11 17 ?
Temporal dead zone ? 12 35 (35) 11 ? ?
let expression No support No support No support No support No support No support
let block No support No support No support No support No support No support
Allowed in sloppy mode 49.0 ? 44 (44) ? ? ?
Feature Android Android Webview Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile Chrome for Android
Basic support ? 41.0 44.0 (44) ? ? ? 41.0
Temporal dead zone ? ? 35.0 (35) ? ? ? ?
let expression No support ? No support No support No support No support No support
let block No support ? No support No support No support No support No support
Allowed in sloppy mode No support 49.0 44 (44) ? ? ? 49.0

Firefox-specific notes

  • Prior to SpiderMonkey 46 (Firefox 46 / Thunderbird 46 / SeaMonkey 2.43), a TypeError was thrown on redeclaration instead of a SyntaxError (bug 1198833, bug 1275240).
  • Prior to SpiderMonkey 44 (Firefox 44 / Thunderbird 44 / SeaMonkey 2.41), let was only available to code blocks in HTML wrapped in a <script type="application/javascript;version=1.7"> block (or higher version) and had different semantics.
  • Support in Worker code is hidden behind the dom.workers.latestJSVersion flag (bug 487070). With version free let, this flag is going to be removed in the future (bug 1219523).
  • ES6 compliance for let in SpIderMonkey is tracked in bug 950547

See also


© 2016 Mozilla Contributors
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.

ECMAScript 2015 ECMAScript6 JavaScript let Statement Variable declaration Variables