Что делает let в javascript

Переменные: let и const

Материал на этой странице устарел, поэтому скрыт из оглавления сайта.

В ES-2015 предусмотрены новые способы объявления переменных: через let и const вместо var .

let a = 5;

let

У объявлений переменной через let есть три основных отличия от var :

Область видимости переменной let – блок <. >.

var apples = 5; if (true) < var apples = 10; alert(apples); // 10 (внутри блока) >alert(apples); // 10 (снаружи блока то же самое)

В примере выше apples – одна переменная на весь код, которая модифицируется в if . То же самое с let будет работать по-другому:

let apples = 5; // (*) if (true) < let apples = 10; alert(apples); // 10 (внутри блока) >alert(apples); // 5 (снаружи блока значение не изменилось)

Здесь, фактически, две независимые переменные apples , одна – глобальная, вторая – в блоке if . Заметим, что если объявление let apples в первой строке (*) удалить, то в последнем alert будет ошибка: переменная не определена:

if (true) < let apples = 10; alert(apples); // 10 (внутри блока) >alert(apples); // ошибка!

alert(a); // undefined var a = 5;

С переменными let всё проще. До объявления их вообще нет. Такой доступ приведёт к ошибке:

alert(a); // ошибка, нет такой переменной let a = 5;

Заметим также, что переменные let нельзя повторно объявлять. То есть, такой код выведет ошибку:

let x; let x; // ошибка: переменная x уже объявлена

Это – хоть и выглядит ограничением по сравнению с var , но на самом деле проблем не создаёт. Например, два таких цикла совсем не конфликтуют:

// каждый цикл имеет свою переменную i for(let i = 0; i for(let i = 0; i alert( i ); // ошибка: глобальной i нет

for(var i=0; i alert(i); // 10

С переменной let – всё по-другому. Каждому повторению цикла соответствует своя независимая переменная let . Если внутри цикла есть вложенные объявления функций, то в замыкании каждой будет та переменная, которая была при соответствующей итерации. Это позволяет легко решить классическую проблему с замыканиями, описанную в задаче Армия функций.

function makeArmy() < let shooters = []; for (let i = 0; i < 10; i++) < shooters.push(function() < alert( i ); // выводит свой номер >); > return shooters; > var army = makeArmy(); army[0](); // 0 army[5](); // 5

const

Объявление const задаёт константу, то есть переменную, которую нельзя менять:

const apple = 5; apple = 10; // ошибка

В остальном объявление const полностью аналогично let .

Заметим, что если в константу присвоен объект, то от изменения защищена сама константа, но не свойства внутри неё:

const user = < name: "Вася" >; user.name = "Петя"; // допустимо user = 5; // нельзя, будет ошибка

То же самое верно, если константе присвоен массив или другое объектное значение.

константы и КОНСТАНТЫ

Константы, которые жёстко заданы всегда, во время всей программы, обычно пишутся в верхнем регистре. Например: const ORANGE = «#ffa500» .

Большинство переменных – константы в другом смысле: они не меняются после присвоения. Но при разных запусках функции это значение может быть разным. Для таких переменных можно использовать const и обычные строчные буквы в имени.

Итого

Видны только после объявления и только в текущем блоке.
Нельзя переобъявлять (в том же блоке).
При объявлении переменной в цикле for(let …) – она видна только в этом цикле. Причём каждой итерации соответствует своя переменная let .

Переменная const – это константа, в остальном – как let .

Что делает let в javascript

The let declaration declares re-assignable, block-scoped local variables, optionally initializing each to a value.

Try it

Syntax

let name1; let name1 = value1; let name1 = value1, name2 = value2; let name1, name2 = value2; let name1 = value1, name2, /* …, */ nameN = valueN;

Parameters

The name of the variable to declare. Each must be a legal JavaScript identifier or a destructuring binding pattern.

Initial value of the variable. It can be any legal expression. Default value is undefined .

Description

The scope of a variable declared with let is one of the following curly-brace-enclosed syntaxes that most closely contains the let declaration:

Block statement
switch statement
try. catch statement
Body of one of the for statements, if the let is in the header of the statement
Function body
Static initialization block

Or the current module or script, if it’s contained in none of these.

Compared with var , let declarations have the following differences:

let declarations are scoped to blocks as well as functions.
let declarations can only be accessed after the place of declaration is reached (see temporal dead zone). For this reason, let declarations are commonly regarded as non-hoisted.
let declarations do not create properties on globalThis when declared at the top level of a script.
let declarations cannot be redeclared by any other declaration in the same scope.
let begins declarations, not statements. That means you cannot use a lone let declaration as the body of a block (which makes sense, since there’s no way to access the variable).

if (true) let a = 1; // SyntaxError: Lexical declaration cannot appear in a single-statement context

Note that let is allowed as an identifier name when declared with var or function in non-strict mode, but you should avoid using let as an identifier name to prevent unexpected syntax ambiguities.

Many style guides (including MDN’s) recommend using const over let whenever a variable is not reassigned in its scope. This makes the intent clear that a variable’s type (or value, in the case of a primitive) can never change. Others may prefer let for non-primitives that are mutated.

The list that follows the let keyword is called a binding list and is separated by commas, where the commas are not comma operators and the = signs are not assignment operators. Initializers of later variables can refer to earlier variables in the list.

Temporal dead zone (TDZ)

A variable declared with let , const , or class is said to be in a «temporal dead zone» (TDZ) from the start of the block until code execution reaches the place where the variable is declared and initialized.

While inside the TDZ, the variable has not been initialized with a value, and any attempt to access it will result in a ReferenceError . The variable is initialized with a value when execution reaches the place in the code where it was declared. If no initial value was specified with the variable declaration, it will be initialized with a value of undefined .

This differs from var variables, which will return a value of undefined if they are accessed before they are declared. The code below demonstrates the different result when let and var are accessed in code before the place where they are declared.

 // TDZ starts at beginning of scope console.log(bar); // "undefined" console.log(foo); // ReferenceError: Cannot access 'foo' before initialization var bar = 1; let foo = 2; // End of TDZ (for foo) >

The term «temporal» is used because the zone depends on the order of execution (time) rather than the order in which the code is written (position). For example, the code below works because, even though the function that uses the let variable appears before the variable is declared, the function is called outside the TDZ.

 // TDZ starts at beginning of scope const func = () => console.log(letVar); // OK // Within the TDZ letVar access throws `ReferenceError` let letVar = 3; // End of TDZ (for letVar) func(); // Called outside TDZ! >

Using the typeof operator for a let variable in its TDZ will throw a ReferenceError :

typeof i; // ReferenceError: Cannot access 'i' before initialization let i = 10;

This differs from using typeof for undeclared variables, and variables that hold a value of undefined :

.log(typeof undeclaredVariable); // "undefined"

Redeclarations

let declarations cannot be in the same scope as any other declaration, including let , const , class , function , var , and import declaration.

 let foo; let foo; // SyntaxError: Identifier 'foo' has already been declared >

A let declaration within a function’s body cannot have the same name as a parameter. A let declaration within a catch block cannot have the same name as the catch -bound identifier.

function foo(a)  let a = 1; // SyntaxError: Identifier 'a' has already been declared > try  > catch (e)  let e; // SyntaxError: Identifier 'e' has already been declared >

If you’re experimenting in a REPL, such as the Firefox web console (Tools > Web Developer > Web Console), and you run two let declarations with the same name in two separate inputs, you may get the same re-declaration error. See further discussion of this issue in Firefox bug 1580891. The Chrome console allows let re-declarations between different REPL inputs.

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

let x = 1; switch (x)  case 0: let foo; break; case 1: let foo; // SyntaxError: Identifier 'foo' has already been declared break; >

To avoid the error, wrap each case in a new block statement.

let x = 1; switch (x)  case 0:  let foo; break; > case 1:  let foo; break; > >

Examples

Scoping rules

Variables declared by let have their scope in the block for which they are declared, 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;  var x = 2; // same variable! console.log(x); // 2 > console.log(x); // 2 > function letTest()  let x = 1;  let x = 2; // different variable console.log(x); // 2 > console.log(x); // 1 >

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

TDZ combined with lexical scoping

The following code results in a ReferenceError at the line shown:

function test()  var foo = 33; if (foo)  let foo = foo + 55; // ReferenceError > > test();

The if block is evaluated because the outer var foo has a value. However due to lexical scoping this value is not available inside the block: the identifier foo inside the if block is the let foo . The expression foo + 55 throws a ReferenceError because initialization of let foo has not completed — it is still in the temporal dead zone.

This phenomenon can be confusing in a situation like the following. The instruction let n of n.a is already inside the scope of the for. of loop’s block. So, the identifier n.a is resolved to the property a of the n object located in the first part of the instruction itself ( let n ). This is still in the temporal dead zone as its declaration statement has not been reached and terminated.

function go(n)  // n here is defined! console.log(n); // for (let n of n.a)  // ^ ReferenceError console.log(n); > > go( a: [1, 2, 3] >);

Other situations

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;  var a = 11; // the scope is global let b = 22; // the scope is inside the block console.log(a); // 11 console.log(b); // 22 > console.log(a); // 11 console.log(b); // 2

However, this combination of var and let declarations below is a SyntaxError because var not being block-scoped, leading to them being in the same scope. This results in an implicit re-declaration of the variable.

let x = 1;  var x = 2; // SyntaxError for re-declaration >

Declaration with destructuring

The left-hand side of each = can also be a binding pattern. This allows creating multiple variables at once.

const result = /(a+)(b+)(c+)/.exec("aaabcc"); let [, a, b, c] = result; console.log(a, b, c); // "aaa" "b" "cc"

Specifications

Specification
ECMAScript Language Specification # sec-let-and-const-declarations

Browser compatibility

BCD tables only load in the browser

MDN

Support

Product help
Report an issue

Our communities

Developers

Web Technologies
Learn Web Development
MDN Plus
Hacks Blog

Website Privacy Notice
Cookies
Legal
Community Participation Guidelines

Visit Mozilla Corporation’s not-for-profit parent, the Mozilla Foundation.
Portions of this content are ©1998– 2023 by individual mozilla.org contributors. Content available under a Creative Commons license.

В чём разница между var, let и const в JavaScript

Сегодня вы узнаете два новых способа создавать переменные в JavaScript (ES6), а именно с помощью let и const . Мы разберёмся в чём разница между операторами var , let , и const . Ещё мы затронем такие темы, как: область видимости функции и блока, поднятие переменной (hoisting) и неизменность.

В спецификации ES2015 (ES6) нам представили два новых оператора для создания переменных: let и const . Чтобы понять различия между var , let , и const , мы должны сперва поговорить о таких понятиях, как: объявление и инициализация переменных, область видимости (особенно функции) и поднятие переменной.

Инициализация и объявление переменной

Объявление переменной вводит новый идентификатор.

var declaration

Только что мы создали новый идентификатор с именем declaration. Когда в JavaScript создаётся переменная, она инициализируется со значением undefined . Если мы сейчас попытаемся логировать переменную declaration , то нам вернётся undefined .

var declarationconsole.log(declaration)

Инициализация — это присваивание значения переменной.

var declarationconsole.log(declaration) // undefineddeclaration = 'This is an initialization'

Итак, мы инициализировали переменную declaration , присвоив ей строку.

Это подводит нас к понятию «область видимости».

Область видимости

Область видимости определяет, где в коде программы будут доступны переменные и функции. В JavaScript есть два типа области видимости — глобальная и локальная (global scope и function scope). Согласно официальной спецификации:

Если переменная создаётся внутри объявления функции, то её область видимости определяется как локальная и ограничивается этой функцией.

То есть, если вы создаёте переменную внутри функции с оператором var , то она будет доступна только внутри этой функции и вложенных в неё функциях.

function getDate () var date = new Date()return date
>getDate()
console.log(date) // ❌ Reference Error

В коде выше, мы пытаемся получить доступ к переменной вне функции, в которой она была объявлена. Так как переменная date ограничена областью видимости функции getDate , она доступна только внутри getDate или для любой вложенной в неё функции (как в примере ниже).

function getDate () var date = new Date()function formatDate () return date.toDateString().slice(4) // ✅ 
>return formatDate()
>getDate()
console.log(date) // ❌ Reference Error

Давайте рассмотрим более сложный пример. Допустим у нас есть массивы prices и discount , нам нужно создать функцию, которая возьмёт значения из обоих массивов и вернёт новый массив цен с учётом скидок. В итоге у нас должен получится такой массив:

discountPrices([100, 200, 300], .5)

function discountPrices (prices, discount) var discounted = []for (var i = 0; i < prices.length; i++) var discountedPrice = prices[i] * (1 - discount) 
var finalPrice = Math.round(discountedPrice * 100) / 100 
discounted.push(finalPrice) 
>return discounted
>

Выглядит довольно просто, но что происходит в области видимости блока? Обратите внимание на цикл for . Доступны ли переменные, которые объявлены внутри цикла, вне его? Оказывается, что да.

function discountPrices (prices, discount) var discounted = []for (var i = 0; i < prices.length; i++) var discountedPrice = prices[i] * (1 - discount) 
var finalPrice = Math.round(discountedPrice * 100) / 100 
discounted.push(finalPrice) 
>console.log(i) // 3 
console.log(discountedPrice) // 150 
console.log(finalPrice) // 150return discounted
>

Если JavaScript это единственный язык программирования, которым вы владеете, то вы не заметите ничего странного. Но если вы перешли с другого языка, вы, вероятно, немного запутались в том, что здесь происходит.

Здесь нет ошибки, это просто немного необычно. К тому же, у нас нет необходимости иметь доступ к i , discountedPrice , и finalPrice вне цикла for . Для нас в этом нет никакой пользы, более того, в некоторых случаях это может мешать. Тем не менее, поскольку переменные, объявлены оператором var , они относятся к функции и доступны вне цикла.

Теперь вы знаете, что такое область видимости, инициализация и объявление переменных; нам осталось разобраться с понятием «поднятие переменной» (hoisting), прежде чем перейти к let и const .

Hoisting

Ранее я уже говорил, что при создании переменной в JavaScript, она инициализируются со значением undefined . Это и есть «Hoisting». Интерпретатор JavaScript присваивает переменой значение undefined по умолчанию, во время так называемой фазы «Создания».

Давайте посмотрим, как действует hoisting, на предыдущем примере:

function discountPrices (prices, discount) var discounted = undefined 
var i = undefined 
var discountedPrice = undefined 
var finalPrice = undefineddiscounted = [] 
for (var i = 0; i < prices.length; i++) discountedPrice = prices[i] * (1 - discount) 
finalPrice = Math.round(discountedPrice * 100) / 100 
discounted.push(finalPrice) 
>console.log(i) // 3 
console.log(discountedPrice) // 150 
console.log(finalPrice) // 150return discounted
>

Обратите внимание, что всем объявленным переменным присвоено значение undefined по умолчанию. Вот почему, если вы попытаетесь получить доступ к одной из этих переменных до того, как она была фактически объявлена, вам вернётся undefined .

function discountPrices (prices, discount) console.log(discounted) // undefinedvar discounted = []for (var i = 0; i < prices.length; i++) var discountedPrice = prices[i] * (1 - discount) 
var finalPrice = Math.round(discountedPrice * 100) / 100 
discounted.push(finalPrice) 
>console.log(i) // 3 
console.log(discountedPrice) // 150 
console.log(finalPrice) // 150return discounted
>

Теперь, когда вы знаете о var всё что нужно, давайте наконец разберёмся в чём разница между var , let , и const ?

var VS let VS const

Сперва сравним var и let . Главное отличие let в том, что область видимости переменной ограничивается блоком, а не функцией. Другими словами, переменная, созданная с помощью оператора let , доступна внутри блока, в котором она была создана и в любом вложенном блоке. Говоря «блок», я имею ввиду всё что вложено между фигурными скобками <> , как например в цикле for или условии if .

Давайте в последний раз вернёмся к нашей функции discountPrices .

function discountPrices (prices, discount) var discounted = []for (var i = 0; i < prices.length; i++) var discountedPrice = prices[i] * (1 - discount) 
var finalPrice = Math.round(discountedPrice * 100) / 100 
discounted.push(finalPrice) 
>console.log(i) // 3 
console.log(discountedPrice) // 150 
console.log(finalPrice) // 150return discounted
>

Помните, что мы можем логировать i , discountedPrice , и finalPrice вне цикла for , так как они созданы с помощью var , а значит видны в пределах функции. Но, что, если мы заменим оператор var на let и попробуем выполнить код.

function discountPrices (prices, discount) let discounted = []for (let i = 0; i < prices.length; i++) let discountedPrice = prices[i] * (1 - discount) 
let finalPrice = Math.round(discountedPrice * 100) / 100 
discounted.push(finalPrice) 
>console.log(i) // 3 
console.log(discountedPrice) // 150 
console.log(finalPrice) // 150return discounted
>discountPrices([100, 200, 300], .5) // ❌ ReferenceError: i is not defined

Вот что мы получим: ReferenceError: i is not defined . Это подтверждает, что let переменные ограничены блоком, а не функцией. Поэтому попытка получить к ним доступ приводит к ошибке.

var VS letvar: function scopedlet: block scoped

Следующее отличие связано с поднятием переменной. Ранее мы определили, что интерпретатор в JavaScript присваивает переменным значение undefined по умолчанию во время фазы «Создания». Вы даже видели это в действии, логируя переменную до её объявления (и получили undefined ).

function discountPrices (prices, discount) console.log(discounted) // undefinedvar discounted = []for (var i = 0; i < prices.length; i++) var discountedPrice = prices[i] * (1 - discount) 
var finalPrice = Math.round(discountedPrice * 100) / 100 
discounted.push(finalPrice) 
>console.log(i) // 3 
console.log(discountedPrice) // 150 
console.log(finalPrice) // 150return discounted
>

Я даже не могу придумать причину, по которой стоит запрашивать переменную до её объявления. Мне кажется, что получать по умолчанию ReferenceError лучше, чем возврат undefined .

Кстати, именно это и делает let , т.е. вы получите ошибку ReferenceError вместо значения undefined , если запросите переменную, созданную оператором let , до её объявления.

function discountPrices (prices, discount) console.log(discounted) // ❌ ReferenceErrorlet discounted = []for (let i = 0; i < prices.length; i++) let discountedPrice = prices[i] * (1 - discount) 
let finalPrice = Math.round(discountedPrice * 100) / 100 
discounted.push(finalPrice) 
>console.log(i) // 3 
console.log(discountedPrice) // 150 
console.log(finalPrice) // 150return discounted
>

var VS letvar: 
function scoped 
undefined when accessing a variable before it's declaredlet: 
block scoped 
ReferenceError when accessing a variable before it's declared

let VS const

Различия между var и let мы выяснили, а что насчёт const ? Получается, что const и let почти одно и тоже. И всё же есть одно отличие: значение переменной, объявленной с помощью const , нельзя переназначить. Это можно увидеть в примере ниже:

let name = 'Tyler'
const handle = 'tylermcginnis'name = 'Tyler McGinnis' // ✅
handle = '@tylermcginnis' // ❌ TypeError: Assignment to constant variable.

Итак, если вы хотите, чтобы переменная была неизменной, используйте const . Ну, почти. На самом деле оператор const не делает переменную неизменной, а только не даёт переназначать её значение. Вот хороший пример:

const person = name: 'Kim Kardashian'
>person.name = 'Kim Kardashian West' // ✅person = <> // ❌ Assignment to constant variable.

Обратите внимание, что изменение свойства объекта не является его переназначением, поэтому, даже если объект объявлен с помощью const , это не означает, что вы не можете изменить ни одно из его свойств. Это только означает, что вы не можете переназначить его на новое значение.

Теперь главный вопрос: что следует использовать var , let , или const ? Наиболее популярное мнение, под которым подписываюсь и я, — всегда использовать const , кроме тех случаев, когда вы знаете, что переменная будет изменятся. Используя const , вы как бы говорите себе будущему и другим разработчикам, которые будут читать ваш код, что эту переменную изменять не следует. Если вам нужна изменяемая переменная (например, в цикле for ), то используйте let .

Таким образом, между изменяемыми и неизменяемыми переменными осталось не так много различий. Это означает, что вам больше не придётся использовать var .

Теперь «непопулярное» мнение, хотя оно и обоснованно (пока): вы никогда не должны использовать const, потому что, хотя вы пытаетесь показать, что переменная неизменна, это не совсем правда (мы видели это на примере выше). Разработчики, которые разделяют это мнение, всегда используют let , за исключением случаев когда переменная действительно является константой, например _LOCATION_ = . .

Повторим для закрепления. Область видимости var переменных ограничена функцией, если вы обратитесь к переменной до её объявления, то получите undefined . const и let ограничены блоком, а попытка обратится к переменной до её объявления, вернётся ошибкой ReferenceError. И наконец, разница между let и const в том, что в первом случае вы можете изменить значение переменной, а во втором нет.

var VS let VS constvar: 
function scoped 
undefined when accessing a variable before it's declaredlet: 
block scoped 
ReferenceError when accessing a variable before it's declaredconst: 
block scoped 
ReferenceError when accessing a variable before it's declared 
can't be reassigned

Let JS — что это? Разница между var, const и let в JavaScript?

Операторы var, let и const — это три инструмента для объявления и инициализации переменных в языке программирования JavaScript. После появления последних двух методов в спецификации ES2015 многие разработчики стали задаваться вопросом, чем различаются доступные варианты, что из них использовать для разработки. Если тоже не понимаете, пришло время разобраться.

Переменные let и var

Var используется для объявления переменной и дальнейшей ее инициализации если есть такая потребность. Используется следующим образом: var varname, где под varname подразумевается наименование. Оно может принимать вид любого разрешенного JS идентификатора. Принято давать короткие названия на английском, по которым можно интуитивно определить назначение конкретного объекта. Это делает скрипт более читаемым, понятным. Второй способ по функционалу полностью копирует рассмотренный выше, но используется только тогда, когда нужно объявить и инициализировать информацию с зоной видимости, которая ограниченная текущим модулем. Она будет функционировать не только внутри этого блока, но и во входящих внутрь него подблоков. Основная разница между рассмотренными операторами заключается в следующем: они по-разному работают с областями видимости. Так, созданная за пределами функции var функционирует как глобальная, может быть вызвана в любой точке кода. Если она создается внутри функции, то ей присваивается локальный характер, обращаться к ней можно исключительно в том же участке кода. Второй метод работает только в рамках конкретного контейнера. Следующее различие между рассматриваемыми инструментами — попытка обратиться к заданной через var информации до ее назначения приведет к выдаче ошибки «undefined». Если выполнить аналогичное действие по отношению к let, будет отображена другая ошибка: «ReferenceError». Идентичное сообщение демонстрируется при попытке вызвать константу до ее назначения. Принципиальных различий нет, тем более обе озвученные проблемы не позволяют правильно применять код. Если столкнулись с ними, проверьте скрипт — возможно, не инициализированы уже вызванные сведения.

Константа в JS

Const в JavaScript создает постоянную, действие которой может носить как глобальный, так и локальный характер в блоке, где она была обнаружена. Это зависит от того, где именно произошел вызов. Важная особенность постоянной: ее нельзя переписать как объект. При этом помните: изменить свойства объекта, заданного таким способом, возможно.

Необходимость использования

Глобальная. Распространяется на всю функцию.
Локальная. Действует в конкретном контейнере и его подкатегориях.

Даже при всем желании специалист не сможет задать глобальную переменную через let с учетом того, что он пригоден только для локального расположения. При попытке обратиться к информации, заданной таким образом, за пределами модуля, получите ошибку обращения. В остальном нет никаких строгих принципов, когда пользоваться тем либо иным способом.

Следующий вопрос, интересующий многих разработчиков — что лучше предпочесть, let или const. Примечательно: оба оператора работают таким же образом за исключением одного свойства. Вызванные не через постоянную данные могут быть перезаписаны, тогда как значение const всегда постоянно. Многие программисты рекомендуют всегда объявлять информацию таким образом за исключением ситуаций, когда уверены, что созданный объект далее потребуется изменить.

Некоторые эксперты уверены, что код, написанный с использованием const, обрабатывается несколько быстрее по сравнению со скриптами, для разработки которых были использованы другие способы инициализации данных. Можете попробовать три варианта, сравнить скорость.

Теперь знаете, что такое let JS, какие различия с другими инструментами для работы с данными есть. Не стоит слепо следовать рекомендациям тех или иных людей. Полагайтесь преимущественно на собственный опыт, чтобы понять, какие методы программирования лучше.

Читать:

Как посчитать корреляцию спирмена в excel

Переменные: let и const

let

const

Итого

Что делает let в javascript

Try it

Syntax

Parameters

Description

Temporal dead zone (TDZ)

Redeclarations

Examples

Scoping rules

TDZ combined with lexical scoping

Other situations

Declaration with destructuring

Specifications

Browser compatibility

See also

Found a content problem with this page?

MDN

Support

Our communities

Developers

В чём разница между var, let и const в JavaScript

Инициализация и объявление переменной

Область видимости

Hoisting

var VS let VS const

let VS const

Let JS — что это? Разница между var, const и let в JavaScript?

Переменные let и var

Константа в JS

Необходимость использования

Похожие записи