Custom errors, extending Error

Author: senzidee

1-js/10-error-handling/1-try-catch/1-finally-or-code-after/solution.md

@@ -1,8 +1,8 @@
-The difference becomes obvious when we look at the code inside a function.
+La differenza diventa ovvia quando inseriamo il codice all'interno di una funzione.
 
-The behavior is different if there's a "jump out" of `try..catch`.
+Il comportamento è differente se c'è un salto dall'interno del `try..catch`.
 
-For instance, when there's a `return` inside `try..catch`. The `finally` clause works in case of *any* exit from `try..catch`, even via the `return` statement: right after `try..catch` is done, but before the calling code gets the control.
+Per esempio, quando c'è un `return` all'interno del `try..catch`. La clausola `finally` funziona indipendentemente da come termina il `try..catch`, anche nel caso avvenga tramite un `return`: subito dopo la conclusione del `try..catch`, ma prima che il codice richiamato prenda il controllo.
 
 ```js run
 function f() {
@@ -21,7 +21,7 @@ function f() {
 f(); // cleanup!
 ```
 
-...Or when there's a `throw`, like here:
+...O quando si presenta un `throw`, come:
 
 ```js run
 function f() {
@@ -44,4 +44,4 @@ function f() {
 f(); // cleanup!
 ```
 
-It's `finally` that guarantees the cleanup here. If we just put the code at the end of `f`, it wouldn't run in these situations.
+È `finally` che garantisce la pulizia qui. Se inseriamo del codice alla fine di `f`, in queste situazioni, non verrà eseguito.

1-js/10-error-handling/1-try-catch/1-finally-or-code-after/task.md

@@ -1,38 +1,38 @@
-importance: 5
+importanza: 5
 
 ---
 
-# Finally or just the code?
+# Finally o solamente il codice?
 
-Compare the two code fragments.
+Confronta i due frammenti di codice.
 
-1. The first one uses `finally` to execute the code after `try..catch`:
+1. Il primo utilizza `finally` per eseguire il codice dopo `try..catch`:
 
     ```js
     try {
-      work work
+      lavoro lavoro
     } catch (e) {
-      handle errors
+      gestisci gli errori
     } finally {
     *!*
-      cleanup the working space
+      ripulisci lo spazio di lavoro
     */!*
     }
     ```
-2. The second fragment puts the cleaning right after `try..catch`:
+2. Il secondo posiziona la puliza subito dopo il `try..catch`:
 
     ```js
     try {
-      work work
+      lavoro lavoro
     } catch (e) {
-      handle errors
+      gestisci gli errori
     }
 
     *!*
-    cleanup the working space
+    ripulisci lo spazio di lavoro
     */!*
     ```
 
-We definitely need the cleanup after the work, doesn't matter if there was an error or not.
+Abbiamo decisamente bisogno di ripulire dopo il lavoro, sia che si verifichi un errore o meno.
 
-Is there an advantage here in using `finally` or both code fragments are equal? If there is such an advantage, then give an example when it matters.
+Esiste un vantaggio nell'usare `finally` o ambedue i frammenti di codice sono equivalenti? Se c'è qualche vantaggio, allora fornisci un esempio di quanto sia importante.

1-js/10-error-handling/2-custom-errors/1-format-error/solution.md

@@ -6,11 +6,11 @@ class FormatError extends SyntaxError {
   }
 }
 
-let err = new FormatError("formatting error");
+let err = new FormatError("errore di formattazione");
 
-alert( err.message ); // formatting error
+alert( err.message ); // errore di formattazione
 alert( err.name ); // FormatError
 alert( err.stack ); // stack
 
-alert( err instanceof SyntaxError ); // true
+alert( err instanceof SyntaxError ); // vero
 ```

1-js/10-error-handling/2-custom-errors/1-format-error/task.md

@@ -2,21 +2,21 @@ importance: 5
 
 ---
 
-# Inherit from SyntaxError
+# Eredita da SyntaxError
 
-Create a class `FormatError` that inherits from the built-in `SyntaxError` class.
+Crea una classe `FormatError` che eredita dalla classe incorporata `SyntaxError`.
 
-It should support `message`, `name` and `stack` properties.
+Dovrebbe supportare le proprietà `message`, `name` e `stack`.
 
 Usage example:
 
 ```js
 let err = new FormatError("formatting error");
 
-alert( err.message ); // formatting error
+alert( err.message ); // Errore nella formattazione
 alert( err.name ); // FormatError
 alert( err.stack ); // stack
 
-alert( err instanceof FormatError ); // true
-alert( err instanceof SyntaxError ); // true (because inherits from SyntaxError)
+alert( err instanceof FormatError ); // vero
+alert( err instanceof SyntaxError ); // vero (poiché eredita SyntaxError)
 ```