Javascript оператор try: 🤷🏽‍♀️ Page not found | MDN Web Docs

Порядок выполнения и обработка ошибок — JavaScript

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

Более подробная информация об инструкциях, рассмотренных в данной главе, содержится в справочнике по JavaScript. Точка с запятой ( ; ) используется для разделения инструкций в коде.

Любое выражение (expression) в JavaScript является также инструкцией (statement). Чтобы получить более подробную информацию о выражениях, прочитайте Выражения и операторы.

Инструкция block является фундаментальной и используется для группировки других инструкций. Блок ограничивается фигурными скобками:

{ statement_1; statement_2; ... statement_n; }

Блок обычно используется с управляющими инструкциями (например, if, for, while).

В вышеприведённом примере { x++; } является блоком.

Обратите внимание: в JavaScript отсутствует область видимости блока до ECMAScript2015. Переменные, объявленные внутри блока, имеют область видимости функции (или скрипта), в которой находится данный блок, вследствие чего они сохранят свои значения при выходе за пределы блока. Другими словами, блок не создаёт новую область видимости. «Автономные» (standalone) блоки в JavaScript могут продуцировать полностью отличающийся результат, от результата в языках C или Java. Например:

var x = 1;
{
  var x = 2;
}
console.log(x); 

В вышеприведённом примере инструкция var x внутри блока находится в той же области видимости, что и инструкция var x перед блоком. В C или Java эквивалентный код выведет значение 1.

Начиная с ECMAScript 6, оператор let позволяет объявить переменную в области видимости блока. Чтобы получить более подробную информацию, прочитайте let.

Условная инструкция — это набор команд, которые выполняются, если указанное условие является истинным. JavaScript поддерживает две условные инструкции: if...else и switch.

Инструкция if…else

Используйте оператор if для выполнения инструкции, если логическое условия истинно. Используйте опциональный else, для выполнения инструкции, если условие ложно. Оператор if выглядит так:

if (condition) {
    statement_1;
} else {
    statement_2;
}

  Здесь condition может быть любым выражением, вычисляемым как истинное (true) или ложное (false). Чтобы получить более подробную информацию о значениях true и false, прочитайте Boolean. Если условие оценивается как true, то выполняется statement_1, в противном случае — statement_2. Блоки statement_1 и statement_2 могут быть любыми блоками, включая также вложенные инструкции if.

Также вы можете объединить несколько инструкций, пользуясь else if для получения последовательности проверок условий:

if (condition_1) { statement_1;} else if (condition_2) { statement_2;} else if (condition_n) { statement_n; } else { statement_last;}

В случае нескольких условий только первое логическое условие, которое вычислится истинным (true), будет выполнено. Используйте блок ( { ... } ) для группировки нескольких инструкций. Применение блоков является хорошей практикой, особенно когда используются вложенные инструкции if:

if (condition) {
  statement_1_runs_if_condition_is_true;
  statement_2_runs_if_condition_is_true;
} else {
  statement_3_runs_if_condition_is_false;
  statement_4_runs_if_condition_is_false;
}

Нежелательно использовать простые присваивания в условном выражении, т.к. присваивание может быть спутано с равенством при быстром просмотре кода. Например, не используйте следующий код:

Если вам нужно использовать присваивание в условном выражении, то распространённой практикой является заключение операции присваивания в дополнительные скобки. Например:

Ложные значения

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

• false
• undefined
• null
• 0
• NaN
• пустая строка ( "" )

Все остальные значения, включая все объекты, будут восприняты как истина при передаче в условное выражение.

Не путайте примитивные логические значения true и false со значениями true и false объекта Boolean. Например:

var b = new Boolean(false);
if (b) 
if (b == true) 

В следующем примере функция checkData возвращает true, если число символов в объекте Text равно трём; в противном случае функция отображает окно alert и возвращает false.

function checkData() {
  if (document.form1.threeChar.value.length == 3) {
    return true;
  } else {
    alert("Enter exactly three characters. " +
    document.form1.threeChar.value + " is not valid.");
    return false;
  }
}

Инструкция switch

Инструкция switch позволяет сравнить значение выражения с различными вариантами и при совпадении выполнить соответствующий код. Инструкция имеет следующий вид:

switch (expression) {
   case label_1:
      statements_1
      [break;]
   case label_2:
      statements_2
      [break;]
   . ..
   default:
      statements_default
      [break;]
}

Сначала производится поиск ветви case с меткой label, совпадающей со значением выражения expression. Если совпадение найдено, то соответствующий данной ветви код выполняется до оператора break, который прекращает выполнение switch и передаёт управление дальше. В противном случае управление передаётся необязательной ветви default и выполняется соответствующий ей код. Если ветвь default не найдена, то программа продолжит выполняться со строчки, следующей за инструкцией switch. По соглашению ветвь default является последней ветвью, но следовать этому соглашению необязательно.

Если оператор break отсутствует, то после выполнения кода, который соответствует выбранной ветви, начнётся выполнение кода, который следует за ней.

В следующем примере если fruittype имеет значение "Bananas", то будет выведено сообщение "Bananas are $0. 48 a pound." и оператор break прекратит выполнение switch. Если бы оператор break отсутствовал, то был бы также выполнен код, соответствующий ветви "Cherries", т.е. выведено сообщение "Cherries are $3.00 a pound.".

switch (fruittype) {
  case "Oranges":
    console.log("Oranges are $0.59 a pound.");
    break;
  case "Apples":
    console.log("Apples are $0.32 a pound.");
    break;
  case "Bananas":
    console.log("Bananas are $0.48 a pound.");
    break;
  case "Cherries":
    console.log("Cherries are $3.00 a pound.");
    break;
  case "Mangoes":
    console.log("Mangoes are $0.56 a pound.");
    break;
  case "Papayas":
    console.log("Mangoes and papayas are $2.79 a pound.");
    break;
  default:
   console.log("Sorry, we are out of " + fruittype + ".");
}
console.log("Is there anything else you'd like?");

Инструкция throw используется, чтобы выбросить исключение, а инструкция try. ..catch, чтобы его обработать.

Типы исключений

Практически любой объект может быть выброшен как исключение. Тем не менее, не все выброшенные объекты создаются равными. Обычно числа или строки выбрасываются как исключения, но часто более эффективным является использование одного из типов исключений, специально созданных для этой цели:

Инструкция throw

Используйте инструкцию throw, чтобы выбросить исключение. При выбросе исключения нужно указать выражение, содержащее значение, которое будет выброшено:

throw expression;

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

throw "Error2";                                              
throw 42;                                                    
throw true;                                                  
throw { toString: function() { return "I'm an object!"; } }; 

Примечание: Вы можете выбросить объект как исключение. Вы можете обращаться к свойствам данного объекта в блоке catch.

В следующем примере объект UserException выбрасывается как исключение:

function UserException (message) {
  this.message = message;
  this.name = "UserException";
}

UserException.prototype.toString = function () {
  return this.name + ': "' + this.message + '"';
}

throw new UserException("Value too high");

Инструкция try…catch

Инструкция try...catch состоит из блока try, который содержит одну или несколько инструкций, и блок catch, которые содержит инструкции, определяющие порядок действий при выбросе исключения в блоке try. Иными словами, если в блоке try будет выброшено исключение, то управление будет передано в блок catch. Если в блоке try не возникнет исключений, то блок catch будет пропущен. Блок finally будет выполнен после окончания работы блоков try и catch, вне зависимости от того, было ли выброшено исключение.

В следующем примере вызывается функция getMonthName, которая возвращает название месяца по его номеру. Если месяца с указанным номером не существует, то функция выбросит исключение "InvalidMonthNo", которое будет перехвачено в блоке catch:

function getMonthName(mo) {
  mo = mo - 1; 
  var months = ["Jan","Feb","Mar","Apr","May","Jun","Jul",
                "Aug","Sep","Oct","Nov","Dec"];
  if (months[mo]) {
    return months[mo];
  } else {
    throw "InvalidMonthNo"; 
  }
}

try { 
  monthName = getMonthName(myMonth); 
}
catch (e) {
  monthName = "unknown";
  logMyErrors(e); 
}

Блок

catch

Используйте блок catch, чтобы обработать исключения, сгенерированные в блоке try.

catch (catchID) { statements }

JavaScript создаёт идентификатор catchID, которому присваивается перехваченное исключение, при входе в блок catch; данный идентификатор доступен только в пределах блока catch и уничтожается при выходе из него.

В следующем примере выбрасывается исключение, которое перехватывается в блоке catch:

try {
  throw "myException"
} catch (e) {
  console.error(e);
}

Блок

finally

Блок finally содержит код, который будет выполнен после окончания работы блоков try и catch, но до того, как будет выполнен код, который следует за инструкцией try...catch. Блок finally выполняется вне зависимости от того, было ли выброшено исключение. Блок finally выполняется даже в том случае, если исключение не перехватывается в блоке catch.

В следующем примере открывается файл, затем в блоке try происходит вызов функции writeMyFile, который может выбросить исключение. Если возникает исключение, то оно обрабатывается в блоке catch. В любом случае файл будет закрыт функцией closeMyFile, вызов которой находится в блоке finally.

openMyFile();
try {
  writeMyFile(theData);
} catch(e) {
  handleError(e);
} finally {
  closeMyFile();
}

Если блок finally возвращает значение, то данное значение становится возвращаемым значением всей связки try-catch-finally. Значения, возвращаемые блоками try и catch, будут проигнорированы.

function f() {
  try {
    console.log(0);
    throw "bogus";
  } catch(e) {
    console.log(1);
    return true;    
    console.log(2); 
  } finally {
    console.log(3);
    return false;   
    console.log(4); 
  }
  
  console.log(5);  
}
f();               

Замена возвращаемых значений блоком finally распространяется в том числе и на исключения, которые выбрасываются или перевыбрасываются в блоке catch:

function f() {
  try {
    throw "bogus";
  } catch(e) {
    console.log('caught inner "bogus"');
    throw e;      
  } finally {
    return false; 
  }
  
}

try {
  f();
} catch(e) {
  
  console. log('caught outer "bogus"');
}

Вложенные инструкции 

try...catch

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

Использование объекта Error

В зависимости от типа ошибки вы можете использовать свойства name и message, чтобы получить более подробную информацию. Свойство name содержит название ошибки (например, DOMException или Error), свойство message — описание ошибки.

Если вы выбрасываете собственные исключения, то чтобы получить преимущество, которое предоставляют эти свойства (например, если ваш блок catch не делает различий между вашими исключениями и системными), используйте конструктор Error. Например:

function doSomethingErrorProne () {
  if ( ourCodeMakesAMistake() ) {
    throw ( new Error('The message') );
  } else {
    doSomethingToGetAJavascriptError();
  }
}

try {
  doSomethingErrorProne();
} catch (e) {
  console.log(e.name);    
  console.log(e.message); 
}

Начиная с ECMAScript2015, JavaScript поддерживает объект Promise, который используется для отложенных и асинхронных операций.

Объект Promise может находиться в следующих состояниях:

• ожидание (pending): начальное состояние, не выполнено и не отклонено.
• выполнено (fulfilled): операция завершена успешно.
• отклонено (rejected): операция завершена с ошибкой.
• заданный (settled): промис выполнен или отклонен, но не находится в состоянии ожидания.

Загрузка изображения при помощи XHR

Простой пример использования объектов Promise и XMLHttpRequest для загрузки изображения доступен в репозитории MDN promise-test на GitHub. Вы также можете посмотреть его в действии. Каждый шаг прокомментирован, что позволяет вам разобраться в архитектуре Promise и XHR. Здесь приводится версия без комментариев:

function imgLoad(url) {
  return new Promise(function(resolve, reject) {
    var request = new XMLHttpRequest();
    request.open('GET', url);
    request.responseType = 'blob';
    request.onload = function() {
      if (request.status === 200) {
        resolve(request.response);
      } else {
        reject(Error('Image didn\'t load successfully; error code:'
                     + request.statusText));
      }
    };
    request.onerror = function() {
      reject(Error('There was a network error.'));
    };
    request.send();
  });
}

Блоки try/catch/finally, оператор throw, проброс исключений

В практически любой
язык программирования, в том числе и JavaScript, имеет
специальную конструкцию:

try/catch/finally

позволяющую
«ловить» ошибки во время выполнения программы и предпринимать определенные
действия (обрабатывать эти ошибки). Общая идея работы этого блока заключается в
том, что мы помещаем в блок try потенциально уязвимый скрипт:

let res = 0;
try {
         res = 5/d; 
         console.log(res);
}
catch(error) {
         console.log(error);
}

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

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

Если же в блоке try ошибок не
возникло, то блок catch пропускается и не выполняется:

let res = 0;
try {
         let d = 2;
         res = 5/d;
         console. log(res);
}
catch(error) {
         console.log(error);
}

Но, обратите
внимание, блок try выполняется в синхронном режиме, то есть, например,
если в него поместить вот такой асинхронный вызов функции:

let res = 0;
try {
         setTimeout(function() {
                   res = 5/d;
                   console.log(res);
         }, 0);
}
catch(error) {
         console.log(error);
}

То ошибка
обработана не будет, т.к. анонимная функция внутри setTimeout выполняется уже
после выполнения блока try. То есть, блок try сначала
полностью выполнится, а затем, будет запущена анонимная функция. В такой
ситуации блок try/catch следует
поместить внутрь анонимной функции:

let res = 0;
setTimeout(function() {
         try {
                   res = 5/d;
                   console.log(res);
         }
         catch(error) {
                   console.log(error);
         }
}, 0);

Свойства объекта ошибки

В языке JavaScript объект ошибки
блока catch имеет три
полезных атрибута:

• 
  name
  – содержит
  название ошибки;
  
• 
  message
  – содержит
  текст ошибки;
  
• 
  stack – стек вызова
  до возникновения ошибки (нестандартное свойство).

Например, мы
можем вывести эти атрибуты в консоль, следующим образом:

let res = 0;
try {
         d = 2;
         res = 5/d;
         console.log(res);
}
catch(error) {
         console.log(error.name);
         console.log(error.message);
         console.log(error.stack);
}

Блок finally

При обработке
ошибок часто используется еще один необязательный блок finally, который
выполняется в любом случае: возникли ошибки или нет, причем, в последнюю
очередь. Зачем он может понадобиться? Например, чтобы выполнить некоторые
обязательные действия после завершения соединения с сервером:

Мы здесь
определяем некоторый флаг (flSend) для определения выполнения
текущего запроса и если он установлен в true, то запрос
второй раз отправляться не будет. Соответственно, потом, после успешной или
ошибочной обработки, этот флаг обязательно нужно вернуть в значение false. Как раз это и
делается в блоке finally.

Генерация собственных исключений – throw

JavaScript позволяет
генерировать свои собственные исключения с помощью оператора

throw
<объект
ошибки>

В качестве
объекта ошибки может быть и число и строка или еще какой-либо примитив и
объект, но лучше использовать стандартные классы ошибок, например:

• 
  Error
  – для
  общих ошибок;
  
• 
  SyntaxError
  – для синтаксических ошибок;
  
• 
  TypeError
  – для ошибок типов данных;
  
• 
  ReferenceError – ссылка на
  несуществующую переменную

и так далее. Чтобы
воспользоваться этими классами, достаточно создать соответствующий объект:

let err1 = new Error("Ошибка выполнения");
let err2 = new SyntaxError("Ошибка синтаксиса");
let err3 = new TypeError("Ошибка типов данных");

и указать после
оператора throw:

throw err1;
throw new SyntaxError("Ошибка синтаксиса");

Например,
зададим функцию деления двух чисел, которая генерирует исключение, если
знаменатель равен нулю:

function divide(a, b) {
         if( b == 0 ) {
                   throw new Error("Деление на ноль");
         }
 
         return a/b;
}

И, далее,
вызываем ее в блоке try:

let res = 0;
try {
         res = divide(1, 0);
         console. log(res);
}
catch(error) {
         console.log(error.name);
         console.log(error.message);
}

В консоли увидим
строчки:

Error, Деление на
ноль

То есть,
свойство name ссылается на
имя конструктора объекта ошибки, а message – на аргумент
этого объекта.

Проброс исключений

В нашей
последней реализации блок catch отлавливает все исключения в блоке try. Но, что если
мы хотим отслеживать лишь определенный их тип, например, Error, а остальные не
трогать – пересылать дальше – блокам try более высокого уровня:

Это и называется
пробросом исключения. Для его реализации нам достаточно проверить во внутреннем
блоке catch тип ошибки и,
если она не соответствует Error, то передать дальше:

// let res = 0;
try {
         res = divide(1, 2);
         console.log(res);
}
catch(error) {
         if(error. name == "Error") {
                   console.log(error.name);
                   console.log(error.message);
         }
         else {
                   throw error;
         }
}

Соответственно,
внутри будет обрабатывать только исключения Error, а остальные
пробрасывать блокам более высокого уровня.

Урок 12 по JScript — конструкция try catch

Всем привет, с вами автор блога scriptcoding.ru. В данной статье рассматривается конструкция try catch языка программирования JSCRIPT, конструкция try catch js отвечает за обработку исключительных ситуаций.

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

TRY CATCH состоит из трёх ключевых слов: try, catch и finally, между которыми прописываются фигурные скобки, содержащие тот или иной блок кода. Блок содержит программный код, в котором, может возникнуть ошибка, например: выражение, в котором может возникнуть деление на ноль; строка кода, которая производит чтение диска или папки. Если исключение не возникает, то блок try{…} никак не повлияет на работу сценария. Блок catch{…} оператора try catch js будет выполнен в том случае, если возникло исключение — тут идёт обработка номера ошибки и вывод нужных операторов. Блок finally{..} содержит так называемый код зачистки, то есть, он гарантированно выполняется независимо от того, что происходит в try{…}.

TRY … CATCH JS – обработка исключительных ситуаций

Давайте посмотрим на общий синтаксис try catch js:

try {

В большинстве случаев данный код работает без сбоев. Но, в определенный момент в нем может возникнуть сбой, либо вызванный инструкцией throw, либо через выполнение программного кода, который и вызывает сбой.

}catch (e) {

Данная часть выполняется только в случае возникновения сбоя, тут переменная e является ссылкой на объект Error или на другое значение, указанное в инструкции throw (смотрите ниже).

}finally {

Данная часть содержит инструкции, которые выполняются всегда, независимо от того, что произошло в блоке try{}.

}

Хорошо, давайте рассмотри следующий программный код:

// ***********************************************************
// try catch js
// try_cath.js
// ***********************************************************
 
var i=0, msg="", e;
 
// Объявляем функцию my_fun
var my_fun = function(x,y){return x +y;}
 
// Объявляем объект my_obj
var my_obj = {a:10, b:100};
 
// Объявляем массив my_arr из 6 элементов!
var my_arr=[2,7.5,0,"abc", my_fun, my_obj];
 
while (i <= 10) {
var res;
//Сбой не возникнет!!!!
     try{
                 res=15/my_arr[i];
     }catch(e){
                 if (e!=0){
                            msg="Сбой!!!\n" + "Код: " + e.number +"\nОписание: " + e.description;
                            WScript.echo (msg);
                 }
     }finally{       
     i++;
     msg+=res + "\n";
     }
}
WScript.echo ("Результат деления \n" + msg);

И так, в данном примере мы создали массив my_arr, который хранит в себе 6 элементов:

• 2 – целое число.
• 7.5 – дробное число.
• 0 — ноль.
• «abc» — строка.
• my_fun — функция.
• my_obj — объект.

В цикле while (смотрите статью «Урок 10 по JScript: Цикл while и do…while») происходит последовательное деление числа 15 на каждый элемент массива, хотя число элементов 6, но, я специально прописал в цикле значение 10. По логике работы, при делении на ноль, строку, функцию, объект и несуществующий индекс массива, оператор try catch js должен бы был генерировать ошибку в catch{}, но, как не странно, это не происходит, на выходе мы получим значения:

7.5, 2, Infinity, NaN, …, NaN.

Разгадка кроется в самом языке JScript, дело в том, что в нём определены типы данных NaN – не число и infinity – бесконечность (смотрите статью «Урок 2 по JScript: Объявление переменных»). Что бы явно указать, что в try{} оператора try catch возникает сбой, нужно использовать инструкцию throw, работу с ней я рассмотрел в статье «JScript: оператор throw».

Хорошо, теперь давайте рассмотри сценарий, который уже точно позволит генерировать ошибку:

// ***********************************************************
// js try catch
// 1_try_catch.js
// ***********************************************************
 
//Объявляем переменные 
var FSO, Folder, Files, s="";     
 
//Создаем объект FileSystemObject
FSO=WScript.CreateObject("Scripting.FileSystemObject");
 
//Создаем объект Folder для каталога Windows диска D: 
try{
     Folder=FSO.GetFolder("D:\\Windows\\");  //Используем ESC-последовательность "\\" для символа "\"
}catch(e){
     if (e!=0){
                 msg="Сбой!!!\n" + "Код: " + e.number +"\nОписание: " + e.description;
                 WScript.echo (msg);
                 //Выход из сценария
                 WScript.Quit();
 
     }
}finally{            
     //Создаем коллекцию файлов                                                                                                                                                                                                                                                                                                                                                                                                                                                           try catch js
     Files=new Enumerator(Folder.Files);
     //Цикл по всем файлам  
     for (; !Files.atEnd(); Files.moveNext()) {  
                 s+=Files.item().Name+"\n";
     }        
     //Выводим полученный список файлов на экран
     WScript.echo(s);    
}

Давайте рассмотрим данный пример, тут происходит обращение к каталогу Windows, который находится на диске D, если такого каталога не существует, то возникнет сбой программного кода и произойдёт вывод сообщения, которое будет содержать код ошибки (e.number) и её описание (e.description), далее наступит выход из сценария (WScript.Quit()). Как мы помним, код в finally{} выполняется независимо от того, была исключительная ситуация или нет, поэтому, если не прописать строку WScript.Quit(), то сценарий выведет сообщение об исключительной ситуации, а далее последует получение списка файлов, что тоже приведет к ошибке. Обратите внимание, что тут мы использовали такие внешние объекты сервера Windows Script Host как Folder – для работы с папками и FileSystemObject – работа с файловой системой, а также внутренний класс языка jscript – Enumerator.

Скачать архив с примерами

И так, давайте подведём итоги, в этой статье мы рассмотрели работу с конструкцией TRY … CATH, которая отвечает за обработку исключительных ситуаций в программном коде на языке JSCRIPT.

попробуйте … поймать — JavaScript | MDN

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

  try {
  try_statements
}
catch (exception_var) {
  catch_statements
}
наконец-то {
  finally_statements
}
  

try_statements

Операторы, которые необходимо выполнить.

catch_statements

Оператор, который выполняется, если в блоке try возникает исключение.

исключение_вар

Необязательный идентификатор для хранения объекта исключения для связанного
защелка — блок.

finally_statements

Операторы, которые выполняются после завершения оператора try . Эти
операторы выполняются независимо от того, было ли исключение выброшено или перехвачено.

Оператор try состоит из try -блока, который содержит один
или более заявлений. {} необходимо использовать всегда, даже для отдельных операторов. В
Должен присутствовать хотя бы один блок захвата , или , наконец, блок .
Это дает нам три формы для оператора try :

• попробовать ... поймать
• попробовать ... наконец
• попробовать ... поймать ... наконец

catch -block содержит инструкции, которые указывают, что делать в случае исключения
добавляется в блок try .Если какое-либо заявление в
try -block (или в функции, вызываемой из try -block)
генерирует исключение, управление немедленно переходит к блоку catch . Если
в блоке try исключений не возникает, блок catch
пропущено.

finally -block всегда будет выполняться после try -block и
catch — блок (ы) завершили выполнение. Он выполняется всегда, независимо от
было ли выброшено или перехвачено исключение.

Вы можете вложить один или несколько операторов try . Если внутренний попробуйте
оператор не имеет catch -блок, включающий пытается
Вместо этого используется блок catch оператора.

Вы также можете использовать оператор try для обработки исключений JavaScript. Видеть
Руководство по JavaScript для получения дополнительной информации
об исключениях JavaScript.

Безусловный блок захвата

Когда используется блок захвата , блок захвата выполняется, когда
любое исключение генерируется из блока try .Например, когда
исключение происходит в следующем коде, управление передается
защелка - блок.

  try {
  throw 'myException';
} catch (e) {
  
  logMyErrors (e);
}
  

  try {
  мои повседневные обязанности();
} catch (e) {
  if (e instanceof TypeError) {
    
  } else if (e instanceof RangeError) {
    
  } else if (e instanceof EvalError) {
    
  } еще {
    
    logMyErrors (e);
  }
}
  

  try {
  мои повседневные обязанности();
} catch (e) {
  if (e instanceof RangeError) {
    
  } еще {
    бросить е;
  }
}
  

  function isValidJSON (text) {
  пытаться {
    JSON.parse (текст);
    вернуть истину;
  } ловить {
    вернуть ложь;
  }
}
  

  openMyFile ();
пытаться {
  
  writeMyFile (данные);
} наконец-то {
  closeMyFile ();
}
  

  try {
  пытаться {
    выбросить новую ошибку ('упс');
  } наконец-то {
    console.log ('наконец');
  }
} catch (ex) {
  console.error ('внешний', например, сообщение);
}




  

  try {
  пытаться {
    выбросить новую ошибку ('упс');
  } catch (ex) {
    приставка.ошибка ('внутренняя', например, сообщение);
  } наконец-то {
    console.log ('наконец');
  }
} catch (ex) {
  console.error ('внешний', например, сообщение);
}




  

  try {
  пытаться {
    выбросить новую ошибку ('упс');
  } catch (ex) {
    console.error ('внутренний', например, сообщение);
    бросить экс;
  } наконец-то {
    console.log ('наконец');
  }
} catch (ex) {
  console.error ('внешний', например, сообщение);
}





  

  (функция () {
  пытаться {
    пытаться {
      выбросить новую ошибку ('упс');
    } catch (ex) {
      приставка.ошибка ('внутренняя', например, сообщение);
      бросить экс;
    } наконец-то {
      console.log ('наконец');
      возвращаться;
    }
  } catch (ex) {
    console.error ('внешний', например, сообщение);
  }
}) ();



  

  функция readProfiles (filePaths) {
  константные профили = [];
  for (const filePath of filePaths) {
    пытаться {
      константный профиль = readOneProfile (filePath);
      профили.толкать (профиль);
    } catch (err) {// (A)
      console.log ('Ошибка в:' + filePath, err);
    }
  }
}
function readOneProfile (filePath) {
  const profile = новый профиль ();
  const file = openFile (путь к файлу);
  // ··· (Считываем данные из файла в профиль)
  возвратный профиль;
}
function openFile (filePath) {
  if (! fs.existsSync (filePath)) {
    выдать новую ошибку ('Не удалось найти файл' + filePath); // (B)
  }
  // ··· (Открыть файл, путь которого - `filePath`)
}  

  прочитанных профилей (···)
  for (const filePath из filePaths)
    пытаться
      readOneProfile (···)
        открыть файл(···)
          если (! fs.существуетSync (filePath))
            бросить  

  выдать новую ошибку («Проблема!»);  

  try {
  «Try_statements»
} catch (ошибка) {
  «Catch_statements»
} наконец-то {
  «Finally_statements»
}  

  const errorObject = new Error ();
function func () {
  бросить errorObject; // (А)
}

пытаться {
  func ();
} catch (err) {// (B)
  assert.equal (ошибка, errorObject);
}  

  try {
  // ···
} ловить {
  // ···
}  

  функция throws (func) {
  пытаться {
    func ();
  } ловить {
    возвращаться; // все в порядке
  }
  throw new Error («Функция не сгенерировала исключение!»);
}  

  const resource = createResource ();
пытаться {
  // Работаем с `ресурсом`.Могут быть выброшены ошибки.
} наконец-то {
  resource.destroy ();
}  

  пусть finallyWasExecuted = false;
assert.throws (
  () => {
    пытаться {
      выбросить новую ошибку (); // (А)
    } наконец-то {
      finallyWasExecuted = true;
    }
  },
  Ошибка
);
assert.equal (finallyWasExecuted, истина);  

  пусть finallyWasExecuted = false;
function func () {
  пытаться {
    возвращаться; // (А)
  } наконец-то {
    finallyWasExecuted = true;
  }
}
func ();
утверждать.равно (finallyWasExecuted, истина);  

  const err = новая ошибка («Привет!»);
утверждать.equal (String (err), 'Ошибка: Здравствуйте!');  

  консоль.log ("ввод оператора try-catch");

пытаться {
  console.log («ввод блока try»);
  бросить "брошенное сообщение";
  console.log («это сообщение никогда не видели»);
}
catch (e) {
  console.log («вход в блок catch»);
  console.log (e);
  console.log («выход из блока захвата»);
}
наконец-то {
  console.log («вход и выход из блока finally»);
}

console.log ("выход из оператора try-catch");
  

  ввод оператора try-catch
вход в блок попытки
вход в блок захвата
брошенное сообщение
выход из блока захвата
вход и выход из блока finally
оставив заявление о попытке улова
  

В основных библиотеках Node.js единственное место, где действительно нужен для использования try-catch, - это около JSON.parse () . Все остальные методы используют либо стандартный объект Error через первый параметр обратного вызова, либо генерируют событие error .Из-за этого обычно считается стандартом возвращать ошибки через обратный вызов, а не использовать оператор throw .

Пример тематического парка проверки ввода JavaScript с использованием инструкции throw

Я уверен, что вы, ребята, знакомы с обработкой ошибок JavaScript методами Try, Throw, Catch и finally.

Проще говоря,

С помощью оператора try вы можете проверить фрагмент кода на наличие ошибок.

С помощью оператора catch вы можете обрабатывать все эти ошибки определенным образом.

С помощью оператора throw вы можете создавать собственные ошибки для конкретного сценария.

И после попытки и поймать оператор finally выполнит код, несмотря ни на что.

При возникновении ошибки любого типа JavaScript выдает исключение (ошибку). Фактически это «объекты ошибок» с именем и значением или текстами для этого имени.

Оператор throw позволяет пользователю записывать настраиваемую ошибку. Например,

 
  throw "Число слишком маленькое"; // выдает текстовую ошибку

  бросить 101; // выдаем числовую ошибку
  

Теперь давайте посмотрим на наш пример проверки ввода и посмотрим, как мы можем использовать оператор throw для проверки ввода пользователем в форме.

Допустим, вы создаете систему для проверки возраста детей и их допуска в тематический парк. Допустимый возраст от 4 до 14 лет. Довольно простой пример.

В приведенном выше примере я ввел текстовое поле, в которое пользователь собирается добавить возраст. Затем у меня есть кнопка, на которую пользователь будет нажимать после ввода возраста. Я также помечен тегом h4 , чтобы отображать результаты после нажатия кнопки пользователем.

В сценарии я создал функцию, которая будет вызываться нажатием кнопки.У меня две переменные resultText и exampleVal. В «resultText» я получаю значение тега «h4» с id = «result», а в «exampleVal» я сохраняю введенные пользователем данные и проверяю их на наличие ошибок.

После этого выполняется простая проверка ошибок. Если он пуст, он попросит пользователя ввести возраст, если пользователь вводит текст или символ, он попросит ввести число, а затем, наконец, он проверит, попадает ли возраст в диапазон от 4 до 14.

Вот и все. Я надеюсь, что это поможет вам, ребята. Спасибо!

Демо

Твитнуть об этом

» Предыдущий Следующий »

Использование оператора trycatch | Внутри JavaScript

Использование оператора try catch

Когда вы заключаете серию операторов в оператор try, любая ошибка, возникающая при выполнении этих операторов, вызовет (то есть вызовет) исключение.Когда генерируется исключение, JavaScript завершает выполнение оператора try и ищет оператор catch, который «перехватывает» исключение. Если есть оператор catch, код в этом операторе catch выполняется, что позволяет вам справиться с ошибкой. Существует также необязательный оператор finally, который выполняется независимо от того, возникло ли исключение; вот синтаксис:

 try {tryStatements} [catch (exception) {catchStatements}] [finally {finallyStatements}] 

Эти операторы состоят из следующих частей:

• tryStatements.Набор операторов, который выполняется один раз. Если эти операторы вызывают исключение, выполнение переходит к оператору catch, если он есть.

• исключение. Имя переменной, которую вы хотите использовать для хранения объекта (обычно объекта Error), переданного в оператор catch.

• улов Набор операторов, выполняемых в случае возникновения исключения.

• наконец Набор операторов, который выполняется до завершения оператора try catch.Эти операторы выполняются независимо от того, было или нет исключение.

Как видно из Таблицы 3.17, оператор try catch является относительно новым.

Таблица 3.17. Заявление о пробном захвате

9882

Давайте приступим к работе с оператором try catch.

Безусловные операторы catch

При возникновении исключения выполнение переходит к оператору catch, если таковой имеется.Например, мы можем вызвать ту же ошибку, что и в нашем примере onerror, но на этот раз мы будем использовать оператор try catch. Это означает, что мы помещаем вызывающий ошибку код в оператор try и выводим сообщение «Произошла ошибка». в операторе catch, как показано ниже:

(Листинг 03-20.html на веб-сайте)

      
 Сообщение об ошибке 
    

На рисунке 3.17 показан этот код в действии.

Рисунок 3.17. Использование try catch для перехвата исключения.

Простое сообщение Произошла ошибка. однако мало что говорит пользователю. Объект, переданный нам в операторе catch, является объектом Error, и мы можем сообщить пользователю имя ошибки, используя свойство name этого объекта.Имена ошибок JavaScript: EvalError, RangeError, ReferenceError, SyntaxError, TypeError и URIError.

Подсказка

Другие объекты могут выдавать собственные типы ошибок в JavaScript. Например, объекты DOM W3C могут вызывать исключения, такие как HIERARCHY_REQUEST_ERROR, WRONG_DOCUMENT_ERROR, NO_MODIFICATION_ALLOWED_ERROR и т. Д.

В скобках после ключевого слова catch можно присвоить имя объекту Error, переданному в оператор catch; в этом примере, следуя стандартному использованию, я просто назову этот объект e:

 try {var myData = undefinedVariable} catch (e) {document.write («Произошла ошибка.»)} 

Теперь в операторе catch мы можем найти имя ошибки, возникшей с помощью свойства e.name, поэтому вот как мы сообщаем пользователю, какая ошибка произошла:

(Листинг 03-21.html на веб-сайте)

      
 Сообщение имени ошибки 
    

Вы можете увидеть эту новую, улучшенную версию этого примера в Рисунок 3.18.

Рисунок 3.18. Сообщение имени исключения.

Условные операторы перехвата

Поскольку вы можете определить тип ошибки с помощью свойства имени объекта Error, вы можете добавить код для обработки определенных типов ошибок. Вот пример, в котором я использую оператор switch для обработки различных типов исключений:

(Листинг 03-22.html на веб-сайте)

      
 Обработка определенных ошибок 
    

В этом случае я просто показываю тип возникшего исключения; однако в вашем собственном коде вы можете написать код для фактической обработки ошибки и восстановления после нее.Этот пример зависит от использования свойства name объекта Error, которое является очень полезным свойством, но обратите внимание, что объект Error также имеет другие свойства.

Как выбросить исключения в JavaScript

Ошибки выбрасывает движок, а исключения выбрасывает разработчик. Но что именно это означает? В JavaScript все исключения — это просто объекты. Хотя большинство исключений являются реализациями глобального класса Error, можно выбросить любой старый объект.Имея это в виду, есть два способа вызвать исключение: напрямую через объект Error и через настраиваемый объект.

Общие исключения

Хотя встроенный класс Error довольно хорошо определен — включая такие вещи, как имя файла, номер строки и трассировку стека, чтобы назвать несколько — когда дело доходит до него, самое важное, что нужно принять к сведению, — это сообщение. Сообщение — это первый и часто единственный параметр, передаваемый во время создания экземпляра ошибки. Это сообщение об ошибке, понятное человеку, которое часто может быть связано непосредственно с конечным пользователем.Создание общего исключения почти так же просто, как кажется. Все, что требуется, — это создать экземпляр объекта исключения — с первым параметром конструктора Error, являющимся сообщением об ошибке, — а затем… «выбросить» его.

  выдать новую ошибку («Сообщение об исключении»);  

код ошибки или сообщение об ошибке

Здесь важно отметить, что, хотя сообщение об ошибке представляет собой удобочитаемые данные об ошибке, Node.js также предоставляет код ошибки, который идентифицирует тип типа , которая возникает.Это значение полезно, поскольку оно позволяет программно адаптироваться к ошибкам, которые могут возникать независимо от сообщения, содержащегося в ошибке.

Хотя коды ошибок обычно используются для системных ошибок, при создании пользовательских ошибок путем расширения класса ошибок (см. Дополнительные сведения в разделе «Пользовательские исключения» ниже) пользовательский код может быть определен и использован для более структурированных определений ошибок.

  function CustomException (сообщение) {
  const error = new Error (сообщение);

  ошибка.code = "THIS_IS_A_CUSTOM_ERROR_CODE";
  ошибка возврата;
}

CustomException.prototype = Object.create (Error.prototype);  

Пользовательские исключения

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

  function CustomException (сообщение) {
  const error = new Error (сообщение);
  ошибка возврата;
}

CustomException.prototype = Object.create (Error.prototype);  

После создания настраиваемого объекта исключения все, что нам нужно сделать, это выбросить его, как любую другую ошибку:

  throw new CustomException («Сообщение об исключении»);  

Еще одно большое преимущество расширения объекта Error вместо генерации общей ошибки состоит в том, что дополнительные метаданные могут быть включены в ошибку и извлечены позже.Это может быть невероятно ценно при отладке и сообщении об ошибках, поскольку иногда простого текстового сообщения просто недостаточно. Например, вы можете включить значения локальных переменных или состояния, которые помогут вам отладить проблему.

  function CustomException (сообщение, метаданные) {
  const error = new Error (сообщение);
  error.metadata = метаданные;
  ошибка возврата;
}  

Помимо данных, включенных в объект Error, при использовании уведомителя Rollbar для JavaScript в отчет также включаются дополнительные данные.Это включает в себя контекстную информацию, такую ​​как браузер и пользователь.

 
пытаться {
  сделай что-нибудь();
} catch (e) {
  Rollbar.error («Что-то пошло не так», д);
}  

Запись в консоль

В JavaScript консоль — это место, где можно найти все журналы (подробнее об этом в разделе «Где регистрируются ошибки JavaScript?»). К счастью, на самом деле запись данных в консоль невероятно проста.