TypeScript vs JavaScript: Quando Migrare

JavaScript domina il web da decenni, ma TypeScript sta conquistando il mondo enterprise a ritmi impressionanti: oltre 60 milioni di download settimanali nel 2025. Dovresti migrare? Quando ha senso e quando no? Vediamo i pro, i contro, e come decidere per il tuo progetto.

TypeScript in numeri (2025)

Prima di discutere opinioni, guardiamo i dati:

73% degli sviluppatori usa TypeScript in progetti professionali
85% di chi lo usa dichiara che continuerà a usarlo
400% crescita nell'adozione enterprise dal 2020
85% delle top 1000 librerie NPM ha supporto TypeScript nativo
TypeScript scopre il 15% degli errori JavaScript prima del runtime

Questi numeri raccontano una storia chiara: TypeScript non è più sperimentale, è mainstream.

Cosa cambia rispetto a JavaScript

TypeScript è un superset di JavaScript: tutto il codice JS valido è anche TS valido. La differenza principale sono i tipi statici:

// JavaScript
function greet(name) {
  return "Hello, " + name;
}
greet(123);  // Nessun errore, ma probabilmente un bug

// TypeScript
function greet(name: string): string {
  return "Hello, " + name;
}
greet(123);  // Errore in compilazione: number non è string

Tipi base

// Primitivi
let name: string = "Mario";
let age: number = 30;
let isActive: boolean = true;

// Array
let numbers: number[] = [1, 2, 3];
let names: Array<string> = ["a", "b"];

// Object
interface User {
  id: number;
  name: string;
  email?: string;  // opzionale
}

const user: User = {
  id: 1,
  name: "Mario"
};

Union types e type guards

// Può essere string o number
type ID = string | number;

function processId(id: ID) {
  if (typeof id === "string") {
    // TypeScript sa che qui id è string
    return id.toUpperCase();
  }
  // Qui id è number
  return id * 2;
}

Generics

// Funzione generica
function first<T>(arr: T[]): T | undefined {
  return arr[0];
}

const num = first([1, 2, 3]);      // tipo: number | undefined
const str = first(["a", "b"]);    // tipo: string | undefined

Vantaggi di TypeScript

1. Errori scoperti prima

Il 15% degli errori JavaScript viene catturato in fase di compilazione. Sembra poco? Su un progetto con 100 bug, sono 15 errori che non arrivano mai in produzione.

// Errore comune in JavaScript
const user = await fetchUser(id);
console.log(user.nmae);  // Typo! JS non se ne accorge

// TypeScript
console.log(user.nmae);
// ❌ Property 'nmae' does not exist on type 'User'.
// Did you mean 'name'?

2. Autocompletamento intelligente

L'IDE conosce i tipi e suggerisce metodi e proprietà corretti. Meno documentazione da consultare, meno errori di digitazione.

3. Refactoring sicuro

Rinominare una proprietà? TypeScript trova tutti gli utilizzi. Cambiare la firma di una funzione? L'IDE evidenzia dove aggiornare il codice chiamante.

4. Documentazione integrata

interface ApiResponse {
  /** HTTP status code */
  status: number;
  /** Response data */
  data: User[];
  /** Pagination info */
  meta: {
    page: number;
    totalPages: number;
  };
}

I tipi sono documentazione che non può diventare obsoleta: se il codice cambia, i tipi devono cambiare.

5. Collaborazione in team

I tipi definiscono contratti chiari tra parti del codice. Se scrivi un'API, chi la usa sa esattamente cosa passare e cosa aspettarsi.

Svantaggi di TypeScript

1. Curva di apprendimento

I tipi avanzati (generics, conditional types, mapped types) richiedono studio. Il 20-30% di produttività in meno durante la fase di apprendimento.

2. Tempo di configurazione

Serve tsconfig.json, build step, e spesso configurazione ESLint aggiuntiva. Per uno script veloce, è overhead.

3. Build step obbligatorio

TypeScript non gira direttamente nel browser. Serve transpilazione, anche se tool come Vite e esbuild la rendono quasi istantanea.

4. Tipi "any" che annullano i benefici

// Questo compila ma vanifica TypeScript
function processData(data: any) {
  return data.foo.bar.baz;  // Nessun controllo
}

Se usi any ovunque, hai gli svantaggi di TypeScript senza i vantaggi.

Quando usare JavaScript

Script veloci e one-off: automatizzazioni, script di build, utility
Prototipi e MVP: quando validare l'idea conta più della manutenibilità
Progetti piccoli solo tuoi: se sei l'unico sviluppatore e il progetto è semplice
Learning: impara JavaScript prima, TypeScript dopo
Contesto che non supporta TS: alcune piattaforme serverless o tool legacy

Quando usare TypeScript

Applicazioni in produzione: qualsiasi cosa che deve durare e scalare
Team multipli: i tipi sono contratti tra sviluppatori
Codebase grandi: oltre 10k righe, il refactoring senza tipi diventa pericoloso
API e backend: dove gli errori costano caro
Applicazioni con dati complessi: form, tabelle, integrazioni API
Progetti con soldi in gioco: fintech, e-commerce, healthcare

Strategia di migrazione graduale

Non serve migrare tutto in una volta. Ecco l'approccio consigliato:

Fase 1: Setup base

# Installa TypeScript
npm install -D typescript @types/node

# Inizializza tsconfig.json
npx tsc --init

// tsconfig.json minimo per migrazione graduale
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "strict": false,         // Inizia permissivo
    "allowJs": true,         // Permetti file .js
    "checkJs": false,        // Non controllare .js
    "outDir": "./dist",
    "esModuleInterop": true
  },
  "include": ["src/**/*"]
}

Fase 2: Nuovi file in TypeScript

Ogni nuova feature scritta in .ts. I file esistenti restano .js.

Fase 3: Migrazione progressiva

Quando modifichi un file .js, convertilo in .ts. Aggiungi tipi gradualmente.

Fase 4: Strict mode

Quando la maggior parte del codice è tipizzata, abilita "strict": true.

Setup consigliato 2025

// tsconfig.json per nuovo progetto
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "noImplicitOverride": true,
    "skipLibCheck": true,
    "esModuleInterop": true,
    "resolveJsonModule": true,
    "isolatedModules": true,
    "outDir": "./dist"
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules"]
}

Framework e librerie nel 2025

Quasi tutti i framework moderni supportano TypeScript nativamente:

React: supporto completo, inclusi tipi per hooks
Next.js: TypeScript di default da anni
Vue 3: scritto in TypeScript, supporto nativo
Express/Fastify: tipi disponibili via @types
Prisma, tRPC: generano tipi automaticamente

Conclusione

Nel 2025 la domanda non è più "TypeScript o JavaScript?" ma "quando ha senso usare JavaScript invece di TypeScript?". Per progetti seri, in team, o che devono durare, TypeScript è la scelta standard. I punti chiave:

TypeScript scopre errori prima che arrivino in produzione
L'investimento iniziale ripaga con 40% di costi di manutenzione in meno
La migrazione può essere graduale, non serve fermare lo sviluppo
Per script veloci e prototipi, JavaScript resta perfetto
Il 73% degli sviluppatori professionisti già usa TypeScript

Se non hai ancora provato TypeScript, inizia con un nuovo progetto piccolo. Una volta sperimentato l'autocompletamento e la sicurezza dei tipi, difficilmente tornerai indietro.