Programmazione orientata alle railway
Concateni operazioni che possono fallire senza try/catch.
Programmazione orientata alle railway è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.
La metafora della ferrovia
La programmazione orientata alla ferrovia rappresenta un calcolo come due binari paralleli: un binario del successo e uno del fallimento. Una volta passati al fallimento, vi si rimane e si saltano i passaggi restanti.
Concatenare le funzioni Result
Ogni passaggio riceve un valore e restituisce un Result. L'obiettivo è collegare i passaggi in modo che il primo fallimento interrompa la catena e venga trasmesso fino alla fine.
type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };
const ok = <T>(value: T): Result<T, never> => ({ ok: true, value });
const err = <E>(error: E): Result<never, E> => ({ ok: false, error });map: trasformare il valore del successo
map applica una funzione normale al valore quando il Result è ok e trasmette i fallimenti senza modificarli. Rimane sul binario del successo.
function map<T, U, E>(r: Result<T, E>, f: (t: T) => U): Result<U, E> {
return r.ok ? ok(f(r.value)) : r;
}
console.log(map(ok(2), n => n + 1)); // { ok: true, value: 3 }flatMap: concatenare passaggi soggetti a errore
Quando il passaggio successivo restituisce a sua volta un Result, utilizzi flatMap (chiamato anche andThen). In questo modo si evita di annidare i Result e si interrompe la catena in caso di fallimento.
function flatMap<T, U, E>(r: Result<T, E>, f: (t: T) => Result<U, E>): Result<U, E> {
return r.ok ? f(r.value) : r;
}Perché flatMap e non map
Se utilizzasse map con una funzione che restituisce un Result, otterrebbe Result<Result<U,E>,E>. flatMap appiattisce quel livello, mantenendo un unico Result.
Interrompere la catena al primo errore
Non appena un passaggio restituisce err, ogni successivo flatMap lo trasmette senza modificarlo. I passaggi rimanenti non vengono mai eseguiti, proprio come quando si passa al binario del fallimento.
const start = err("boom") as Result<number, string>;
const out = flatMap(start, n => ok(n + 1));
console.log(out); // { ok: false, error: "boom" }Costruire una pipeline
Componete i passaggi di validazione, ognuno dei quali restituisce un Result. Il primo fallimento diventa il risultato della pipeline; se tutti i passaggi hanno esito positivo, il valore del successo arriva fino alla fine.
function parseNum(s: string): Result<number, string> {
const n = Number(s);
return Number.isNaN(n) ? err("not a number") : ok(n);
}
function positive(n: number): Result<number, string> {
return n > 0 ? ok(n) : err("must be positive");
}Eseguire la pipeline
Concatenare flatMap fa passare il valore attraverso ogni passaggio soggetto a errore. Un fallimento in qualsiasi punto interrompe la catena e rende disponibile quell'errore.
const good = flatMap(parseNum("5"), positive);
console.log(good); // { ok: true, value: 5 }
const bad = flatMap(parseNum("-3"), positive);
console.log(bad); // { ok: false, error: "must be positive" }Combinare map e flatMap
Utilizzi flatMap per i passaggi che possono fallire e map per le trasformazioni pure. Insieme mantengono lineare il percorso principale e gestiscono automaticamente gli errori.
const result = map(flatMap(parseNum("10"), positive), n => n * 2);
console.log(result); // { ok: true, value: 20 }Non serve try/catch
L'intera pipeline esprime il successo e il fallimento attraverso i valori. Non c'è alcun try/catch e il tipo di ogni passaggio rende il percorso dell'errore esplicito e impossibile da ignorare.
Perché è scalabile
Il codice orientato alla ferrovia mantiene leggibili i flussi di lavoro complessi: ogni passaggio è piccolo e puro, gli errori si propagano automaticamente e aggiungere un passaggio non complica la gestione degli errori esistente.
Verifica rapida
Verifica rapida su questa lezione.
Riepilogo
La programmazione orientata alla ferrovia concatena passaggi che restituiscono Result con map (trasforma il successo) e flatMap/andThen (concatena i passaggi soggetti a errore e appiattisce i Result annidati). Il primo err interrompe i passaggi restanti e si propaga fino alla fine, senza try/catch.
Impara TypeScript con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 101
- Lezioni
- 352
Domande Frequenti
La lezione «Programmazione orientata alle railway» è gratuita?
Sì — il testo completo di «Programmazione orientata alle railway» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.
Cosa imparerò in «Programmazione orientata alle railway»?
Concateni operazioni che possono fallire senza try/catch. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare TypeScript Academy?
Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Programmazione orientata alle railway»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?
Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Il problema del lancio degli errori
- Modellare i tipi Result
- Tipi Option e Maybe
- Programmazione orientata alle railway