Saltar al contingut principal
Tornar enrere

TypeScript #1: La Inferencia treballa per tu

#typescript #inference #basics
Per què escriure tipus quan TypeScript ja els sap? Entenent const vs let i la inferència automàtica.

El primer pel que començarem és entendre que TypeScript és llest. No cal explicar-li l’obvi.

La Inferència de Tipus

Molts devs (com jo) que venen de llenguatges fortament tipats (com C, Java o C# antics) és normal que estiguem acostumats a la idea de tipar-ho tot.

typescript 
// ❌ Redundant (Boilerplate innecessari)
const userName: string = "Arnau";
const userAge: number = 41;
const isAdmin: boolean = true;

TypeScript ja sap que “Arnau” és un string. No cal que l’hi juris.

typescript 
// ✅ Perfecte (Net i llegible)
const userName = "Arnau"; // TS infereix: string (o literal "Arnau", veurem això després)
const userAge = 41;       // TS infereix: number
const isAdmin = true;     // TS infereix: boolean

Això es diu Inferència de Tipus. Deixes que TS dedueixi el tipus pel valor inicial.

const vs let: La diferència clau

Aquí és on la cosa es posa interessant i on TS brilla.

Amb let (Variables mutables)

Quan uses let, TS assumeix que canviaràs el valor, així que infereix el tipus primitiu “general”.

typescript 
// TS amb això entén: "Ah, 'status' és un STRING i a més canviarà a qualsevol altre string".
let status = "pending";

status = "success"; // ✅ Bé
status = "error";   // ✅ Bé

status = 123;       // ❌ Si ho intentes et retornarà un error.
// No pots ficar un número en un string.

Amb const (Constants)

Quan uses const, TS sap que aquest valor mai canviarà. Així que pot ser molt més específic.

typescript 
const method = "GET";
// TS diu: "Això no és només un string. És L'string 'GET'".
// El tipus literal és "GET".

Això sembla una ximpleria ara, però és la base per entendre per què a vegades TS es queixa que "GET" no és assignable a string (o viceversa) en configuracions complexes.

Quan SÍ anotar tipus

Llavors, si TS ho infereix, mai és necessari posar tipus? No, hi ha casos on és necessari:

  1. Quan la inferència falla o és molt àmplia:

Des del meu punt de vista amb poca experiència, deixaria que TS infereixi any (o el posaria jo mateix) en casos en què no sé el que passarà, sigui per errors o que la resposta pugui ser molt àmplia.

typescript 
// TS infereix 'any' si no està configurat en mode 'strict' (que t'obliga a anotar tipus sempre)
let data; 
data = fetchSomething(); // Pots passar-li el que vulguis i TS no es queixa.

Però ull amb any, perquè li estàs traient a TS tot el seu propòsit. L’ideal seria no veure’t obligat a utilitzar-lo.

  1. En paràmetres de funcions (Aquí és obligatori!):
typescript 
// ❌ TS no pot llegir la teva ment ni saber qui cridarà a això
function greet(person) {
  ...
}

// ✅ Aquí defineixes el contracte
function greet(person: string) {
  ...
}
  1. Per definir contractes de retorn explícits: A vegades vols assegurar-te que la teva funció retorna X, encara que infereixi Y.

Resum de la Part 1

  • Menys és més: Si TS pot inferir-ho, no ho escriguis. El teu codi serà més net.
  • Variable (let) = Tipus General (string, number).
  • Constant (const) = Tipus Literal (El valor exacte).

A la Part 2, mirarem com usar aquests tipus literals al nostre favor amb les Unions, i com dir-li a TS: “Aquesta variable només pot ser ‘admin’ o ‘user’, res més”.

Experimenta!

Aquí tens un editor de TypeScript real corrent al teu navegador per provar el que has après.