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:
| Sintassi | Forma | Utilizzo |
|---|---|---|
shape: rectangle | Rettangolo | Nodi predefiniti, processi |
shape: circle | Cerchio | Stati, nodi semplici |
shape: cylinder | Cilindro | Database, archiviazione |
shape: cloud | Nuvola | Servizi esterni, reti |
shape: diamond | Rombo | Decisioni, condizioni |
shape: person | Persona | Utenti, attori |
shape: sql_table | Tabella SQL | Schemi di database, modelli ER |
Connessioni
Le connessioni definiscono direzione e relazioni tra i nodi:
| Sintassi | Descrizione | Utilizzo |
|---|---|---|
a -> b | Freccia orientata | Flusso normale |
a -- b | Linea non orientata | Associazioni |
a <-> b | Freccia bidirezionale | Scambio a due vie |
a <- b | Freccia inversa | Flusso inverso |
a -> b: label | Connessione etichettata | Descrive 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.
