minor fixes

Author: iliakan

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

@@ -353,73 +353,33 @@ 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.
+To avoid such problems, we can employ the "rethrowing" technique. The rule is simple:
 
-Using its `name` property:
-
-```js run
-try {
-  user = { /*...*/ };
-} catch(e) {
-*!*
-  alert(e.name); // "ReferenceError" for accessing an undefined variable
-*/!*
-}
-```
+**Catch should only process errors that it knows and "rethrow" all others.**
 
-Using its `constructor.name` property (read-only):
+The "rethrowing" technique can be explained in more detail as:
 
-```js run
-try {
-  user = { /*...*/ };
-} catch(e) {
-*!*
-  alert(e.constructor.name); // "ReferenceError" for accessing an undefined variable
-*/!*
-}
-```
+1. Catch gets all errors.
+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`.
 
-Comparing its `constructor` property to the specific error type:
+Usually, we can check the error type using the `instanceof` operator:
 
 ```js run
 try {
   user = { /*...*/ };
-} catch(e) {
+} catch(err) {
 *!*
-  if (e.constructor === RefferenceError) {
-    alert('e is a ReferenceError'); // "ReferenceError" for accessing an undefined variable
-  }
+  if (err instanceof ReferenceError) {
 */!*
-}
-```
-
-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
+    alert('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:
-
-**Catch should only process errors that it knows and "rethrow" all others.**
-
-The "rethrowing" technique can be explained in more detail as:
-
-1. Catch gets all errors.
-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`.
+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`: