For-In

Edoardo Midali

Il ciclo for-in in TypeScript rappresenta il meccanismo nativo per iterare sulle chiavi enumerabili di un oggetto. A differenza dei cicli che operano su array, for-in è progettato specificamente per attraversare le proprietà di oggetti, fornendo accesso alle chiavi piuttosto che ai valori diretti.

Fondamenti e Sintassi

Il ciclo for-in itera attraverso tutte le proprietà enumerabili di un oggetto, incluse quelle ereditate dalla catena prototipale. La variabile del ciclo contiene il nome della proprietà come stringa ad ogni iterazione.

const persona = {
  nome: "Mario",
  cognome: "Rossi",
  eta: 30,
};

for (const chiave in persona) {
  console.log(`${chiave}: ${persona[chiave]}`);
}
// Output:
// nome: Mario
// cognome: Rossi
// eta: 30

Tipizzazione delle Chiavi

TypeScript tratta la variabile del ciclo for-in come tipo string per impostazione predefinita, anche se l’oggetto ha chiavi tipizzate. Questo comportamento protegge da accessi non sicuri ma richiede type assertion o narrowing per accesso tipizzato.

interface Utente {
  nome: string;
  email: string;
  eta: number;
}

const utente: Utente = {
  nome: "Anna",
  email: "anna@example.com",
  eta: 25,
};

for (const chiave in utente) {
  // chiave è di tipo string
  console.log(utente[chiave]); // ERRORE: Element implicitly has an 'any' type
}

// Approccio corretto con type assertion
for (const chiave in utente) {
  const k = chiave as keyof Utente;
  console.log(utente[k]); // OK
}

Proprietà Ereditate

For-in itera su tutte le proprietà enumerabili incluse quelle ereditate dal prototipo. Per limitarsi alle proprietà proprie dell’oggetto, è necessario usare hasOwnProperty.

class Animale {
  tipo = "mammifero";
}

class Cane extends Animale {
  razza = "Labrador";
  nome = "Rex";
}

const cane = new Cane();

// Itera su tutte le proprietà, incluse quelle ereditate
for (const prop in cane) {
  console.log(prop); // tipo, razza, nome
}

// Solo proprietà proprie
for (const prop in cane) {
  if (cane.hasOwnProperty(prop)) {
    console.log(prop); // razza, nome
  }
}

For-In con Array

Usare for-in con array è generalmente sconsigliato perché itera sugli indici come stringhe e può includere proprietà aggiuntive aggiunte all’array. Per array, preferire for-of o forEach.

const numeri = [10, 20, 30];
numeri.descrizione = "Array di numeri"; // Proprietà aggiuntiva

for (const indice in numeri) {
  console.log(indice, typeof indice); // "0" string, "1" string, "2" string, "descrizione" string
  console.log(numeri[indice]); // 10, 20, 30, "Array di numeri"
}

// Approccio corretto per array
for (const numero of numeri) {
  console.log(numero); // 10, 20, 30
}

Ordine di Iterazione

L’ordine di iterazione delle proprietà non è garantito dallo standard JavaScript originale, anche se i motori moderni seguono convenzioni prevedibili: proprietà intere in ordine numerico, poi proprietà stringhe in ordine di inserimento, infine simboli.

const oggetto = {
  c: 3,
  a: 1,
  2: "due",
  1: "uno",
  b: 2,
};

for (const chiave in oggetto) {
  console.log(chiave);
}
// Output tipico: "1", "2", "a", "c", "b"

Proprietà Non Enumerabili

For-in salta proprietà definite come non enumerabili tramite Object.defineProperty. Questo comportamento permette di nascondere dettagli implementativi dall’iterazione.

const oggetto = { visibile: 1 };

Object.defineProperty(oggetto, "nascosta", {
  value: 2,
  enumerable: false,
});

for (const chiave in oggetto) {
  console.log(chiave); // Solo "visibile"
}

console.log(oggetto.nascosta); // 2 (la proprietà esiste ma non è enumerabile)

For-In con Oggetti Complessi

For-in funziona con oggetti annidati ma itera solo sulle chiavi del primo livello. Per attraversamento profondo, è necessario ricorsione o librerie specializzate.

const config = {
  server: {
    host: "localhost",
    port: 3000,
  },
  database: {
    nome: "app_db",
    user: "admin",
  },
};

for (const sezione in config) {
  console.log(`Sezione: ${sezione}`);
  for (const chiave in config[sezione]) {
    console.log(`  ${chiave}: ${config[sezione][chiave]}`);
  }
}

Record e Index Signatures

For-in funziona naturalmente con tipi Record e oggetti con index signatures, dove tutte le chiavi hanno lo stesso tipo di valore.

type Punteggi = Record<string, number>;

const punteggi: Punteggi = {
  matematica: 95,
  storia: 87,
  scienze: 92,
};

for (const materia in punteggi) {
  console.log(`${materia}: ${punteggi[materia]}/100`);
}

// Index signature
interface Dizionario {
  [chiave: string]: string;
}

const traduzioni: Dizionario = {
  hello: "ciao",
  goodbye: "arrivederci",
};

for (const inglese in traduzioni) {
  console.log(`${inglese} = ${traduzioni[inglese]}`);
}

Alternative Moderne

TypeScript e JavaScript moderno offrono alternative più sicure e espressive: Object.keys(), Object.values(), Object.entries() restituiscono array che possono essere iterati con for-of o metodi di array.

const prodotto = {
  nome: "Laptop",
  prezzo: 999,
  disponibile: true,
};

// Object.keys()
Object.keys(prodotto).forEach((chiave) => {
  console.log(chiave);
});

// Object.values()
Object.values(prodotto).forEach((valore) => {
  console.log(valore);
});

// Object.entries() - più pratico
Object.entries(prodotto).forEach(([chiave, valore]) => {
  console.log(`${chiave}: ${valore}`);
});

Performance

For-in è generalmente più lento rispetto a cicli for classici o for-of su array, a causa del controllo della catena prototipale. Per operazioni critiche per performance su oggetti con molte proprietà, considerare alternative o caching delle chiavi.

// Più lento
for (const chiave in grandeOggetto) {
  elabora(grandeOggetto[chiave]);
}

// Potenzialmente più veloce
const chiavi = Object.keys(grandeOggetto);
for (let i = 0; i < chiavi.length; i++) {
  elabora(grandeOggetto[chiavi[i]]);
}

Controllo di Flusso

For-in supporta break e continue come i cicli tradizionali, permettendo di interrompere o saltare iterazioni in base a condizioni.

const dati = {
  a: 1,
  b: 2,
  c: 3,
  d: 4,
};

for (const chiave in dati) {
  if (chiave === "c") break; // Interrompe al raggiungimento di 'c'
  console.log(chiave);
}

for (const chiave in dati) {
  if (dati[chiave] % 2 === 0) continue; // Salta valori pari
  console.log(`${chiave}: ${dati[chiave]}`);
}

Casi d’Uso Appropriati

For-in è appropriato quando si deve iterare dinamicamente su proprietà di oggetti semplici, specialmente quando le chiavi non sono note a priori. È utile per serializzazione, validazione, o trasformazione di oggetti di configurazione.

// Validazione dinamica
function valida(
  oggetto: Record<string, any>,
  regole: Record<string, Function>
): boolean {
  for (const campo in regole) {
    if (!regole[campo](oggetto[campo])) {
      return false;
    }
  }
  return true;
}

// Filtraggio proprietà
function filtraProprietaNulle<T extends object>(obj: T): Partial<T> {
  const risultato: any = {};
  for (const chiave in obj) {
    if (obj[chiave] !== null && obj[chiave] !== undefined) {
      risultato[chiave] = obj[chiave];
    }
  }
  return risultato;
}

Conclusioni

Il ciclo for-in rimane uno strumento utile per iterazione su proprietà di oggetti, ma richiede attenzione per evitare trappole comuni come iterazione su prototipi o uso improprio con array. Le alternative moderne come Object.keys/values/entries offrono spesso approcci più sicuri e leggibili, rendendo for-in appropriato principalmente per casi specifici dove l’iterazione dinamica su proprietà è necessaria e le sue limitazioni sono comprese e gestite correttamente.