Когда вы запускаете запрос Delete
, вы используете тот же Statement
, который использовался в запросе Select
. При повторном выполнении на том же Statement
предыдущий ResultSet
закрывается.
Чтобы избежать этого, вы должны создавать новый Statement
каждый раз, когда вы выполняете запрос. Поэтому удалите statement = connection.createStatement();
из метода connect()
в классе MySQLDatabase
и замените все statement
в этом классе на connection.createStatement()
. Вы также можете вообще удалить частную переменную statement
.
Вы можете узнать больше об этом здесь .
Разница заключается в определении области. var
привязан к ближайшему функциональному блоку, а let
- к ближайшему блоку , содержащему блок , который может быть меньше функционального блока. Оба являются глобальными, если вне любого блока.
Кроме того, переменные, объявленные с помощью let
, недоступны до того, как они будут объявлены в их закрывающем блоке. Как показано в демо, это вызовет исключение ReferenceError.
Демо :
var html = '';
write('#### global ####\n');
write('globalVar: ' + globalVar); //undefined, but visible
try {
write('globalLet: ' + globalLet); //undefined, *not* visible
} catch (exception) {
write('globalLet: exception');
}
write('\nset variables');
var globalVar = 'globalVar';
let globalLet = 'globalLet';
write('\nglobalVar: ' + globalVar);
write('globalLet: ' + globalLet);
function functionScoped() {
write('\n#### function ####');
write('\nfunctionVar: ' + functionVar); //undefined, but visible
try {
write('functionLet: ' + functionLet); //undefined, *not* visible
} catch (exception) {
write('functionLet: exception');
}
write('\nset variables');
var functionVar = 'functionVar';
let functionLet = 'functionLet';
write('\nfunctionVar: ' + functionVar);
write('functionLet: ' + functionLet);
}
function blockScoped() {
write('\n#### block ####');
write('\nblockVar: ' + blockVar); //undefined, but visible
try {
write('blockLet: ' + blockLet); //undefined, *not* visible
} catch (exception) {
write('blockLet: exception');
}
for (var blockVar = 'blockVar', blockIndex = 0; blockIndex < 1; blockIndex++) {
write('\nblockVar: ' + blockVar); // visible here and whole function
};
for (let blockLet = 'blockLet', letIndex = 0; letIndex < 1; letIndex++) {
write('blockLet: ' + blockLet); // visible only here
};
write('\nblockVar: ' + blockVar);
try {
write('blockLet: ' + blockLet); //undefined, *not* visible
} catch (exception) {
write('blockLet: exception');
}
}
function write(line) {
html += (line ? line : '') + '<br />';
}
functionScoped();
blockScoped();
document.getElementById('results').innerHTML = html;
<pre id="results"></pre>
Они очень похожи, если использовать это вне функционального блока.
let me = 'go'; // globally scoped
var i = 'able'; // globally scoped
Однако глобальные переменные, определенные с помощью let
, не будут добавлены как свойства на глобальном объекте window
, таком как те, которые определены с помощью var
.
console.log(window.me); // undefined
console.log(window.i); // 'able'
Они идентичны при использовании этого в функциональном блоке.
function ingWithinEstablishedParameters() {
let terOfRecommendation = 'awesome worker!'; //function block scoped
var sityCheerleading = 'go!'; //function block scoped
}
Вот разница. let
видна только в цикле for()
, а var
видна всей функции.
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)
//and there is a separate tuce variable for each iteration of the loop
}
//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
}
Предполагая строгий режим, var
будет позвольте вам повторно объявить одну и ту же переменную в той же области. С другой стороны, let
не будет:
'use strict';
let me = 'foo';
let me = 'bar'; // SyntaxError: Identifier 'me' has already been declared
'use strict';
var me = 'foo';
var me = 'bar'; // No problem, `me` is replaced.
Вот пример, чтобы добавить к тому, что уже написано другими. Предположим, вы хотите создать массив функций adderFunctions
, где каждая функция принимает один аргумент Number и возвращает сумму аргумента и индекс функции в массиве. Попытка сгенерировать adderFunctions
с помощью цикла с использованием ключевого слова var
не будет работать так, как можно было бы наивно ожидать:
// An array of adder functions.
var adderFunctions = [];
for (var i = 0; i < 1000; i++) {
// We want the function at index i to add the index to its argument.
adderFunctions[i] = function(x) {
// What is i bound to here?
return x + i;
};
}
var add12 = adderFunctions[12];
// Uh oh. The function is bound to i in the outer scope, which is currently 1000.
console.log(add12(8) === 20); // => false
console.log(add12(8) === 1008); // => true
console.log(i); // => 1000
// It gets worse.
i = -8;
console.log(add12(8) === 0); // => true
. Вышеописанный процесс не генерирует желаемый массив функций, потому что i
выходит за пределы итерации блока for
, в котором была создана каждая функция. Вместо этого в конце цикла i
в закрытии каждой функции ссылается на значение i
в конце цикла (1000) для каждой анонимной функции в adderFunctions
. Это совсем не то, чего мы хотели: теперь у нас есть массив из 1000 различных функций в памяти с точно таким же поведением. И если мы впоследствии обновим значение i
, мутация повлияет на все adderFunctions
.
Однако мы можем попробовать снова, используя ключевое слово let
:
// Let's try this again.
// NOTE: We're using another ES6 keyword, const, for values that won't
// be reassigned. const and let have similar scoping behavior.
const adderFunctions = [];
for (let i = 0; i < 1000; i++) {
// NOTE: We're using the newer arrow function syntax this time, but
// using the "function(x) { ..." syntax from the previous example
// here would not change the behavior shown.
adderFunctions[i] = x => x + i;
}
const add12 = adderFunctions[12];
// Yay! The behavior is as expected.
console.log(add12(8) === 20); // => true
// i's scope doesn't extend outside the for loop.
console.log(i); // => ReferenceError: i is not defined
На этот раз i
отскок на каждой итерации цикла for
. Каждая функция теперь сохраняет значение i
во время создания функции, а adderFunctions
ведет себя так, как ожидалось.
Теперь изображение смешивает два поведения, и вы, вероятно, увидите, почему это не рекомендуется для смешивания новых let
и const
со старым var
в том же скрипте. Это может привести к некоторому эффектно запутанному коду.
const doubleAdderFunctions = [];
for (var i = 0; i < 1000; i++) {
const j = i;
doubleAdderFunctions[i] = x => x + i + j;
}
const add18 = doubleAdderFunctions[9];
const add24 = doubleAdderFunctions[12];
// It's not fun debugging situations like this, especially when the
// code is more complex than in this example.
console.log(add18(24) === 42); // => false
console.log(add24(18) === 42); // => false
console.log(add18(24) === add24(18)); // => false
console.log(add18(24) === 2018); // => false
console.log(add24(18) === 2018); // => false
console.log(add18(24) === 1033); // => true
console.log(add24(18) === 1030); // => true
Не позволяйте этому случиться с вами. Используйте linter.
ПРИМЕЧАНИЕ. Это пример обучения, предназначенный для демонстрации поведения
blockquote>var
/let
в циклах и закрытия функций, которые также будут легко понятны. Это был бы ужасный способ добавить числа. Но общая техника захвата данных при закрытии анонимных функций может встречаться в реальном мире в других контекстах. YMMV.
let value = i;
. Оператор for
создает лексический блок.
– Toothbrush
22 October 2015 в 22:38
Вот пример ключевого слова let
с некоторыми примерами.
let работает очень похоже на var. Основное отличие состоит в том, что область действия переменной var представляет собой всю закрывающую функцию
blockquote>В этой таблице в Википедии показано, какие браузеры поддерживают Javascript 1.7.
Обратите внимание, что поддерживаются только браузеры Mozilla и Chrome. IE, Safari и, возможно, другие нет.
let
msdn.microsoft.com/en-us/library/ie/dn342892%28v=vs.85%29.aspx
– eloyesp
24 December 2013 в 14:59
Основное различие - разность областей, в то время как let может быть доступна только в пределах области, которую она объявила, например, для цикла for, например, для доступа к var вне цикла. Из документации в MDN (примеры также из MDN):
let позволяет вам объявлять переменные, которые ограничены по объему блоку, выражению или выражению, на которых Это использовано. Это не похоже на ключевое слово var, которое определяет переменную глобально или локально для целой функции независимо от области блока.
Переменные, объявленные let, имеют в качестве области действия блок, в котором они определены, а также в любых содержащихся подблоках. Таким образом, пусть работает очень похоже на var. Основное различие заключается в том, что область действия переменной var является всей охватывающей функцией:
blockquote>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 }`
На верхнем уровне программ и функций пусть, в отличие от var, не создать свойство на глобальном объекте. Например:
blockquote>var x = 'global'; let y = 'global'; console.log(this.x); // "global" console.log(this.y); // undefined
При использовании внутри блока, ограничивает область видимости переменной этим блоком. Обратите внимание на разницу между var, область видимости которой находится внутри функции, где она объявлена.
blockquote>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
Также не забывайте, что это функция ECMA6, поэтому она еще не полностью поддерживается, поэтому лучше всегда транслирует его в ECMA5 с помощью Babel и т. д. ... для получения дополнительной информации о посещении веб-сайта babel
При использовании let
ключевое слово let
присоединяет объявление переменной к какому-либо блоку (обычно пару { .. }
), в котором оно содержится. Другими словами, let
неявно захватывает область любого блока для его объявления переменной.
let
переменные не могут быть доступны в объекте window
, потому что они не могут быть глобально доступны.
function a(){
{ // this is the Max Scope for let variable
let x = 12;
}
console.log(x);
}
a(); // Uncaught ReferenceError: x is not defined
При использовании var
var
, а переменные в ES5 имеют области действия, означающие, что переменные действительны внутри функции, а не вне самой функции.
var
переменные могут быть доступны в window
, потому что они не могут быть доступны по всему миру.
function a(){ // this is the Max Scope for var variable
{
var x = 12;
}
console.log(x);
}
a(); // 12
Если вы хотите узнать больше продолжить чтение ниже
, один из самых известных вопросов собеседования по сфере охвата также может быть достаточным точное использование let
и var
, как показано ниже:
При использовании let
for (let i = 0; i < 10 ; i++) {
setTimeout(
function a() {
console.log(i); //print 0 to 9, that is literally AWW!!!
},
100 * i);
}
Это связано с тем, что при использовании let
для каждой итерации цикла переменная
При использовании var
for (var i = 0; i < 10 ; i++) {
setTimeout(
function a() {
console.log(i); //print 10 times 10
},
100 * i);
}
Th заключается в том, что при использовании var
для каждой итерации цикла переменная имеет область действия и имеет общую копию.
let
не будет подниматься ко всей области блока, в которой они появляются. Напротив, var
может подниматься, как показано ниже. {
console.log(cc); // undefined. Caused by hoisting
var cc = 23;
}
{
console.log(bb); // ReferenceError: bb is not defined
let bb = 23;
}
Фактически, Per @Bergi, Подняты var
и let
. let
полезен для закрытия и сбора мусора для восстановления памяти. Рассмотрим, function process(data) {
//...
}
var hugeData = { .. };
process(hugeData);
var btn = document.getElementById("mybutton");
btn.addEventListener( "click", function click(evt){
//....
});
Обратный вызов обработчика click
вообще не нуждается в переменной hugeData
. Теоретически, после запуска process(..)
, огромная структура данных hugeData
может быть собрана в мусор. Тем не менее, возможно, что какой-то движок JS по-прежнему должен сохранить эту огромную структуру, поскольку функция click
имеет закрытие по всей области. Тем не менее, область блока может сделать эту огромную структуру данных собранной мусором. function process(data) {
//...
}
{ // anything declared inside this block can be garbage collected
let hugeData = { .. };
process(hugeData);
}
var btn = document.getElementById("mybutton");
btn.addEventListener( "click", function click(evt){
//....
});
let
петли let
в цикле могут повторно привязывать его к каждой итерации цикла, чтобы повторно назначить ему значение с конца предыдущей итерации цикла. Рассмотрим // print '5' 5 times
for (var i = 0; i < 5; ++i) {
setTimeout(function () {
console.log(i);
}, 1000);
}
, но заменим var
на let
// print 1, 2, 3, 4, 5. now
for (let i = 0; i < 5; ++i) {
setTimeout(function () {
console.log(i);
}, 1000);
}
Поскольку let
создают новую лексическую среду с этими именами для a) выражение инициализатора b) каждая итерация (предшествующая оценке выражения инкремента), больше подробности здесь . Если я прочитал спецификации прямо, тогда let
, к счастью, также можно использовать, чтобы избежать самоназывающих функций, используемых для имитации только частных членов - популярного шаблона дизайна, который уменьшает читаемость кода, затрудняет отладку, что не добавляет реального кода защиты или другой пользы - за исключением, возможно, удовлетворения чьего-то желания семантики, поэтому прекратите ее использовать. / rant
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();
myInstance.showPublic();
myInstance.showPrivate();
console.log(privateScope.hiddenProperty); // error
См. « Эмуляция частных интерфейсов »
В этой статье четко определена разница между var, let и const
const
- сигнал о том, что идентификатор не будет переназначен.
let
, является сигналом о том, что переменная может быть переназначена, например счетчик в цикле, или обмен значениями в алгоритме. Он также сигнализирует, что переменная будет использоваться только в определенном блоке, в котором не всегда содержится вся содержащая функция.blockquote>
var
теперь является самым слабым сигналом, доступным при определении переменной в JavaScript. Переменная может быть переназначена или не может быть изменена, и эта переменная может использоваться или не использоваться для целой функции или только для целей блока или цикла.https: //medium.com/javascript-scene/javascript-es6-var-let-or-const-ba58b8dcde75#.esmkpbg9b
Есть некоторые тонкие отличия - let
scoping ведет себя больше, как изменение переменных, в более или менее любых других языках.
, например. Он привязан к закрывающему блоку. Они не существуют до их объявления и т. Д.
Однако стоит отметить, что let
является лишь частью новых реализаций Javascript и имеет разную степень поддержка браузера .
let
включен в проект шестого издания и, скорее всего, будет в окончательной спецификации.
– Richard Ayotte
31 March 2012 в 16:09
let
. Safari, IE и Chome - нет.
– pseudosavant
13 July 2012 в 18:38
let
не поднимается, чтобы использовать переменную, определенную в let
, определенную в верхней части вашего блока. Если у вас есть оператор if
, который больше, чем несколько строк кода, вы можете забыть, что вы не можете использовать эту переменную до тех пор, пока она не будет определена. БОЛЬШАЯ ТОЧКА !!!
– Eric Bishard
7 May 2015 в 14:01
let
будет поднимать переменную до вершины блока. Однако ссылка на переменную в блоке перед объявлением переменной приводит к ReferenceError i> (моя заметка: вместо старого старого undefined
). Переменная находится в «временной мертвой зоне» от начала блока до тех пор, пока декларация не будет обработана. & Quot; То же самое относится и к операторам switch, потому что есть только один базовый блок ". Источник: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
– GitaarLAB
21 May 2016 в 04:15
Также кажется, что, по крайней мере, в Visual Studio 2015, TypeScript 1.5, «var» допускает несколько объявлений с одним и тем же именем переменной в блоке, а «let» - нет.
Это выиграло 'генерирует ошибку компиляции:
var x = 1;
var x = 2;
Это будет:
let x = 1;
let x = 2;
i
Известно всюду в функциональном блоке! Он начинается с undefined
(из-за подъема), пока вы не назначите значение! ps: let
также поднимается (вверху блока, содержащего его), но будет давать ReferenceError
при ссылке в блоке перед первым назначением. (ps2: Я про-полуколонный парень, но вам не нужна точка с запятой после блока). Это, как говорится, спасибо за добавление проверки реальности относительно поддержки!
– GitaarLAB
21 May 2016 в 04:41
let
и var
!
– John Slegers
27 February 2018 в 00:37
let
и const
были рекомендованы, чтобы использовать их только тогда, когда вам действительно нужны их дополнительные функции i>, потому что принудительное выполнение / проверка этих дополнительных функции (например, write-only const) приводят к «большей работе» (и дополнительным узлам-узлам в дереве областей) для (текущего) движка (-ов) для обеспечения / проверки / проверки / настройки.
– GitaarLAB
1 March 2018 в 19:17
Разница заключается в области переменных, объявленных с каждым.
На практике существует ряд полезных последствий разницы в области:
Переменныеlet
видны только в ближайшем к нему блоке ({ ... }
). let
переменные используются только в строках кода, которые после объявлена переменная (даже если они подняты !). let
переменные не могут быть переопределены последующим var
или let
. let
не добавляются к глобальному объекту window
. let
переменные просты в использовании с закрытием (они не вызывают условия гонки ). Ограничения, налагаемые let
, уменьшают видимость переменных и увеличивают вероятность того, что неожиданные столкновения имен будут найдены раньше. Это облегчает отслеживание и рассуждение о переменных, в том числе их достижимость (помощь в восстановлении неиспользуемой памяти).
Следовательно, переменные let
с меньшей вероятностью могут вызывать проблемы при использовании в больших программах или когда независимые разработки объединяются в новые и неожиданные способы.
var
может по-прежнему быть полезным, если вы уверены, что хотите эффект единственной привязки при использовании замыкания в цикле ( # 5) или для объявления внешне видимых глобальных переменных в вашем коде (# 4). Использование var
для экспорта может быть вытеснено, если export
мигрирует из пространства транспилера и на основной язык.
1. Не использовать внешний ближайший закрывающий блок: этот блок кода выдает опорную ошибку, потому что второе использование x
происходит за пределами блока, где оно объявлено с помощью let
:
{
let x = 1;
}
console.log(`x is ${x}`); // ReferenceError during parsing: "x is not defined".
В отличие от , тот же пример с var
работает.
2. Не использовать перед объявлением: этот блок кода будет выдавать ReferenceError
до того, как код будет запущен, потому что x
используется до его объявления:
{
x = x + 1; // ReferenceError during parsing: "x is not defined".
let x;
console.log(`x is ${x}`); // Never runs.
}
Напротив, тот же пример с var
анализирует и работает без каких-либо исключений.
3. Нет повторного объявления. Следующий код демонстрирует, что переменная, объявленная с помощью let
, не может быть повторно указана позже:
let x = 1;
let x = 2; // SyntaxError: Identifier 'x' has already been declared
4. Глобалы, не привязанные к window
:
var button = "I cause accidents because my name is too common.";
let link = "Though my name is common, I am harder to access from other JS files.";
console.log(link); // OK
console.log(window.link); // undefined (GOOD!)
console.log(window.button); // OK
5. Простое использование с затворами: переменные, объявленные с помощью var
, плохо работают с замыканиями внутри петель. Вот простой цикл, который выводит последовательность значений, которые переменная i
имеет в разные моменты времени:
for (let i = 0; i < 5; i++) {
console.log(`i is ${i}`), 125/*ms*/);
}
В частности, эти выходы:
i is 0
i is 1
i is 2
i is 3
i is 4
In JavaScript мы часто используем переменные значительно позже, чем когда они созданы. Когда мы это продемонстрируем, задерживая выход с закрытием, переданным в setTimeout
:
for (let i = 0; i < 5; i++) {
setTimeout(_ => console.log(`i is ${i}`), 125/*ms*/);
}
... выход остается неизменным, пока мы придерживаемся let
. Напротив, если бы мы использовали var i
вместо:
for (var i = 0; i < 5; i++) {
setTimeout(_ => console.log(`i is ${i}`), 125/*ms*/);
}
... цикл неожиданно выводит «i is 5» пять раз:
i is 5
i is 5
i is 5
i is 5
i is 5
var
вместо let
, код эквивалентен: var i = 0; while (i < 5) { doSomethingLater(); i++; }
i
находится за закрытием, а к тому времени, когда doSomethingLater()
выполняется, i
уже увеличивается 5 раз, следовательно выход будет i is 5
пять раз. Используя let
, переменная i
находится внутри замыкания, поэтому каждый асинхронный вызов получает свою собственную копию i
вместо использования «глобальной», созданной с помощью var
.
– Daniel T.
2 June 2017 в 01:12
for
. Более точная трансформация, хотя и более сложная, является классической for (var i = 0; i < 5; i++) { (function(j) { setTimeout(_ => console.log(
i, является $ {j} ), 125/*ms*/); })(i); }
, которая вводит "запись активации функции" для сохранения каждого значения i
с именем j
внутри функции.
– mormegil
25 July 2017 в 07:13
var
- глобальная область действия (с возможностью подъема).
let
и const
- область блока.
test.js
blockquote>
{ let l = 'let'; const c = 'const'; var v = 'var'; v2 = 'var 2'; } console.log(v, this.v); console.log(v2, this.v2); console.log(l); // ReferenceError: l is not defined console.log(c); // ReferenceError: c is not defined
Как упоминалось выше:
Разница заключается в определении области.
blockquote>var
привязан к ближайшему функциональному блоку, аlet
привязан к ближайшему закрывающему блоку, который может быть меньше функционального блока. Оба являются глобальными, если вне любого блока. Давайте посмотрим на пример:Example1:
В обоих моих примерах у меня есть функция
myfunc
.myfunc
содержит переменнуюmyvar
, равную 10. В моем первом примере я проверяю, равен лиmyvar
10 (myvar==10
). Если да, я agian объявляю переменнуюmyvar
(теперь у меня есть две переменные myvar), используя ключевое словоvar
и присваиваю ей новое значение (20). В следующей строке я напечатаю его значение на моей консоли. После условного блока я снова распечатаю значениеmyvar
на моей консоли. Если вы посмотрите на выходmyfunc
,myvar
имеет значение равно 20.Пример2: В моем втором примере вместо использования
var
в моем условном блоке объявляюmyvar
с помощью ключевого словаlet
. Теперь, когда я вызываюmyfunc
, я получаю два разных выхода:myvar=20
иmyvar=10
.Таким образом, разница очень проста в его области.
Проверьте эту ссылку в MDN
let x = 1;
if (x === 1) {
let x = 2;
console.log(x);
// expected output: 2
}
console.log(x);
// expected output: 1
let
, хотя это сделает его дубликатом другого ответа здесь
– pushkin
31 May 2018 в 19:47
ECMAScript 6 добавил еще одно ключевое слово, чтобы объявлять переменные, другие «const», кроме «let».
Основная цель введения «let» и «const» над «var» должно иметь область охвата блока вместо традиционной лексической области. В этой статье объясняется очень кратковременная разница между «var» и «let», а также обсуждается обсуждение «const» .
let { type, name, value } = node;
? вы создаете новый объект с 3 свойствами type / name / value и инициализируете их значениями свойств из узла?
– AlainIb
15 June 2017 в 07:55
let
также можно использовать, чтобы избежать проблем с закрытием. Он связывает свежую ценность, а не сохраняет старую ссылку, как показано в примерах ниже.
for(var i = 1; i < 6; i++) {
document.getElementById('my-element' + i)
.addEventListener('click', function() { alert(i) })
}
В коде выше показана классическая проблема закрытия JavaScript. Ссылка на переменную i
хранится в закрытии обработчика кликов, а не на фактическом значении i
.
Каждый обработчик одного клика будет ссылаться на один и тот же объект, потому что есть только один объект-счетчик, имеет 6, поэтому вы получаете по шесть на каждом клике.
Общим решением является обернуть это анонимной функцией и передать i
в качестве аргумента. Эти проблемы также можно избежать, используя let
вместо var
, как показано в коде ниже.
DEMO (проверено в Chrome и Firefox 50)
'use strict';
for(let i = 1; i < 6; i++) {
document.getElementById('my-element' + i)
.addEventListener('click', function() { alert(i) })
}
let
, но он предупреждает «6». для всех кнопок. У вас есть источник, говорящий о том, как let
должен вести себя?
– Jim Hunziker
22 October 2015 в 13:29
let
будет действительно полезен. Установка прослушивателей событий в цикле больше не требует непосредственного вызова функции для локального определения области i
на каждой итерации.
– Adrian Moisa
21 February 2016 в 09:12
let является частью es6. Эти функции объяснят разницу легким способом.
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
}
Вот пример разницы между двумя (поддержка только что началась для chrome): [/g2]
Как вы можете видеть, переменная var j
по-прежнему имеет значение вне из области действия цикла (Block Scope), но переменная let i
не определена вне области действия цикла.
"use strict";
console.log("var:");
for (var j = 0; j < 2; j++) {
console.log(j);
}
console.log(j);
console.log("let:");
for (let i = 0; i < 2; i++) {
console.log(i);
}
console.log(i);
В принятом ответе отсутствует точка:
{
let a = 123;
};
console.log(a); // ReferenceError: a is not defined
for
, резко сужая область применения ограничений let
. Upvoted.
– Jon Davis
22 September 2015 в 06:55
let
block expressionlet (variable declaration) statement
является нестандартным и будет удалено в будущем, bugzilla.mozilla.org/show_bug.cgi?id=1023609 . – Gajus 17 December 2014 в 15:51let
не добавлять свойство в глобальную переменную 2ality.com/2015/02/es6-scoping.html#the_global_object – Yukulélé 26 September 2015 в 10:51