Рубрики
Без рубрики

Попробуйте / поймать в JavaScript – Как обрабатывать ошибки в JS

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

Ошибки и ошибки неизбежны в программировании. Мой друг звонит им Неизвестные функции :).

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

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

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

Что такое блок попробовать/ловить в JavaScript?

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

Хотя это может выглядеть как-то, что вы можете легко сделать с Если заявление Попробуйте/Catch дает вам много преимуществ, кроме того, что может сделать оператор IF/Evel, некоторые из которых вы увидите ниже.

try{
//...
}catch(e){
//...
}

Попытка заявления позволяет проверить блок кода для ошибок.

Заявление о CATH позволяет вам справиться с этой ошибкой. Например:

try{ 
getData() // getData is not defined 
}catch(e){
alert(e)
}

Это в основном, как построен попытка/поймать. Вы поместите свой код в попробуйте блок И немедленно, если есть ошибка, JavaScript дает поймать Контроль оператора, и он просто делает все, что вы говорите. В этом случае он предупреждает вас с ошибкой.

Все ошибки JavaScript на самом деле являются объектами, которые содержат два свойства: имя (например, ошибка, SyntaxError и так далее) и фактическое сообщение об ошибке. Вот почему, когда мы оповещаем е мы получаем что-то вроде Справочник: getdata не определяется Отказ

Как и любой другой объект в JavaScript, вы можете решить доступ к значениям по-разному, например, E.Name (Освещение) и E.message (GetData не определен).

Но, честно говоря, это не совсем отличается от того, что будет делать JavaScript. Хотя JavaScript будет уважать вас достаточно, чтобы зарегистрировать ошибку в консоли и не показывать предупреждение для всего мира, чтобы увидеть:).

Что тогда, это выгода попыток попробовать/ловить?

Как использовать операторы TRY/CALL

Выписка броска

Одной из преимуществ TRY/CATH – это его способность отображать собственную настроенную ошибку. Это называется (ошибка броска) Отказ

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

let num =prompt("insert a number greater than 30 but less than 40")
try { 
if(isNaN(num)) throw "Not a number (☉。☉)!" 
else if (num>40) throw "Did you even read the instructions ಠ︵ಠ, less than 40"
else if (num <= 30) throw "Greater than 30 (ب_ب)" 
}catch(e){
alert(e) 
}

Это хорошо, верно? Но мы можем сделать его еще дальше, фактически бросая ошибку с ошибками конструктора JavaScript.

В основном JavaScript классифицирует ошибки на шесть групп:

  • EvalError – Произошла ошибка в функции Eval.
  • AssiteRor – Число из диапазона произошло, например 1. Топировка (500) . TopRecision В основном дает число десятичное значение, например, 1.000, а число не может иметь 500 из этого.
  • Собственный центр – Использование переменной это не было объявлено
  • SyntaxError – При оценке кода с синтаксической ошибкой
  • Типеррр – Если вы используете значение, которое находится вне диапазона ожидаемых типов: например 1.Тупперсс ()
  • URI (единый идентификатор ресурсов) Ошибка . – Уриеррор брошен, если вы используете незаконные символы в функции URI.

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

function CustomError(message){ 
this.value ="customError";
this.message=message;
}

И вы можете легко использовать это где угодно с бросить новый CustomError («данные не определены») Отказ

До сих пор мы узнали о пробовании/CALL и о том, как он предотвращает умирание нашего сценария, но это на самом деле зависит. Давайте рассмотрим этот пример:

try{ 
console.log({{}}) 
}catch(e){ 
alert(e.message) 
} 
console.log("This should run after the logged details")

Но когда вы пробуете, даже с попыткой попробовать, он все еще не работает. Это связано с тем, что в JavaScript есть два основных типа ошибок (что я описал выше -syntaxError и так далее – на самом деле не являются типовыми ошибками. Вы можете назвать их примерами ошибок): Ошибки времени анализа и Ошибки времени выполнения или исключения Отказ

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

Например, сверху JavaScript не понимает, что вы подразумеваете под {{}} И из-за этого ваша попытка/поймать здесь не использовать (оно не будет работать).

С другой стороны, Ошибки времени выполнения Это ошибки, которые происходят в действительном коде, и это ошибки, которые пытаются/catch, наверняка найдут.

try{ 
y=x+7 
} catch(e){ 
alert("x is not defined")
} 
alert("No need to worry, try catch will handle this to prevent your code from breaking")

Поверьте, или нет, вышеприведенное является действительным кодом, и попытка/Catch будет обрабатывать ошибку соответствующим образом.

Наконец-то выписка

Наконец Заявление действует как нейтральные земли, базовая точка или окончательная земля для вашего блока попробуйте/Catch. С наконец, вы в основном говорите Независимо от того, что произойдет в Thrue/Catch (ошибка или без ошибок), этот код в окончательном операторе должен работать Отказ Например:

let data=prompt("name")
try{ 
if(data==="") throw new Error("data is empty") 
else alert(`Hi ${data} how do you do today`) 
} catch(e){ 
alert(e) 
} finally { 
alert("welcome to the try catch article")
}

Гнездо пробовать блоки

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

Вложенные вложенные блоки дают вам преимущество использования только одного оператора CABS для нескольких операторов попробуйте. Хотя вы также можете решить написать заявление о CATH для каждого блока Try Try, как это:

try { 
try { 
throw new Error('oops');
} catch(e){
console.log(e) 
} finally { 
console.log('finally'); 
} 
} catch (ex) { 
console.log('outer '+ex); 
}

В этом случае не будет никакой ошибки из внешнего блока попробовать, потому что с ним ничего не так. Ошибка исходит от внутреннего блок Try Try, и она уже заботится о себе (у него есть собственное утверждение Catch). Рассмотрим это ниже:

try { 
try { 
throw new Error('inner catch error'); 
} finally {
console.log('finally'); 
} 
} catch (ex) { 
console.log(ex);
}

Этот код выше работает немного по-другому: ошибка возникает во внутреннем блоке попробуйте без выявления CALF, а вместо этого с помощью окончательного оператора.

Обратите внимание, что попробуйте/поймать Может быть написан тремя разными способами: попробуй ... поймать , попробуй ... наконец-то , попробуй ... поймать ... наконец ), но ошибка бросается из этой внутренней попытки.

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

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

Вы можете играть с кодом ниже, комментируя внутренний улов.

try { 
try { 
throw new Error('inner catch error');
} catch(e){ //comment this catch out
console.log(e) 
} finally { 
console.log('finally'); 
} 
throw new Error("outer catch error") 
} catch (ex) { 
console.log(ex);
}

Rethrow ошибка

Выявление CATH на самом деле ловит все ошибки, которые приходят на свой путь, а иногда мы можем этого не захотеть. Например,

"use strict" 
let x=parseInt(prompt("input a number less than 5")) 
try{ 
y=x-10 
if(y>=5) throw new Error(" y is not less than 5") 
else alert(y) 
}catch(e){ 
alert(e) 
}

Предположим, на секунду предположим, что число ввода будет меньше 5 (цель «Используйте строгое» – указать, что код должен быть выполнен в разделе «Строгий режим»). С Строгий режим Нельзя, например, использовать ненужденные переменные ( Источник ).

Я хочу попыток попробовать, чтобы бросить ошибку у не … Когда значение Y больше 5, что близко к невозможным. Ошибка выше должна быть для у не меньше … И не y неопределен .

В таких ситуациях, вы можете проверить имя ошибки, и если это не то, что вы хотите, Rethrow это :

"use strict" 
let x = parseInt(prompt("input a number less than 5"))
try{
y=x-10 
if(y>=5) throw new Error(" y is not less than 5") 
else alert(y) 
}catch(e){ 
if(e instanceof ReferenceError){ 
throw e
}else alert(e) 
}

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

Заключение

В этой статье я пытался объяснить следующие концепции, относящиеся к TRY/CALL:

  • Какие заявления TRY/CALL и когда они работают
  • Как бросить пользовательские ошибки
  • Какое утверждение окончательно и как это работает
  • Как гнездоваться/поймать заявления
  • Как разобрать ошибки

Спасибо за чтение. Следуй за мной в Twitter @fakorededami Отказ

Оригинал: “https://www.freecodecamp.org/news/try-catch-in-javascript/”

Читайте ещё по теме: