Tipi base TypeScript: string, number, boolean, any, unknown, never, void — Guida Operativa

Hai mai passato ore a cercare un bug in JavaScript solo per scoprire che una variabile non era del tipo che pensavi? Succede a tutti. Ecco perché esistono i tipi base di TypeScript. Non sono nozioni accademiche: sono la differenza tra un codice che si rompe in produzione e uno che resiste. Noi, di Meteora Web, li usiamo ogni giorno nei nostri progetti Laravel, Vue e WordPress custom. E partiamo da un principio: un type ben scelto è un bug che non nasce.

Perché i tipi base contano davvero

TypeScript aggiunge un sistema di tipi a JavaScript. I tipi base sono i mattoni: string, number, boolean, any, unknown, never, void. Usarli male significa scrivere TypeScript che è solo JavaScript travestito. Usarli bene significa:

• Codice auto-documentato: chi legge sa subito cosa può passare e cosa aspettarsi.
• Meno bug: il compilatore intercetta errori come sommare stringhe a numeri.
• Refactoring sicuro: cambi un tipo e TypeScript ti mostra tutti i punti da aggiornare.

Un esempio concreto: quando abbiamo ottimizzato il gestionale ERP di un negozio di abbigliamento, abbiamo migrato la logica di calcolo dei margini da JavaScript a TypeScript. Il risultato? Zero errori di tipo nei report di season. Non è teoria.

I tipi primitivi: string, number, boolean

Sono la base. Usali sempre per valori semplici.

string

Rappresenta una sequenza di caratteri. In TypeScript puoi dichiarare una variabile stringa in tre modi:

let nome: string = 'Meteora Web';
let descrizione: string = `Siamo a Sciacca dal 2017`; // template literal
let url: string = 'https://meteoraweb.com';

Errore comune: usare String (l'oggetto) invece di string (il tipo primitivo). Non farlo: String è l'oggetto wrapper, raro da usare.

number

Include interi, decimali, NaN, Infinity. Non c'è distinzione tra int e float — in TypeScript è tutto number.

let eta: number = 35;
let prezzo: number = 29.99;
let fatturato: number = 1_000_000; // underscore come separatore visivo

Consiglio operativo: per soldi, usa number ma attento agli arrotondamenti. Se lavori con transazioni, considera librerie come decimal.js.

boolean

Vero o falso. Semplice, ma spesso abusato:

let isActive: boolean = true;
let hasDiscount: boolean = false;

Errore comune: assegnare 0 o '' a un booleano. TypeScript lo blocca, ma in JavaScript si. Allenati a essere esplicito.

any e unknown: il rischio e la rete di sicurezza

Questi due tipi sono spesso confusi. Noi li chiamiamo “il diavolo e l'acqua santa”.

any: il tipo che disabilita il controllo

any dice a TypeScript: “fidati, so cosa faccio”. Di conseguenza, nessun controllo sui metodi chiamati. È il tipo che fa tornare il tuo codice a JavaScript puro.

let data: any = 'testo';
data = 42; // ok
data.toUpperCase(); // a runtime si rompe perché 42 non ha toUpperCase

Quando usarlo: solo in transizioni da JS a TS, o per dati davvero imprevedibili (es. risposta di API esterne non tipizzata). Ma appena possibile, sostituiscilo con un tipo specifico o unknown.

unknown: il tipo sicuro

unknown è come any ma obbliga a fare un controllo di tipo prima di usare il valore. È la scelta migliore per dati di cui non conosci la forma.

let valore: unknown = 'ciao';
// valore.toUpperCase(); // Errore! Object is of type 'unknown'

if (typeof valore === 'string') {
    console.log(valore.toUpperCase()); // OK, type narrowing
}

Noi lo usiamo spesso nelle API call: prima di processare la risposta, controlliamo il tipo con typeof o con uno schema (es. Zod). Riduce i crash runtime del 90%.

never e void: fine del flusso e assenza di ritorno

Sono i tipi che indicano cosa non succede.

void: nessun valore restituito

Tipico per funzioni che eseguono azioni senza tornare nulla (es. log, salvataggio in DB).

function logMessaggio(msg: string): void {
    console.log(msg);
    // nessun return
}

Attenzione: void non significa “undefined”. Una funzione void può restituire undefined, ma non altri valori. Se provi a fare return 42; TypeScript dà errore.

never: qualcosa che non accade mai

never rappresenta un valore che non può verificarsi. Lo vedi in:

• Funzioni che lanciano sempre un'eccezione.
• Cicli infiniti.
• Switch esaustivi (exhaustive checks).

function throwError(msg: string): never {
    throw new Error(msg);
}

function infiniteLoop(): never {
    while (true) {}
}

Uso pratico: quando fai uno switch su un enum, TypeScript può controllare che tutti i casi siano coperti. Aggiungi un default con never:

type StatoOrdine = 'pending' | 'shipped' | 'delivered';

function handleStato(s: StatoOrdine) {
    switch (s) {
        case 'pending': break;
        case 'shipped': break;
        case 'delivered': break;
        default:
            const _exhaustive: never = s; // se aggiungi un nuovo stato, qui errore
    }
}

Questo pattern ci ha salvato più volte quando abbiamo ampliato i flussi di stato nel nostro ERP.

Inline type annotations vs type inference

Non devi sempre scrivere il tipo. TypeScript è bravo a inferire:

let name = 'Meteora'; // TypeScript inferisce: string
let count = 100;      // inferisce: number

Noi preferiamo annotare esplicitamente i parametri di funzione e i tipi di ritorno (rende il contratto chiaro), ma lasciamo inferire le variabili locali semplici. Equilibrio.

Tabella riassuntiva — quando usare cosa

Tipo	Quando usare	Quando NON usare
string	Testi, URL, email, nomi	Numeri o booleani
number	Conteggi, prezzi, età	Cifre che non calcoli (es. CAP)
boolean	Flag, toggle, condizioni	Invece di valori enumerati
any	Migrazione JS->TS, prototipi veloci	Codice di produzione (sostituisci appena possibile)
unknown	API esterne, input utente, JSON non validato	Quando conosci già il tipo
never	Funzioni che lanciano errori, switch esaustivi	Valori che possono capitare
void	Funzioni senza return significativo	Funzioni che restituiscono un valore

In sintesi — cosa fare adesso

1. Rivedi i tipi nei tuoi file .ts. Apri un componente qualsiasi. Controlla dove hai usato any e sostituiscilo con unknown o un tipo union.
2. Aggiungi type annotation esplicite per parametri e return delle funzioni pubbliche.
3. Implementa un controllo esaustivo con never in ogni switch su enum o union.
4. Usa unknown per ogni risposta di API non ancora validata. Poi fai narrowing con typeof o con una libreria come Zod.
5. Se lavori in un team, concorda una policy: niente any nei merge su main. Usa gli strumenti come ESLint con regola @typescript-eslint/no-explicit-any.

I tipi base di TypeScript non sono una burocrazia: sono la rete che impedisce al tuo codice di cadere nel vuoto. Noi, di Meteora Web, lo vediamo ogni giorno nei progetti che seguiamo dall’idea al fatturato. Se vuoi approfondire, dai un’occhiata alla nostra guida su ES2024 ed ES2025 o a quella sulla programmazione a oggetti in Python — concetti che si intrecciano col typing.