Jamdesk Documentation logo

Diagrammi D2

Genera diagrammi di architettura, flowchart, sequenze e modelli SQL dalla sintassi testuale D2. I diagrammi vengono resi come SVG che seguono il tema del sito.

Usa D2 quando un diagramma richiede contenitori annidati e confini, uno schema di database con chiavi primarie ed esterne, oppure un layout che puoi regolare cambiando motore. Mermaid resta adatto ai flowchart rapidi. Passa a D2 quando la struttura diventa architetturale. Si scrive D2 allo stesso modo di Mermaid, in un blocco di codice recintato nel tuo Markdown.

Utilizzo di base

Usa un blocco di codice recintato con l'identificatore di linguaggio d2:

```d2
a -> b -> c
```

Tipi di diagrammi

Architettura

I diagrammi di architettura mostrano come i servizi si connettono. Usa forme etichettate per illustrare il percorso delle richieste nel tuo sistema.

```d2
Client: Web Client
API: API Server
Database: { shape: cylinder }

Client -> API: request
API -> Database: query
```

Contenitori

I contenitori raggruppano nodi correlati. Annida forme dentro { } per modellare confini come un account cloud o un deployment. Poi disegna connessioni che attraversano quei confini.

```d2
cloud: Cloud {
  api: API
  worker: Worker
}

queue: Message Queue

cloud.api -> queue: publish
queue -> cloud.worker: consume
```

Diagrammi di sequenza

I diagrammi di sequenza mostrano come i componenti comunicano nel tempo. Imposta shape: sequence_diagram su un contenitore. Elenca i messaggi in ordine per documentare un flusso di API o di autenticazione.

```d2
flow: {
  shape: sequence_diagram

  Client -> Server: request
  Server -> Database: query
  Database -> Server: results
  Server -> Client: response
}
```

Diagrammi delle classi

I diagrammi di classe documentano la struttura dei sistemi orientati agli oggetti. Imposta shape: class su un nodo ed elenca i suoi campi e metodi. Prefissa i membri con + per pubblico, - per privato o # per protetto. Collega le classi per mostrare le loro relazioni.

```d2
User: {
  shape: class
  +name: string
  +email: string
  +login(): void
  +logout(): void
}

Order: {
  shape: class
  +id: int
  +created: date
  +addItem(): void
  +checkout(): void
}

Item: {
  shape: class
  +name: string
  +price: float
}

User -> Order: places
Order -> Item: contains
```

Diagrammi di stato

I diagrammi di stato modellano il ciclo di vita di un oggetto o di un processo. D2 non ha una forma dedicata ai diagrammi di stato. Modella gli stati come ovali o cerchi, poi disegna transizioni etichettate tra di essi.

```d2
Draft: { shape: oval }
Review: { shape: oval }
Published: { shape: oval }
Archived: { shape: oval }

Draft -> Review: submit
Review -> Published: approve
Review -> Draft: request changes
Published -> Archived: archive
```

Tabelle SQL

Le forme di tabella SQL documentano uno schema di database con colonne e tipi. Contrassegna una colonna con { constraint: primary_key } o { constraint: foreign_key } per visualizzare i badge PK e FK. Collega una chiave esterna alla tabella a cui fa riferimento per mostrare la relazione.

```d2
users: {
  shape: sql_table
  id: int { constraint: primary_key }
  email: varchar
}

orders: {
  shape: sql_table
  id: int { constraint: primary_key }
  user_id: int { constraint: foreign_key }
  total: decimal
}

orders.user_id -> users.id
```

Forme

Imposta un shape su qualsiasi nodo per cambiarne il rendering:

SintassiFormaUtilizzo
shape: rectangleRettangoloNodi predefiniti, processi
shape: circleCerchioStati, nodi semplici
shape: cylinderCilindroDatabase, archiviazione
shape: cloudNuvolaServizi esterni, reti
shape: diamondRomboDecisioni, condizioni
shape: personPersonaUtenti, attori
shape: sql_tableTabella SQLSchemi di database, modelli ER

Connessioni

Le connessioni definiscono direzione e relazioni tra i nodi:

SintassiDescrizioneUtilizzo
a -> bFreccia orientataFlusso normale
a -- bLinea non orientataAssociazioni
a <-> bFreccia bidirezionaleScambio a due vie
a <- bFreccia inversaFlusso inverso
a -> b: labelConnessione etichettataDescrive la relazione

Scelta del motore di layout

D2 include diversi motori di layout. Quello predefinito è dagre. Passa a ELK per grafi più densi usando il blocco di configurazione nativo di D2 nel sorgente del diagramma. In questa release nessuna prop del componente imposta il motore.

```d2
vars: {
  d2-config: {
    layout-engine: elk
  }
}

ingress -> service -> database
```

I diagrammi larghi scorrono orizzontalmente all'interno del loro contenitore. Non escono mai dalla pagina.

Suggerimenti per lo stile

Jamdesk genera i diagrammi D2 come SVG a doppio tema. I colori restano leggibili in ogni tema senza alcuna configurazione.

  • Mantieni ogni diagramma piccolo: suddividi un sistema grande in viste mirate.
  • Etichetta ogni connessione con la sua relazione.
  • Raggruppa i nodi correlati in contenitori invece di un unico grafo piatto.
  • Passa al motore di layout ELK per grafi densi con molte connessioni.

D2 e Mermaid

D2 e Mermaid vengono renderizzati in fase di build. Scegli in base all'adattamento:

  • Scegli D2 per diagrammi di architettura e infrastruttura, modelli SQL ed ER, visualizzazioni in stile schizzo e quando vuoi poter scegliere il motore di layout.
  • Scegli Mermaid per flowchart, diagrammi di Gantt e grafi Git. La sintassi di sequenza di Mermaid ha più funzionalità di quella di D2. I diagrammi di sequenza D2 mantengono il resto del diagramma in un unico linguaggio. Mermaid è ampiamente adottato.

Consulta la pagina Diagrammi Mermaid per la sintassi e gli esempi di Mermaid.

Per saperne di più

Consulta la documentazione ufficiale di D2 per la sintassi completa, incluse stili, classi e animazioni.

Qual è il prossimo passo?

Diagrammi Mermaid

Genera flowchart e diagrammi di sequenza con Mermaid

Panoramica dei componenti

Esplora tutti i componenti disponibili