Generici

Benvenuto alla prossima lezione! In questa lezione imparerà a conoscere i generici, una potente funzionalità di TypeScript che consente di creare componenti riutilizzabili e sicuri dal punto di vista dei tipi. Iniziamo!

Che cosa sono i generici?

I generici consentono di scrivere codice riutilizzabile che funziona con qualsiasi tipo. Fungono da segnaposto per i tipi che è possibile specificare quando li si utilizza.

Esempio: una funzione generica:

Attività: Scriva una funzione generica che accetti un argomento e lo restituisca senza modificarlo.

function identity<T>(value: T): T {
  return value;
}

console.log(identity<string>("Hello")); 
// Output: Hello
console.log(identity<number>(42)); 
// Output: 42

Perché utilizzare i generici?

I generici consentono di:

• Scrivere codice riutilizzabile: le funzioni e le classi possono lavorare con tipi diversi.
• Garantire la sicurezza dei tipi: è possibile imporre tipi specifici senza rinunciare alla flessibilità.
• Ridurre la ridondanza: evitare di scrivere versioni separate della stessa funzione o classe per tipi diversi.

Suggerimento: Utilizzi i generici per scrivere codice più flessibile e facile da mantenere.

Funzioni generiche

È possibile utilizzare i generici per creare funzioni flessibili. Esempio:

Attività: Scriva una funzione generica che unisca due oggetti e restituisca il risultato.

function merge<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

let merged = merge({ name: "Alice" }, { age: 25 });
console.log(merged); 
// Output: { name: "Alice", age: 25 }

Classi generiche

I generici possono essere utilizzati nelle classi per renderle riutilizzabili con tipi diversi. Esempio:

class Box<T> {
  private contents: T;

  constructor(contents: T) {
    this.contents = contents;
  }

  getContents(): T {
    return this.contents;
  }
}

let stringBox = new Box<string>("Hello");
console.log(stringBox.getContents()); 
// Output: Hello

let numberBox = new Box<number>(42);
console.log(numberBox.getContents()); 
// Output: 42

Interfacce generiche

Anche le interfacce possono utilizzare i generici per imporre una struttura a tipi diversi. Esempio:

Attività: Definisca un'interfaccia generica e crei un oggetto che la implementi.

interface Pair<T, U> {
  first: T;
  second: U;
}

let coordinates: Pair<number, number> = { first: 10, second: 20 };
console.log(coordinates); 
// Output: { first: 10, second: 20 }

Vincoli dei generici

È possibile aggiungere vincoli ai generici per garantire che funzionino solo con tipi specifici. Esempio:

function printLength<T extends { length: number }>(item: T): void {
  console.log(`Length: ${item.length}`);
}

printLength("Hello"); 
// Output: Length: 5
printLength([1, 2, 3]); 
// Output: Length: 3
// printLength(42); 
// Error: Argument of type 'number' is not assignable to parameter of type '{ length: number }'.

Valori predefiniti dei generici

È possibile specificare tipi predefiniti per i generici se non viene fornito alcun tipo. Esempio:

Attività: Crei una funzione generica con un tipo predefinito e la verifichi con tipi diversi.

function wrap<T = string>(value: T): T[] {
  return [value];
}

console.log(wrap("Hello")); // Output: ["Hello"]
console.log(wrap(42)); // Output: [42]

Ottimo lavoro!

Congratulazioni! Ha imparato a utilizzare i generici in TypeScript per creare funzioni, classi e interfacce riutilizzabili e sicure dal punto di vista dei tipi. I generici sono uno strumento potente per scrivere codice flessibile e scalabile. Nella prossima lezione esploreremo i tipi avanzati, come i tipi mappati e condizionali. Continui a programmare!