MODALITA’ STRICT
Javascript è nato come linguaggio per essere semplice anche per programmatori inesperti, e per questo motivo accetta codice scritto con una serie di problematiche. ES5 ha introdotto novità che in parte pone rimedio a questa concezione. La modalità strict (rigorosa) può essere applicata sia all’intero programma javascript, sia alle singole funzioni. I moduli introdotti in ES6 già operano in modalità strict.
DIFFERENZE TRA MODALITA’ NORMALE E MODALITA’ STRICT
Il codice sotto riportato illustra alcune delle differenze tra la modalità normale e la modalità rigorosa.
STRICT MODE E THIS
This in normal mode è sempre un riferimento ad un oggetto. Se invochiamo la funzione su un valore primitivo, il valore sarà convertito in oggetto. In modalità strict non vi è la forzatura ad oggetto, e questo è un vantaggio per le prestazioni. Inoltre all’interno di una funzione this in strict mode non fa riferimento all’oggetto window a meno che non venga invocato su tale oggetto.
ERROR HANDLING INTRODUZIONE
La corretta gestione degli errori è un aspetto molto importante nello sviluppo delle applicazioni. Quando ci sono istruzioni che possono generare errori queste vanno messe in un blocco try (prova ad eseguire le seguenti istruzioni), se viene generato un errore il controllo passa immediatamente al blocco catch (cattura) che riceve in input l’oggetto errore contenente informazioni sulla natura dell’errore.
ERROR HANDLING THROW NEW E BLOCCO FINALLY
Se viene sollevata un’eccezione ReferenceError tale oggetto è una constructor function le cui istanze vengono create con la parola chiave new. L’istanza di tale oggetto viene passato come argomento nel catch in modo che possiamo avere tutte le informazioni dettagliate sull’errore. Il blocco finally viene sempre eseguito, sia in presenza di errori che in assenza.
ERROR HANDLING GESTIRE GLI ERRORI DELL’APPLICAZIONE
Sia che si tratti di una interfaccia utente sia che si tratti di una richiesta ad una API esterna gli errori possono essere scaturiti dall’applicazione e come tali vanno gestiti. Vediamo un esempio.
APPROFONDIMENTO AI
La modalità strict in JavaScript (o “strict mode”) è una funzionalità introdotta con ECMAScript 5 (ES5) che consente di scrivere codice JavaScript più sicuro e meno soggetto a errori. Quando si abilita la modalità strict, JavaScript adotta una serie di restrizioni aggiuntive e comportamenti più severi per evitare errori comuni o ambiguità che potrebbero causare problemi nel codice.
Come attivare la modalità strict
Per attivare la modalità strict in JavaScript, basta aggiungere la stringa “use strict”; all’inizio di uno script o di una funzione. Ecco un esempio:
1. Applicazione globale:
“use strict“;
function myFunction() {
// Codice JavaScript in modalità strict
}
2. Applicazione locale (solo dentro una funzione):
function myFunction() {
“use strict“;
// Solo questa funzione sarà eseguita in modalità strict
}
Caratteristiche e restrizioni della modalità strict
1. Dichiarazione obbligatoria delle variabili:
In modalità strict, non è possibile usare variabili senza prima dichiararle (con var, let o const).
“use strict“;
x = 10; // Genera un errore, perché x non è dichiarata
2. Eliminazione sicura di proprietà:
Non è possibile eliminare una variabile, una funzione o un oggetto con l’operatore delete in modalità strict.
“use strict“;
var obj = {};
delete obj; // Genera un errore
3. Nomi di variabili e parametri duplicati non ammessi:
Non è possibile avere più parametri con lo stesso nome in una funzione o dichiarare una variabile già esistente.
“use strict“;
function myFunction(x, x) {
// Genera un errore: parametri duplicati
}
4. Restrizioni su eval():
Il codice eseguito all’interno di eval() non può dichiarare variabili o funzioni che vengano definite al di fuori di esso.
“use strict“;
eval(“var x = 2;”);
console.log(x); // Genera un errore: x non è definito al di fuori di eval
5. Modifica delle proprietà di sola lettura non permessa:
In modalità strict, la modifica delle proprietà non scrivibili di un oggetto genera un errore.
“use strict“;
var obj = {};
Object.defineProperty(obj, “prop“, { value: 42, writable: false });
obj.prop = 10; // Genera un errore
6. Evitare di usare parole riservate future:
Parole riservate per le future versioni di ECMAScript (come implements, interface, let, package, private, protected, public, static, yield) non possono essere utilizzate come identificatori.
“use strict“;
var let = 10; // Genera un errore
Benefici della modalità strict
•Errori silenziosi resi espliciti: Situazioni che normalmente verrebbero ignorate dal motore JavaScript (come l’utilizzo di variabili non dichiarate) generano errori chiari e immediati, facilitando il debugging.
•Prestazioni migliorate: In alcuni motori JavaScript, il codice in modalità strict può essere ottimizzato meglio.
•Sicurezza migliorata: La modalità strict previene alcune vulnerabilità, come la modifica delle proprietà non scrivibili o la dichiarazione di variabili globali involontarie.
Gestione degli errori in JavaScript
In JavaScript, gli errori possono essere gestiti usando il costrutto try…catch. Questo costrutto consente di gestire in modo controllato le eccezioni che possono essere sollevate durante l’esecuzione del codice.
Sintassi di base:
try {
// Codice che potrebbe generare un errore
} catch (err) {
// Codice per gestire l’errore
} finally {
// Codice che viene eseguito sempre, indipendentemente dall’errore
}
Componenti del costrutto try…catch:
1. try: Contiene il codice che potrebbe generare un errore.
2. catch: Viene eseguito se un errore viene sollevato nel blocco try. L’errore catturato è disponibile come parametro (spesso chiamato err o error).
3. finally (opzionale): Questo blocco viene eseguito indipendentemente dal fatto che si sia verificato o meno un errore. È utile per eseguire operazioni di pulizia, come il rilascio di risorse.
Esempio:
“use strict“;
try {
let x = 10;
x = y + 1; // Genera un errore, perché y non è definita
} catch (err) {
console.log(“Errore catturato: ” + err.message);
} finally {
console.log(“Questo verrà eseguito sempre“);
}
Creazione di errori personalizzati
In JavaScript, puoi anche generare eccezioni personalizzate usando l’istruzione throw. Questo ti permette di sollevare errori specifici in determinate condizioni.
“use strict“;
function checkAge(age) {
if (age < 18) {
throw new Error(“L’età deve essere almeno 18.“);
}
return true;
}
try {
checkAge(15);
} catch (err) {
console.log(“Errore: ” + err.message);
}
Tipi di errori in JavaScript
•ReferenceError: Sollevato quando si cerca di accedere a una variabile non definita.
•TypeError: Sollevato quando un’operazione viene eseguita su un tipo di dato non valido.
•SyntaxError: Sollevato quando il codice contiene errori di sintassi.
•RangeError: Sollevato quando un numero è fuori dall’intervallo valido.
•EvalError: Sollevato quando c’è un problema nell’uso di eval() (questo errore è raro nelle versioni moderne di JavaScript).
Best practice nella gestione degli errori:
1. Usare sempre try…catch per gestire errori potenziali, specialmente quando si lavora con input esterni, richieste di rete o codice che potrebbe generare errori.
2. Evitare di abusare di try…catch: Non avvolgere tutto il codice in un blocco try…catch senza motivo, poiché può rendere il codice difficile da leggere e mantenere.
3. Creare messaggi di errore chiari: Quando si solleva un errore personalizzato, fornire un messaggio chiaro che descriva il problema.
La modalità strict, insieme a una buona gestione degli errori, contribuisce a rendere il codice JavaScript più robusto, leggibile e facile da manutenere.
Scrivi un commento