Introduzione al restringimento avanzato dei tipi

Il restringimento avanzato dei tipi consente di precisare tipi complessi a runtime usando tecniche avanzate come i type guard, l'analisi del flusso di controllo e i predicati personalizzati.

Questi strumenti rendono il codice TypeScript più sicuro e prevedibile.

Cos'è il restringimento dei tipi?

Il restringimento dei tipi è il processo di trasformazione di un tipo più ampio (ad esempio, string | number) in un tipo più specifico usando controlli a runtime.

Usare typeof per restringere il tipo

L'operatore typeof può essere usato per restringere i tipi primitivi:

function printValue(value: string | number): void {
  if (typeof value === 'string') {
    console.log(`String: ${value}`);
  } else {
    console.log(`Number: ${value}`);
  }
}

printValue('Hello'); // String: Hello
printValue(42); // Number: 42

Usare instanceof per restringere il tipo

L'operatore instanceof può essere usato per restringere le istanze delle classi:

class Dog {
  bark() {
    console.log('Woof!');
  }
}

class Cat {
  meow() {
    console.log('Meow!');
  }
}

function makeSound(animal: Dog | Cat): void {
  if (animal instanceof Dog) {
    animal.bark();
  } else {
    animal.meow();
  }
}

makeSound(new Dog()); // Woof!
makeSound(new Cat()); // Meow!

Usare type guard personalizzati

È possibile creare funzioni personalizzate di type guard per restringere i tipi in modo più preciso:

type Fish = { swim: () => void };
type Bird = { fly: () => void };

declare const animal: Fish | Bird;

function isFish(animal: Fish | Bird): animal is Fish {
  return (animal as Fish).swim !== undefined;
}

if (isFish(animal)) {
  animal.swim();
} else {
  animal.fly();

Analisi del flusso di controllo

L'analisi del flusso di controllo di TypeScript restringe automaticamente i tipi in base al flusso logico del codice:

function getLength(value: string | string[]): number {
  if (Array.isArray(value)) {
    return value.length;
  } else {
    return value.length;
  }
}

console.log(getLength('Hello')); // 5
console.log(getLength(['a', 'b', 'c'])); // 3

Vantaggi del restringimento avanzato dei tipi

Il restringimento avanzato dei tipi migliora il codice:

• Riducendo gli errori a runtime.
• Rendendo il codice più sicuro e facile da comprendere.
• Offrendo un controllo preciso sulla gestione dei tipi.

Esercizio

Crei una funzione che accetti un parametro di tipo string | number e registri un messaggio diverso per ciascun tipo. Usi typeof per implementare la logica.

Congratulazioni!

Ha imparato a usare tecniche avanzate di restringimento dei tipi in TypeScript per precisare e gestire tipi complessi in modo sicuro ed efficace. Si eserciti con queste tecniche per rendere il codice più robusto e sicuro dal punto di vista dei tipi!