TypeScript vs Python: tipi, velocità e casi d'uso a confronto

TypeScript e Python sono entrambi linguaggi di alto livello con garbage collection, funzioni di prima classe e grandi ecosistemi di pacchetti. La differenza principale sono i tipi: quelli di TypeScript vengono controllati dal compilatore prima che il programma venga eseguito, mentre i type hint di Python sono annotazioni facoltative che l'interprete ignora. Girano anche su motori diversi e dominano tipi di software diversi: TypeScript il web, Python il lavoro sui dati e lo scripting.

Ecco un piccolo programma in TypeScript. Premi Run:

interface Order {
    customer: string;
    amount: number;
    paid: boolean;
}

function totalPaid(orders: Order[]): number {
    return orders.filter((o) => o.paid).reduce((sum, o) => sum + o.amount, 0);
}

const orders: Order[] = [
    { customer: "Ada", amount: 120, paid: true },
    { customer: "Grace", amount: 80.5, paid: false },
    { customer: "Linus", amount: 42.25, paid: true },
];

const byAmount = [...orders].sort((a, b) => b.amount - a.amount).map((o) => o.customer);
console.log(totalPaid(orders));
console.log(byAmount);

Output:

162.25
[ 'Ada', 'Grace', 'Linus' ]

Lo stesso programma in Python, con i type hint:

from dataclasses import dataclass


@dataclass
class Order:
    customer: str
    amount: float
    paid: bool


def total_paid(orders: list[Order]) -> float:
    return sum(o.amount for o in orders if o.paid)


orders = [
    Order("Ada", 120.0, True),
    Order("Grace", 80.5, False),
    Order("Linus", 42.25, True),
]

by_amount = [o.customer for o in sorted(orders, key=lambda o: o.amount, reverse=True)]
print(total_paid(orders))
print(by_amount)

162.25
['Ada', 'Grace', 'Linus']

La struttura è simile: un tipo per il record, una funzione con parametri tipizzati, una lista di valori. Le differenze visibili sono la sintassi (graffe e punti e virgola contro indentazione), interface contro una @dataclass, e arrow function con filter/reduce contro una generator expression.

TypeScript vs Python a colpo d'occhio

La sintassi fianco a fianco

Se conosci i type hint di Python, quasi ogni annotazione TypeScript ha un equivalente diretto:

Tipi statici e type hint

Entrambi i linguaggi ti permettono di scrivere la stessa annotazione, a: number o a: int. Ciò che succede dopo è diverso.

In TypeScript il compilatore controlla ogni chiamata prima che venga eseguito qualsiasi cosa. Un argomento sbagliato blocca la build:

// This does not compile: TypeScript checks the call before running it.
function add(a: number, b: number): number {
    return a + b;
}

console.log(add(2, 3));
console.log(add("2", "3"));

index.ts(7,17): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.

In Python i type hint sono metadati. L'interprete esegue la chiamata e restituisce una stringa:

def add(a: int, b: int) -> int:
    return a + b


print(add(2, 3))      # 5
print(add("2", "3"))  # 23, the hints are not enforced

Il controllo è un passaggio separato con uno strumento come mypy:

$ mypy hints.py
hints.py:6: error: Argument 1 to "add" has incompatible type "str"; expected "int"  [arg-type]
hints.py:6: error: Argument 2 to "add" has incompatible type "str"; expected "int"  [arg-type]
Found 2 errors in 1 file (checked 1 source file)

Quindi i tipi in Python sono graduali per scelta: il codice senza annotazioni semplicemente non viene controllato, e aggiungi i type hint dove servono. Anche TypeScript può essere permissivo (any disattiva il controllo per un valore), ma con strict attivo, che è il valore predefinito, un parametro senza annotazione è un errore e non un lasciapassare.

Una cosa li accomuna: nessuno dei due controlla i tipi mentre il programma è in esecuzione. TypeScript elimina i suoi tipi e Python ignora i suoi type hint. I dati che arrivano a runtime, come il JSON di un'API, vanno validati in entrambi i linguaggi (librerie come Zod in TypeScript e Pydantic in Python lo fanno a partire da uno schema).

I numeri si comportano in modo diverso

TypeScript ha i numeri di JavaScript: number è un valore in virgola mobile a 64 bit sia per gli interi sia per i decimali, e bigint è un tipo separato per gli interi grandi. L'int di Python cresce da solo fino a qualsiasi dimensione.

console.log(0.1 + 0.2);        // float rounding, same as Python
console.log(2 ** 53 + 1);      // beyond 2^53, not every integer fits in a number
console.log(7 / 2, Math.trunc(7 / 2));
console.log(2n ** 100n);       // bigint: exact, like Python's int

Output:

0.30000000000000004
9007199254740992
3.5 3
1267650600228229401496703205376n

Python stampa 9007199254740993 per 2**53 + 1, perché i suoi interi sono esatti a qualsiasi dimensione, e ha un operatore dedicato alla divisione intera, 7 // 2, che dà 3. In TypeScript non esiste un tipo int; un intero è un number che non ha parte decimale.

Runtime e prestazioni

TypeScript gira come JavaScript. V8 (in Chrome e Node.js), JavaScriptCore (in Safari e Bun) e SpiderMonkey (in Firefox) compilano il codice più usato in codice macchina durante l'esecuzione, quindi i cicli stretti in TypeScript sono di solito molto più veloci degli stessi cicli in CPython, che esegue bytecode.

Per molti programmi questo divario conta meno di quanto sembri:

• Le librerie numeriche e di machine learning di Python (NumPy, pandas, PyTorch) svolgono il lavoro pesante in codice compilato C, C++ o CUDA, quindi un programma Python che le chiama non esegue i suoi cicli interni in Python.
• I server web, in entrambi i linguaggi, passano gran parte del tempo ad aspettare database e rete.

Entrambi i linguaggi usano un solo thread principale per la maggior parte del codice. TypeScript su Node.js gestisce la concorrenza con un event loop e async/await, e usa i worker thread per il lavoro parallelo sulla CPU. Python ha asyncio per lo stesso stile di concorrenza, più thread e processi.

Ecosistemi e casi d'uso

TypeScript è la scelta predefinita per:

• Front end web: React, Angular, Vue e Svelte lo supportano tutti, e viene compilato nel JavaScript eseguito dai browser.
• Codice server su Node.js, Deno e Bun: API con Express, Fastify, NestJS o Hono.
• App full stack in cui server e browser condividono le definizioni dei tipi, come i progetti Next.js.
• Strumenti di sviluppo, strumenti da riga di comando e app desktop con Electron.

Python è la scelta predefinita per:

• Analisi e visualizzazione dei dati (pandas, NumPy, Matplotlib, notebook Jupyter).
• Machine learning e IA (PyTorch, scikit-learn e la maggior parte del codice di addestramento dei modelli).
• Scripting e automazione: elaborazione di file, amministrazione di sistema, codice di collegamento.
• Back end web con Django, Flask o FastAPI.
• Calcolo scientifico e didattica.

Lo sviluppo web back end è dove si sovrappongono di più. I team spesso scelgono in base al resto dello stack: TypeScript per condividere codice con un front end in TypeScript, Python per stare accanto al codice di dati e ML.

Quale dovresti imparare?

• Sviluppi per il web? Impara JavaScript, poi TypeScript. Tutto ciò che gira in un browser alla fine è JavaScript, e TypeScript è il modo in cui si scrive la maggior parte del codice front end professionale.
• Lavori con dati, IA o automazione? Impara Python. Le sue librerie in questi ambiti non hanno veri equivalenti nel mondo JavaScript.
• Primo linguaggio, senza un obiettivo preciso? Python ha meno sintassi da imparare prima di poter scrivere programmi utili. TypeScript aggiunge un sistema di tipi sopra JavaScript, che all'inizio è una cosa in più da imparare e ripaga man mano che i programmi crescono.

Molti sviluppatori usano entrambi: Python per dati e script, TypeScript per il codice web del prodotto. Se conosci già i type hint di Python, le annotazioni di TypeScript ti sembreranno familiari; le novità sono che il compilatore le fa rispettare di default e che il runtime sottostante è JavaScript.