jeena/en.javascript.info
1
0
Fork 0
Code Issues Pull requests Projects Packages Wiki Activity Actions

minor fixes

Browse source
This commit is contained in:
Ilya Kantor 2020-05-17 23:59:55 +03:00
parent 7ef7c5ebf7
commit da1d600ecd
1 changed files with 18 additions and 58 deletions
Download patch file Download diff file Expand all files Collapse all files

76
1-js/10-error-handling/1-try-catch/article.md
View file

@ -353,65 +353,9 @@ try {
Of course, everything's possible! Programmers do make mistakes. Even in open-source utilities used by millions for decades -- suddenly a bug may be discovered that leads to terrible hacks.
In our case, `try..catch` is meant to catch "incorrect data" errors. But by its nature, `catch` gets *all* errors from `try`. Here it gets an unexpected error, but still shows the same `"JSON Error"` message. That's wrong and also makes the code more difficult to debug.
In our case, `try..catch` is placed to catch "incorrect data" errors. But by its nature, `catch` gets *all* errors from `try`. Here it gets an unexpected error, but still shows the same `"JSON Error"` message. That's wrong and also makes the code more difficult to debug.
Fortunately, there are multiple ways to determine the type of error. Common methods are shown below.
Using its `name` property:
```js run
try {
user = { /*...*/ };
} catch(e) {
*!*
alert(e.name); // "ReferenceError" for accessing an undefined variable
*/!*
}
```
Using its `constructor.name` property (read-only):
```js run
try {
user = { /*...*/ };
} catch(e) {
*!*
alert(e.constructor.name); // "ReferenceError" for accessing an undefined variable
*/!*
}
```
Comparing its `constructor` property to the specific error type:
```js run
try {
user = { /*...*/ };
} catch(e) {
*!*
if (e.constructor === RefferenceError) {
alert('e is a ReferenceError'); // "ReferenceError" for accessing an undefined variable
}
*/!*
}
```
Comparing its class type to another error type using the `instanceof` operator:
```js run
try {
user = { /*...*/ };
} catch(e) {
*!*
if (e instanceof RefferenceError) {
alert('e is an instance of ReferenceError'); // "ReferenceError" for accessing an undefined variable
}
*/!*
}
```
MDN suggests using the `constructor` property or `instanceof` operator in its [error examples](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Handling_a_specific_error).
The rule is simple:
To avoid such problems, we can employ the "rethrowing" technique. The rule is simple:
**Catch should only process errors that it knows and "rethrow" all others.**
@ -421,6 +365,22 @@ The "rethrowing" technique can be explained in more detail as:
2. In the `catch(err) {...}` block we analyze the error object `err`.
2. If we don't know how to handle it, we do `throw err`.
Usually, we can check the error type using the `instanceof` operator:
```js run
try {
user = { /*...*/ };
} catch(err) {
*!*
if (err instanceof ReferenceError) {
*/!*
alert('ReferenceError'); // "ReferenceError" for accessing an undefined variable
}
}
```
We can also get the error class name from `err.name` property. All native errors have it. Another option is to read `err.constructor.name`.
In the code below, we use rethrowing so that `catch` only handles `SyntaxError`:
```js run