const api = {
  url: "/v1",
  timeout: 5000
};

type User = {
  id: string;
  role: "admin";
};

async function
  fetch(url) {}

SELECT name
FROM users;

$ git push
✓ deployed

@Module({})
class App {}

const [state, setState]
  = useState(null);

FROM node:20
WORKDIR /app
CMD ["npm", "start"]

def main():
    print("Hello")
    return True

query {
  user(id: 1) {
    name
  }
}

fn main() {
    let x = 42;
    println!("{}", x);
}

.container {
  display: grid;
  gap: 1rem;
}

func handler(w http.
  ResponseWriter) {}

{
  "name": "app",
  "version": "1.0"
}

#!/bin/bash
npm run build
echo "Done ✓"

interface Props {
  children: ReactNode;
  onClick?: () => void;
}

apiVersion: v1
kind: Service
metadata:
  name: api

struct App: View {
  var body: some View
}

</>{ }=>||[ ]::// todo!=&&

✦

✡

→

∞

↔

Caricamento...

Torna al blog

TypeScript

5 Dic 2024•12 min di lettura

TypeScript: pattern avanzati per backend robusti

Esploriamo pattern come Branded Types, Result Pattern e Dependency Injection per scrivere codice backend più sicuro.

Oltre le basi di TypeScript

TypeScript offre molto più della semplice tipizzazione. Vediamo alcuni pattern avanzati che uso quotidianamente nei miei progetti backend.

Branded Types

I branded types permettono di creare tipi nominali in TypeScript, evitando errori di confusione tra valori strutturalmente identici.

typescript

1type UserId = string & { readonly brand: unique symbol };
2type OrderId = string & { readonly brand: unique symbol };
3
4function getUserById(id: UserId) { /* ... */ }
5function getOrderById(id: OrderId) { /* ... */ }
6
7// Errore! Non puoi passare un OrderId dove serve un UserId
8getUserById(orderId);

Result Pattern

Invece di lanciare eccezioni, ritorna risultati espliciti:

typescript

1type Result<T, E> = 
2  | { success: true; data: T }
3  | { success: false; error: E };
4
5function parseUser(json: string): Result<User, ParseError> {
6  try {
7    return { success: true, data: JSON.parse(json) };
8  } catch {
9    return { success: false, error: new ParseError() };
10  }
11}

Dependency Injection con TypeScript

Usa i types per definire contratti chiari:

typescript

1interface UserRepository {
2  findById(id: UserId): Promise<User | null>;
3  save(user: User): Promise<void>;
4}
5
6class UserService {
7  constructor(private readonly repo: UserRepository) {}
8  
9  async getUser(id: UserId) {
10    return this.repo.findById(id);
11  }
12}

Conclusione

Questi pattern non sono solo "eleganti" - prevengono bug reali e rendono il codice più manutenibile. Inizia ad applicarli gradualmente nei tuoi progetti.

#backend#javascript#performance#best-practices

Condividi questo articolo:

PrecedenteArchitettura microservizi: quando ha senso?

SuccessivoFlutter vs React Native nel 2024

Ti è piaciuto questo articolo?

Iscriviti alla newsletter per ricevere nuovi contenuti direttamente nella tua inbox.

Torna al blog

TypeScript

5 Dic 2024•12 min di lettura

TypeScript: pattern avanzati per backend robusti

Esploriamo pattern come Branded Types, Result Pattern e Dependency Injection per scrivere codice backend più sicuro.

Oltre le basi di TypeScript

TypeScript offre molto più della semplice tipizzazione. Vediamo alcuni pattern avanzati che uso quotidianamente nei miei progetti backend.

Branded Types

I branded types permettono di creare tipi nominali in TypeScript, evitando errori di confusione tra valori strutturalmente identici.

typescript

1type UserId = string & { readonly brand: unique symbol };
2type OrderId = string & { readonly brand: unique symbol };
3
4function getUserById(id: UserId) { /* ... */ }
5function getOrderById(id: OrderId) { /* ... */ }
6
7// Errore! Non puoi passare un OrderId dove serve un UserId
8getUserById(orderId);

Result Pattern

Invece di lanciare eccezioni, ritorna risultati espliciti:

typescript

1type Result<T, E> = 
2  | { success: true; data: T }
3  | { success: false; error: E };
4
5function parseUser(json: string): Result<User, ParseError> {
6  try {
7    return { success: true, data: JSON.parse(json) };
8  } catch {
9    return { success: false, error: new ParseError() };
10  }
11}

Dependency Injection con TypeScript

Usa i types per definire contratti chiari:

typescript

1interface UserRepository {
2  findById(id: UserId): Promise<User | null>;
3  save(user: User): Promise<void>;
4}
5
6class UserService {
7  constructor(private readonly repo: UserRepository) {}
8  
9  async getUser(id: UserId) {
10    return this.repo.findById(id);
11  }
12}

Conclusione

Questi pattern non sono solo "eleganti" - prevengono bug reali e rendono il codice più manutenibile. Inizia ad applicarli gradualmente nei tuoi progetti.

#backend#javascript#performance#best-practices

Condividi questo articolo:

PrecedenteArchitettura microservizi: quando ha senso?

SuccessivoFlutter vs React Native nel 2024

Ti è piaciuto questo articolo?

Iscriviti alla newsletter per ricevere nuovi contenuti direttamente nella tua inbox.

Luca Frattini | Software Developer

TypeScript: pattern avanzati per backend robusti

Oltre le basi di TypeScript

Branded Types

Result Pattern

Dependency Injection con TypeScript

Conclusione

Articoli correlati

Architettura microservizi: quando ha senso?

PostgreSQL: ottimizzazione query per applicazioni real-world

Ti è piaciuto questo articolo?

TypeScript: pattern avanzati per backend robusti

Oltre le basi di TypeScript

Branded Types

Result Pattern

Dependency Injection con TypeScript

Conclusione

Articoli correlati

Architettura microservizi: quando ha senso?

PostgreSQL: ottimizzazione query per applicazioni real-world

Ti è piaciuto questo articolo?