0Pricing
TypeScript Academy · Lezione

Punti critici di JavaScript: bug a runtime

Esplori i bug comuni di JavaScript che compaiono solo a runtime.

Punti critici di JavaScript: bug a runtime è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.

Benvenuto

In questa lezione esploriamo i bug a runtime che hanno motivato la creazione di TypeScript. JavaScript è flessibile, ma questa flessibilità può causare errori difficili da individuare.

Il bug silenzioso della coercizione dei tipi

JavaScript converte implicitamente i tipi senza segnalare nulla. La somma di un numero e di una stringa restituisce una stringa, non un errore. Questo causa comportamenti imprevisti a runtime.
// JavaScript
let total = 5 + '10'; // '510' not 15
console.log(total);   // '510'

Accesso a proprietà undefined

JavaScript consente di accedere a proprietà inesistenti degli oggetti. Il risultato è `undefined` anziché un errore, e spesso si propaga senza essere rilevato.
const user = { name: 'Alice' };
console.log(user.age); // undefined — no error thrown

Chiamare valori non funzione

Se una variabile contiene un valore che non è una funzione e si tenta di chiamarlo, JavaScript genera un TypeError solo a runtime, non durante lo sviluppo.
const greet = 'hello';
greet(); // TypeError: greet is not a function

Refusi nei nomi delle proprietà

Un refuso nel nome di una proprietà restituisce `undefined` senza alcun avviso. Questi bug sono difficili da individuare nei codebase di grandi dimensioni.
const config = { timeout: 3000 };
console.log(config.tiemout); // undefined — typo goes unnoticed

Tipi di argomento errati

Le funzioni JavaScript accettano argomenti di qualsiasi tipo. Passare il tipo sbagliato produce risultati imprevisti anziché un errore chiaro.
function double(n) { return n * 2; }
console.log(double('5')); // 10 — but '5' * 2 uses coercion

Crash dovuti alla dereferenziazione di null

Uno dei crash a runtime più comuni consiste nell'accedere a una proprietà di null o undefined. I controlli rigorosi sui valori null di TypeScript impediscono questa classe di bug.
let element = document.querySelector('.missing');
console.log(element.textContent); // TypeError: Cannot read properties of null

Il problema del refactoring

Quando si rinomina una funzione o una proprietà in JavaScript puro, non esiste uno strumento che trovi in modo affidabile tutti i relativi utilizzi. Il sistema dei tipi di TypeScript consente di eseguire refactoring sicuri anche nei codebase di grandi dimensioni.

Errori a runtime e in fase di compilazione

Gli errori JavaScript compaiono a runtime, spesso in produzione. TypeScript rileva molti di questi errori in fase di compilazione, prima ancora che il codice venga eseguito.

Il supporto dell'IDE peggiora senza i tipi

Senza informazioni sui tipi, l'IDE non può offrire in modo affidabile il completamento automatico, il passaggio alla definizione o il refactoring per la rinomina. I tipi migliorano notevolmente gli strumenti di sviluppo.

Il problema emerge con la crescita

I piccoli script funzionano bene in JavaScript. Tuttavia, quando i progetti crescono fino a comprendere migliaia di file e molti collaboratori, l'assenza di tipi diventa una fonte importante di bug e di difficoltà di manutenzione.

Verifica rapida

Quale comportamento di JavaScript aiuta a prevenire il controllo rigoroso dei valori null di TypeScript?

Riepilogo

La flessibilità di JavaScript, inclusi la coercizione dei tipi, le proprietà `undefined` e l'assenza di controlli sugli argomenti, causa bug silenziosi che compaiono solo a runtime. TypeScript è stato creato per rilevare questi errori prima dell'esecuzione del codice.

Domande Frequenti

La lezione «Punti critici di JavaScript: bug a runtime» è gratuita?

Sì — il testo completo di «Punti critici di JavaScript: bug a runtime» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.

Cosa imparerò in «Punti critici di JavaScript: bug a runtime»?

Esplori i bug comuni di JavaScript che compaiono solo a runtime. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare TypeScript Academy?

Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Punti critici di JavaScript: bug a runtime»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?

Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Punti critici di JavaScript: bug a runtime
  2. Cosa aggiunge TypeScript a JavaScript
  3. Compilazione di TypeScript in JavaScript
  4. Quando utilizzare TypeScript nei propri progetti
← Torna a TypeScript Academy