Управляющие инструкции

break	Завершает текущий цикл или конструкции switch и label и передает управление на следующий вызов
comment	Авторский комментарий, объясняющий работу скрипта. Комментарии игнорируются интерпретатором.
const	Объявляет видимую в пределах блока переменную с постоянным значением.
continue	Прекращает текущую итерацию цикла и продолжает выполнение со следующей итерации
do..while	Задает цикл с проверкой условия после каждой итерации
for	Создать цикл, указав начальное состояние, условие и операцию обновления состояния
for..in	Перебрать свойства объекта, для каждого свойства выполнить заданный код
for..of	Предназначен для итерации по элементам коллекций
function	Объявить функцию
if	Выполняет тот или иной блок кода в зависимости от того, верно ли условие
label	Указать идентификатор для использования в break и continue
let	Объявляет видимую в пределах блока переменную.
return	Возвратить результат работы функции
switch	Сравнивает значение выражения с различными вариантами и при совпадении выполняет соответствующий код
throw	Инициировать("бросить") исключение
try..catch	Ловить все исключения, выпадающие из блока кода
var	Объявить переменную (или несколько) в текущей области видимости
while	Задает цикл, который выполняется до тех пор, пока условие верно. Условие проверяется перед каждой итерацией.
with	Добавить новую область видимости
Блок	Группировка javascript-вызовов внутри фигурных скобок

break

Завершает текущий цикл или конструкции switch и label и передает управление на следующий вызов

Синтаксис

break [label]

Параметры

label: Идентификатор метки, которой помечен прерываемый оператор/конструкция. Не обязательно для циклов и switch

Описание, комментарии, примеры

Единственное ограничение и отличие break от не существующего в javascript goto: вызов break должен находится внутри помеченного оператора, чтобы прервать его управление.

простой пример:

for(i=0; i<10; i++) {

    if (i==5) break;

}
alert(i);

В языке javascript оператор break дает возможность прерывать выполнение сразу на несколько уровней. Для этого используется метка label:

top:
for(i=0; i<10; i++) {
  for(j=0; j<15; j++) {
    if (i==5 && j==5) break top;
  }
}
alert(j+i);

Помеченным может быть не только цикл/switch, но и блок:

top: 
{
  a=5
  break top
  a=10
}
alert(a);

comment

Авторский комментарий работы скрипта. Комментарии игнорируются интерпретатором.

Синтаксис

// текст однострочного комментария

/* многострочный текст комментария */

Описание

JavaScript поддерживает комментарии в стиле Java, C++:

Однострочный комментарий начинается с двойного слэша (//)
Многострочный комментарий находится в пределах символов /* и */

Примеры

// Это однострочный комментарий.

/* Это многострочный комментарий. Он может быть любого размера и,
Вы можете размещать его где угодно. */

const

Объявляет видимую в пределах блока переменную с постоянным значением.

Синтаксис

const constant1 = value1

Параметры

constant1: Имя объявляемой переменной.
value1: Исходное значение, присваиваемое переменной.

Описание, комментарии, примеры

Использование оператора const для объявления переменной с постоянным значением, область действия ограничивается в блок, в котором он объявлен. Значение переменной невозможно изменить.

Переменная, объявленная с использованием ключевого слова const, должна быть инициализирована при объявлении.

Объявление const полностью аналогично let, за исключением того, что переменную нельзя менять.

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

const user = {
  name: "Вася"
};

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

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

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

const ORANGE = "#ffa500"

Совместимость с браузерами


21	11	36	5	12

continue

Прекращает текущую итерацию цикла и продолжает выполнение со следующей итерации

Синтаксис

continue [label]

Параметры

label: Необязательная метка для перехода к следующей итерации несколькими уровнями циклов выше

Описание, комментарии, примеры

В противоположность оператору break, continue не останавливает исполнение цикла.

Вместо этого:

для цикла while - передает управление на проверку условия цикла
для цикла for - передает управление на обновление условия

Оператор continue может содержать необязательную метку. Тогда управление будет передано на следующую итерации внешнего цикла с такой меткой.

Как и для оператора break, для перехода на метку вызов continue должен быть вложен в цикл с такой меткой.

for(i=0; i<10; i++) {
  if (i<5) continue;

  alert(i) // 5
  break;
}

Пример перехода на метку

top:
for(i=0; i<10; i++) {
  for(j=0; j<10; j++) {
    if (i==j) continue top;
    //...
  }
}

В этом примере оператор continue при совпадающих i,j переведет управление сразу на следующую итерацию внешнего цикла по i.

do..while

Задает цикл с проверкой условия после каждой итерации

Синтаксис

do
   statement
while (condition)

Параметры

statement: Блок или вызов javascript, который будет выполняться, пока верно условие condition
condition: Выражение будет вычислено каждый раз во время цикла. Если оно верно, statement будет выполнено еще раз, если нет - контроль пойдет на операторы после do..while

Пример

В следующем примере оператор do..while выполнится хотя бы один раз и продолжит выполняться, пока i<5.

i = ...
do {
   i += 1;
   document.write(i)
} while (i < 5)

for

Создать цикл, указав начальное состояние, условие и операцию обновления состояния

Синтаксис

for ([initial-expression]; [condition]; [final-expression])
   statement

Параметры

initial-expression: Выражение (включая присваивание) или объявление переменной. Как правило, используется для инициализации переменной-счетчика. Это условие может объявлять новую переменную при помощи var. Такая переменная не является локальной переменной цикла, она видна во всей области видимости.
condition: Выражение, которое вычисляется между итерациями. Если оно является верным true, то выполняется следующая итерация, иначе - управление переходит дальше, вызовам после цикла.
final-expression: Выражение, которое вычисляется в конце каждой итерации, перед проверкой условия condition. Обычно используется для увеличения переменной-счетчика.
statement: Блок или javascript-вызов для выполнения при каждой итерации цикла, пока верно условие condition

Ни одно условие не является обязательным.

Примеры

В следующем примере в начальном условии объявляется переменная-счетчик i и увеличивается до 9 по 1 за каждую итерацию

for (var i = 0; i < 9; i++) {
   n += i
}

Пример: бесконечный цикл с выходом изнутри

for(;;) {
  ...
  if (какое-то условие) break;
}

for..in

Перебрать свойства объекта, для каждого свойства выполнить заданный код

Синтаксис

for (property in object)
  statement

Параметры

property: Переменная, которой последовательно присваиваются названия свойств объекта. Может быть объявлена при помощи var, но не будет при этом локальной для цикла
object: Объект, свойства которого перебираются
statement: Блок или javascript-вызов для вызова на каждой итерации

Описание, комментарии, примеры

Конструкция for..in - единственный в javascript способ перебрать все свойства объекта.

Большинство свойств встроенных объектов javascript перебираться в цикле for..in не будут, так как помечены специальным внутренним флагом DontEnum.
Этот флаг нельзя получить или поменять.

var a = {
  p1: 1,
  p2: 2
}
for(var p in a) {
  alert(p) // p1, затем p2

  // к значению каждого свойства прибавить 1
  a[p] = a[p] + 1
}

Пример: встроенное свойство toString:

// объявим объект
var a = {
  p1: 1
}

// у него есть свойство toString
alert(a.toString) 

// унаследованное от Object.prototype
alert(a.toString === Object.prototype.toString) // true

for(p in a) {
  // в этом цикле свойства toString не будет
  alert("Property name:"+p+" value:"+a[p])
}

Порядок перечисления свойств не определен.

Поэтому, если во время итерации добавить свойство к объекту - цикл может по нему пройти позже или не пройти никогда, в зависимости от того, куда это новое свойство встанет во внутренней хэш-таблице интерпретатора javascript.

При удалении свойства во время итерации - если цикл по нему еще не прошел, то он не пройдет в дальнейшем.

Для перебора всех свойств объекта, кроме унаследованных, используется конструкция for..in с дополнительной проверкой.

for(var prop in object) {
  // если свойство унаследовано - continue
  if (!object.hasOwnProperty(prop)) continue

  // работа с prop
  ...
}

В следующем примере свойство print участвовало бы в цикле, если бы там не было проверки.

Object.prototype.print = function() { 
  document.write(this) 
}
var a = {
  p1: 1,
  p2: 2
}
for(var p in a) {
  if (!a.hasOwnProperty(p)) continue
  alert(p)
}

for..of

Цикл for.. of предназначен для итерации по элементам коллекций, но в отличие от цикла for .. in при итерациях используется значение, а не ключ.

Синтаксис

for (variable of iterable) {
  statement
}

Параметры

variable: Для каждой итерации переменной присваивается значение следующего свойства. Переменная может быть объявлена с const, let, или var.
object: объект, имеющий итерируемые свойства.
statement: Блок или javascript-вызов для вызова на каждой итерации

Описание, комментарии, примеры

Цикл for .. of для массивов работает схожим образом с forEach, но имеет свои плюсы: как и в любом другом цикле можно использовать continue и break для контроля итераций, что при использовании forEach невозможно. Таким образом, основное преимущество цикла for .. of над методом массивов forEach заключается в широких возможностях его оптимизации.

С помощью цикла for .. of можно перебирать не только массивы, но и многие другие коллекции, такие как:

строки
генераторы
типизированные массивы
коллекции DOM элементов

const calculateSum = (coll) => {
  let sum = 0;
  for (const value of coll) { sum += value; }
  return sum;
};
alert( calculateSum( [1,2,3,4,5,6,7,8,9] ) );

let s='';
for (var chr of "♔♕♖♗♘") {s+='\n'+chr; }
alert(s);

// Коллекции DOM элементов
let result = [];
for (let link of document.links) {
  if (!/#/.test(link)) result.push(link.href);
}
alert( result.join('\n') );

let numphones = new Map ([
  [ "Андрей", "+7 918 567 3245" ],
  [ "Antonio", "+34 611 567 200"],
  [ "Smit", "+1 345 678 3241"],
]);
let s="";
for (var [key, value] of numphones) {
    s+="\nУ " + key + " номер телефона: " + value;
 }
alert(s);

let a = {
  "Россия": "Москва",
  "Epaña":  "Madrid",
  "USA":    "Washington"
};
let s="";
for (const [ country, capital ] of Object.entries(a) ) {
    s+="\nСтрана: " + country + ", \t столица: " + capital;
 }
alert(s);

function

Объявить функцию

Синтаксис

function name([param_1] [, param_2] [..., param_n]) {
   statements
}

Параметры

name: Имя функции
param_1, param_2, ..., param_n: Названия параметров
statements: Тело функции

Описание, комментарии, примеры

Существует два вида использования этой конструкции:

объявление функции:
```
function func(a) { ... }
```
присвоение анонимной функции:
```
var func = function(a) { ...}
```

Их отличие - в области видимости. Присвоенная анонимная функция видна с момента присвоения, а объявленная явно - везде:

// функции определены ниже
alert(decl) // функция видна, все ок
alert(anon) // функция еще не определена - ошибка
// сами функции 
function decl(a) { }
var anon = function(a) { }

Функции можно запускать с любым числом параметров.

Если функции передано меньше параметров, чем есть в определении, то отсутствующие считаются undefined.

Следующая функция возвращает время time, необходимое на преодоление дистанции distance с равномерной скоростью speed.

var run = function (distance, speed)
 { speed = speed || 10;
   var time = distance / speed;
   return time;
 }
alert (
  run (10) + '\n' +
  run (10,2) + '\n' +
  run (10,2,5,6,7) + '\n' +
  run () );

Функция, объявленная внутри другой функции, видит переменные внешней функции. Они доступны ей даже тогда, когда родительская функция завершила исполнение. Это называется замыканием.

Значение возвращается оператором return. Функции без return или с return без значения возвращают undefined.

В теле функции доступна специальная переменная arguments, которая содержит параметры и ссылку на объект, представляющий собой текущую функцию:

Аргументы вызова, начиная от нуля
Длину в свойстве length
Ссылку на саму функцию в свойстве callee

func(5);
function func() {
  alert ( 
    "Количество аргументов:   " + arguments.length + '\n' +
    "Аргументы:    (" + arguments[0] + ', ' + arguments[1] + ', ' + arguments[3] + ')\n'+
    "ссылка на функцию func:\n" + arguments.callee );
}
func(1,2,3);

if

Выполняет тот или иной блок кода в зависимости от того, верно ли условие

Синтаксис

if (condition)
   statement1
[else
   statement2]

Параметры

condition: Выражение, являющееся условием для проверки
statement1: Блок или javascript-вызов, который выполняется, если условие верно
statement2: Блок или javascript-вызов, который выполняется, если условие ложно

Описание, примеры

В javascript также разрешена проверка else if:

if (a==1) {
  ...
} else if (a==2) {
  ...
} else {
  ...
}

В качестве условия может быть любое выражение:

Пример: присваивание как условие

a = 5
if (b=a) {
  ...
}

label

Указать идентификатор для использования в break и continue

Синтаксис

label:
   statement

Параметры

label: Любой идентификатор javascript, кроме зарезервированных слов
statement: Цикл, оператор switch или блок, который помечается

Описание, примеры

Указывает идентификатор для использования в break и continue

Для примеров использования смотрите информацию об операторах break и continue

let

Оператор let объявляет переменную с блочной областью видимости с возможностью инициализировать её значением.

Синтаксис

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

Параметры

var1, var2, ..., varN: Имя переменной. Может использоваться любой допустимый идентификатор.
value1, value2, ..., valueN: Значение переменной. Любое допустимое выражение.

Описание, комментарии, примеры

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

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

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

Переменная, объявленная через var, видна везде в функции.

Переменная, объявленная через let, видна только в рамках блока {...}, в котором объявлена.

Это, в частности, влияет на объявления внутри if, while или for.
```
var str = '';
var xvar = 5; //переменная через var:
let xlet = 5; //переменная через let:
if (true) {
  var xvar = 10;
  let xlet = 10;
  str += "внутри блока: xvar=" + xvar + ", xlet="+xlet;
 }
alert (str + '\n'+
   "снаружи  xvar=" + xvar + ", xlet="+xlet);
```
Переменная let видна только после объявления.

Переменные var существуют и до объявления. Они равны undefined:
```
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<10; i++) {  }
for(let i = 0; i<10; i++) {  }
alert( i ); // ошибка: глобальной i нет
```
При объявлении внутри цикла переменная i будет видна только в блоке цикла. Она не видна снаружи.
При использовании в цикле, для каждой итерации создаётся своя переменная.

Переменная var – одна на все итерации цикла и видна даже после цикла:
```
for(var i=0; i<10; i++) { /* … */ }
alert(i); // 10
```
С переменной let – всё по-другому.

Каждому повторению цикла соответствует своя независимая переменная let. Если внутри цикла есть вложенные объявления функций, то в замыкании каждой будет та переменная, которая была при соответствующей итерации.

Совместимость с браузерами


41	11	44	10	17

return

Возвратить результат работы функции

Синтаксис

return [expression]

Параметры

expression: Результат для возврата. Если отсутствует - возвращается undefined

Примеры

function square(x) {
   return x * x;
}
alert(square(16));

switch

Сравнивает значение выражения с различными вариантами и при совпадении выполняет соответствующий код

Синтаксис

switch (expression) {
   case label1:
      statements1
      [break]
   case label2:
      statements2
      [break]
   ...
   case labelN:
      statementsN
      [break]
   default:
      statements_def
      [break]
}

Параметры

expression: Выражение для сравнения
labelN: Значение, с которым сравнивать
statementsN: Ветка кода, на которую перейдет управление при совпадении expression с labelN
statements_def: Ветка кода, которая будет выполнена, если expression не совпадет ни с одним значением labelN

Описание, примеры

Конструкция switch служит для сравнения значения на равенство с различными вариантами.

При этом равенство подразумевается в смысле оператора "===", сравнивать с регулярным выражением или как-то еще switch не умеет.

Если совпадение найдено, то соответствующий код исполняется до оператора break, который прекращает выполнение switch и передает управление дальше.

Пример: обычное применение switch

var a = 2+2
switch (a) {
  case 3:
    alert('Маловато')
    break
  case 4:
    alert('В точку!')
    break
  case 5:
    alert('Перебор')
    break
  default:
    alert('Я таких значений не знаю')
}

Если оператор break отсутствует, то выполнение продолжается дальше.

Например, предыдущий пример без break:

var a = 2+2
switch (a) {
  case 3:
    alert('Маловато')
  case 4:
    alert('В точку!')
  case 5:
    alert('Перебор')
  default:
    alert('Я таких значений не знаю')
}

При a=4 последовательно будут выполнены операторы:

alert('В точку!')

alert('Перебор')

alert('Я таких значений не знаю')

Несколько значений case можно группировать.

Пример: группировка case

var a = 2+2
switch (a) {
  case 4:
    alert('Верно!')
    break
  case 3:
  case 5:
    alert('Неверно!')
    break
  default:
    alert('Я таких значений не знаю')
}

throw

Инициировать ("бросить") исключение

Синтаксис

throw expression

Параметры

expression: Любое выражение. Результат вычисления expression будет брошен как исключение

Описание, примеры

Используйте throw для генерации исключения, аналогично Java/PHP и другим языкам.

В отличие от них, javascript позволяет бросать исключение любого формата:

throw "Ошибка!"
throw 12
throw true
throw { 
  message: "Ошибка доступа",
  code: 403
}

Удобным соглашением является выбор для исключения объекта Error или его наследника.

function toInt(value) {
  var intVal = +value
  if (isNaN(intVal)) {
    **throw new Error("Неправильный формат данных: "+value)**
  }
}

Пример: используем toInt

function toInt(value) {
  var intVal = +value
  if (isNaN(intVal)) {
    throw new Error("Неправильный формат данных: "+value)
  }
}

try {
  var i = "something"
  i = toInt(i)
} catch(e) {
  alert(e.message)
}

try..catch

Ловить все исключения, выпадающие из блока кода

Синтаксис

try {
     try_statements
    }
[catch (exception_var) {
     catch_statements
     }]
[finally {
    finally_statements
     }]

Параметры

try_statements: Код для выполнения и контроля над генерируемыми им исключениями
catch_statements: Все исключения будут попадать в блок catch_statements
exception_var: Переменная, которой присваивается пойманное исключение
finally_statements: Блок finally_statements будет выполнен после окончания работы try/catch, вне зависимости от того, было ли сгенерировано исключение

Описание, примеры

Конструкция try..catch в javascript представлена в своей полной форме, включая необязательную ветку finally.

Допускается использование всех трех форм:

try...catch
try...finally
try...catch...finally

В любом случае сначала выполняется код блока try. Затем, если было исключение - оно перехватывается и выполняется код из catch. Затем, вне зависимости от работы try/catch, перед выходом из конструкции выполняется блок finally.

Пример: tryEval

function tryEval(code) {
  try{
    eval(code)
  } catch(e) {
    alert(e.name)
  } finally {
    alert("finished")
  }
}

Запустим функцию tryEval с некорректным кодом.

При этом eval бросит исключение класса SyntaxError, что приведет к переходу управления в catch.

По окончанию catch выполнится finally.

Пример ниже, как предполагается, выведет всплывающее окно "Добро пожаловать гость!" при нажатии кнопки мыши. Однако, есть опечатка в функции message(). alert() напечатано как adddlert(). Возникает ошибка JavaScript. Блок catch перехватывает ошибку и выполняет дополнительный код для ее обработки. Код отображает пользовательское сообщение об ошибке, информирующее пользователя, что произошло:

<script>
var txt="";
function message()
 { try  { adddlert("Добро пожаловать гость!"); }
   catch(err)
    { txt="На этой странице произошла ошибка.\n\n";
      txt+="Описание ошибки: " + err.description + "\n\n";
      txt+="Нажмите OK, чтобы продолжить.\n\n";
      alert(txt);
    }
  }
</script>
<input type="button" value="Просмотр сообщение" onclick="message()" />

Следующий пример использует окно подтверждения, чтобы показать пользовательское сообщение, говорящее пользователям, что они могут нажать OK, чтобы продолжить, или нажать Отмена, чтобы перейти на главную страницу. Если метод возвращает false, пользователь нажал Отмена, и код перенаправляет пользователя. Если же метод возвращает true, код ничего не делает:

<script>
var txt="";
function message()
 { try { adddlert("Добро пожаловать гость!"); }
   catch(err)
    { txt="На этой странице произошла оишбка.\n\n";
      txt+="Нажмите OK, чтобы продолжить просмотр этой страницы,\n";
      txt+="или Отмена, чтобы вернуться на главную страницу.\n\n";
      if(!confirm(txt))
        { document.location.href="http://anekdotov.net/";}
     }
 }
</script>
<input type="button" value="Просмотр сообщение" onclick="message()" />

var

Объявить переменную (или несколько) в текущей области видимости

Синтаксис

var varname1 [= value1 [, varname2 [, varname3 ... [, varnameN]]]];

Параметры

varnameN: Имя для переменной
valueN: Начальное значение переменной, любое выражение

Описание, примеры

Область видимости переменной - текущая функция. Если переменная объявлена вне функции, то ее область видимости - глобальный объект window.

Использовать var вне функций не обязательно; Вы можете объявить переменную, просто присвоив ей значение. Однако хорошим стилем будет использование var, который необходим в функциях при следующих обстоятельствах:

Если имеется глобальная переменная с тем же именем.
Если при рекурсии (или несколькими функциями) используются переменные с тем же именем.

Здесь javascript похож на традиционные языки программирования

var a = 5
function go() {
  var a = 6
}

go()  // значение внешней переменной a не меняется

В отличие от большинства языков, javascript блок не задает область видимости.

var i = 5
{
  var i
  i = 6
}
alert(i) // значение i поменялось

Переменная внешней функции видна во внутренней, благодаря наличию замыканий.

while

Задает цикл, который выполняется до тех пор, пока условие верно. Условие проверяется перед каждой итерацией.

Синтаксис

while (condition)
  statement

Параметры

condition: Условие цикла
statement: Блок или javascript-вызов для выполнения во время итераций

Примеры

Следующий цикл будет повторяться до тех пор, пока n меньше трех.

n = 0
x = 0
while (n < 3) {
  n ++
  x += n
  alert("n="+n+", x="+x)
}

При каждой итерации цикл увеличивает n и прибавляет к x. Переменные x и n последовательно принимают значения:

n = 1, x = 1
n = 2, x = 3
n = 3, x = 6

После окончания третьего прохода, условие n < 3 более не верно, поэтому цикл завершается.

with

Добавить новую область видимости

Синтаксис

with (object)
  statement

Параметры

object: Добавить указанный объект в цепочку областей видимости. Может быть любое выражение, скобки вокруг обязательны.
statement: Блок или javascript-вызов для выполнения внутри дополненной области видимости

Описание, примеры

В следующем примере вычисления выполняются с областью видимости, расширенной объектом Math.

var a, x, y;
var r = 10;
with (Math) {
  a = PI * r * r;
  x = r * cos(PI);
  y = r * sin(PI / 2);
}

Более частый пример:

with(element.style) {
    position = 'relative'
    top = left = '5px'
}

При поиске переменной внутри with, интерпретатор сначала проверяет свойства object. Если свойства с таким именем нет - он идет дальше вверх по областям видимости.

Использование with с одной стороны наглядно, с другой - может скрывать ошибки программирования и соответствующий код плохо сжимается компрессорами.

По этим причинам использовать with не рекомендуется.

Вместо этого можно использовать чуть менее наглядный, но надежный доступ через временную переменную:

s = element.style
s.position = 'relative'
s.top = s.left = '5px'

Блок

Группировка javascript-вызовов внутри фигурных скобок

Синтаксис

{
   statement_1
   statement_2
   ...
   statement_n
}

Параметры

statement_1, statement_2, ..., statement_n: Вызовы внутри блока

Описание, комментарии, примеры

Как правило, используется в управляющих операторах (for, while и т.п.).

while (x < 10) {
   x++
}

Блок не задает область видимости

Это важная особенность языка javascript, по сравнению с C, Java и многими другими языками.

Переменные, объявленные внутри блока, видны в содержащей их функции или во всем скрипте, если такой функции нет.

Изменение переменной внутри блока также видно за его пределами.

Поэтому, хотя отдельные блоки и являются корректными с точки зрения языка, но в javascript их никто не использует.

var x = 1;
{
   var x = 2;
}
alert(x); // выведет 2

Пример выводит 2, так как вызов var x внутри блока использует переменную x, объявленную до блока.

В C или Java этот пример вывел бы 1.