# Comprendere il codice esistente (/it/docs/verdent-for-vscode/task-based-guides/understanding-code)
> Usare Verdent per esplorare, analizzare e comprendere codebase esistenti
Verdent for VS Code ti aiuta a comprendere codebase sconosciute grazie a domande in linguaggio naturale e all'esplorazione automatizzata. Il sottoagente Explorer integrato trova rapidamente i file, cerca pattern nel codice e risponde a domande sull'architettura senza consumare la finestra di contesto principale.
### Cosa imparerai [#cosa-imparerai]
* Esplorare codebase sconosciute con il sottoagente Explorer
* Porre domande sulla struttura del codice e sull'implementazione
* Ottenere spiegazioni dettagliate di funzioni, classi e moduli
* Generare documentazione a partire dal codice esistente
* Comprendere l'architettura di un progetto e il flusso dei dati
* Inserire in modo efficiente i nuovi membri del team
### Prerequisiti [#prerequisiti]
Prima di usare Verdent per comprendere il codice:
* Visual Studio Code con l'estensione Verdent installata
* Una codebase o un workspace di progetto aperto in VS Code
* Un abbonamento Verdent attivo con crediti disponibili
***
## Esplorare codebase sconosciute [#esplorare-codebase-sconosciute]
Quando poni domande sulla struttura della codebase o richiedi ricerche di file, Verdent delega automaticamente al **sottoagente Explorer** (`@Explorer`), uno specialista efficiente nell'uso dei token e ottimizzato per un'esplorazione rapida della codebase.
Il sottoagente Explorer, in modo rapido:
* Trova i file che corrispondono a pattern o nomi
* Cerca nel codice parole chiave o funzioni specifiche
* Risponde a domande sull'architettura della codebase
* Identifica dove è implementata una determinata funzionalità
**Esempi di domande di esplorazione:**
```
What is the structure of this project?
```
```
Where is user authentication handled?
```
```
Find all API endpoint definitions
```
```
Show me where database queries are defined
```
L'Explorer lavora in modo efficiente in background, fornendo risposte rapide senza consumare la finestra di contesto principale. Verdent presenta i risultati con i percorsi dei file pertinenti e frammenti di codice.
**Esplorazione parallela per attività complesse:**
Per attività di esplorazione complesse, più agenti Explorer possono essere eseguiti in parallelo per risparmiare tempo, ciascuno indagando contemporaneamente un aspetto diverso della codebase. Verdent sintetizza poi i risultati in un riepilogo coerente.
**Esempio:**
```
Use the Explorer agent to find all places where we manually validate email addresses
```
In questo modo Verdent individua sistematicamente ogni occorrenza senza perderne nessuna nella codebase.
***
## Porre domande sul tuo codice [#porre-domande-sul-tuo-codice]
Verdent risponde praticamente a qualsiasi domanda sulla tua codebase usando il linguaggio naturale. L'AI comprende il contesto e fornisce spiegazioni, analisi e approfondimenti dettagliati.
Chiedi come funziona una determinata funzionalità:
```
Explain how authentication works in this project
```
```
What does the calculateTotal function do?
```
```
How are API requests handled?
```
Verdent analizza il codice pertinente, traccia i flussi di esecuzione e spiega l'implementazione con riferimenti a file e numeri di riga specifici.
Comprendi il quadro generale della tua applicazione:
```
What is the overall architecture of this application?
```
```
How do the components communicate with each other?
```
```
What design patterns are used in this codebase?
```
Verdent esamina la struttura del tuo progetto, identifica i pattern e spiega le decisioni architetturali.
Ottieni approfondimenti sulle scelte tecniche:
```
Why do you think Redux was chosen instead of Context API for state management?
```
```
What would happen if I changed the API timeout from 30s to 60s?
```
```
Is this validateUserInput function redundant?
```
Verdent analizza il contesto del codice e fornisce spiegazioni motivate basate sui pattern del tuo progetto e sulle best practice del settore.
Trova funzionalità o dipendenze specifiche:
```
Where is user data validated?
```
```
Show me all database queries in the project
```
```
What dependencies does this project have?
```
Il sottoagente Explorer esegue ricerche efficienti con strumenti come grep (ricerca nei contenuti) e glob (corrispondenza di pattern nei file), restituendo risultati pertinenti senza consumare il contesto principale.
Comprendi algoritmi e pattern:
```
How does the quicksort algorithm work in the sortItems function?
```
```
What are the best practices for error handling in React components?
```
```
Explain the Observer pattern implementation in the EventEmitter class
```
Verdent fornisce spiegazioni chiare con riferimenti a implementazioni specifiche nella tua codebase.
***
## Spiegare funzioni e classi [#spiegare-funzioni-e-classi]
Verdent fornisce spiegazioni dettagliate di funzioni o classi specifiche analizzandone l'implementazione, i parametri, i valori di ritorno e l'utilizzo nell'intera codebase.
**Esempi:**
```
Explain the UserAuth class
```
```
What does the processPayment function do?
```
```
Break down the ApiService class methods
```
**Cosa spiega Verdent:**
* **Scopo**: cosa realizza la funzione o la classe
* **Parametri**: tipi di input, valori attesi e vincoli
* **Tipi di ritorno**: tipi di output e possibili valori restituiti
* **Logica interna**: come funziona l'implementazione passo dopo passo
* **Dipendenze**: moduli, funzioni o servizi esterni utilizzati
* **Esempi di utilizzo**: come la funzione/classe viene usata altrove nel tuo codice
Verdent traccia il flusso di esecuzione del codice, identifica i casi limite e spiega le motivazioni dietro le scelte di implementazione.
***
## Generare documentazione [#generare-documentazione]
Verdent genera documentazione in più formati, tra cui commenti inline nel codice (JSDoc, docstring Python, ecc.), file README, documentazione API e guide all'architettura.
#### Usare Plan Mode per la documentazione [#usare-plan-mode-per-la-documentazione]
In Plan Mode, Verdent può:
* Analizzare la documentazione esistente per adeguarsi al suo stile e alla sua densità
* Porre domande di chiarimento sulle preferenze di formattazione (stile dei commenti, livello di dettaglio, inclusione di esempi)
* Analizzare la codebase per comprendere i pattern di documentazione attuali
* Presentare un piano di documentazione che mostra cosa verrà documentato e in quale stile
**Esempio:**
```
Generate JSDoc comments for all functions in the utils folder
```
Verdent esamina i commenti JSDoc esistenti nel tuo progetto, pone domande sulle preferenze (descrizione dei parametri, inclusione di esempi d'uso) e genera poi documentazione conforme alle convenzioni consolidate.
**Formati di documentazione supportati:**
* **Commenti inline**: JSDoc, docstring Python, Javadoc, commenti di documentazione XML
* **File README**: panoramiche del progetto, istruzioni di configurazione, guide all'uso
* **Documentazione API**: descrizioni degli endpoint, formati di richiesta/risposta, dettagli di autenticazione
* **Guide all'architettura**: spiegazioni della progettazione del sistema, relazioni tra componenti, diagrammi del flusso dei dati
Usa Plan Mode quando generi documentazione estesa. Verdent esaminerà lo stile della documentazione esistente e porrà domande di chiarimento per assicurarsi che i documenti generati rispettino le convenzioni del tuo progetto.
Usa Plan Mode quando generi documentazione per più file, rivedendo la struttura della documentazione prima di eseguire il commit.
***
## Riepilogare file e moduli [#riepilogare-file-e-moduli]
Verdent analizza e riepiloga file o moduli leggendo il codice, comprendendone la struttura e spiegandone lo scopo in linguaggio semplice.
**Esempi:**
```
Summarize what the authMiddleware.js file does
```
```
Explain the purpose of the UserService module
```
```
What's the main responsibility of the PaymentController?
```
**Cosa fornisce Verdent:**
* **Scopo principale**: cosa realizza il file/modulo nel sistema
* **Funzioni chiave**: le funzioni o i metodi principali e il loro ruolo
* **Dipendenze**: moduli e servizi esterni utilizzati
* **Export**: API pubbliche e cosa possono accedervi delle altre parti del sistema
* **Pattern**: pattern di progettazione o approcci architetturali utilizzati
* **Punti di integrazione**: come si collega con le altre parti del progetto
Verdent legge il file, identifica le funzioni chiave, traccia le dipendenze e spiega come il codice si inserisce nell'architettura complessiva del progetto.
***
## Comprendere l'architettura [#comprendere-larchitettura]
Verdent spiega l'architettura tramite descrizioni testuali dettagliate, relazioni tra componenti e spiegazioni del flusso dei dati. Pur non generando diagrammi grafici in modo diretto, può creare diagrammi in ASCII art o codice per diagrammi Mermaid che puoi poi renderizzare.
**Esempio:**
```
Explain the architecture of this application and show component relationships
```
Verdent potrebbe produrre una rappresentazione ASCII:
```
Frontend (React)
↓
API Layer (Express)
↓
Service Layer (Business Logic)
↓
Database Layer (PostgreSQL)
```
Oppure generare codice Mermaid per il rendering:
```mermaid
graph TD
A[React Frontend] --> B[API Gateway]
B --> C[Auth Service]
B --> D[User Service]
C --> E[Database]
D --> E
```
**Le spiegazioni dell'architettura includono:**
* **Interazioni tra componenti**: come comunicano le diverse parti del sistema
* **Flusso dei dati**: come le informazioni si muovono attraverso l'applicazione
* **Pattern architetturali**: MVC, microservizi, architettura a livelli, ecc.
* **Stack tecnologico**: frontend, backend, database, servizi esterni
* **Punti di integrazione**: API, code di messaggi, webhook, servizi di terze parti
* **Pattern di scalabilità**: bilanciamento del carico, caching, sharding del database
Verdent analizza la struttura del tuo progetto, traccia import e dipendenze, identifica i pattern e spiega le decisioni architetturali alla base del design del tuo sistema.
***
## Inserire nuovi membri del team [#inserire-nuovi-membri-del-team]
Verdent aiuta a inserire i nuovi membri del team rispondendo a domande sulla codebase, spiegando le decisioni architetturali, identificando file e pattern chiave e generando documentazione pensata per aiutare i nuovi arrivati a comprendere la struttura e le convenzioni del progetto.
**In Plan Mode**, Verdent può porre domande di chiarimento per capire quali aspetti della codebase siano più rilevanti per il ruolo del nuovo membro del team prima di creare una guida di onboarding personalizzata.
**Esempi di domande di onboarding:**
```
What's the best starting point for understanding this codebase?
```
```
How does data flow from the API to the frontend?
```
```
Where should I look to understand the authentication system?
```
```
What are the naming conventions and code style guidelines used here?
```
**Verdent può generare:**
* **Guide di onboarding**: percorsi passo-passo attraverso l'architettura della codebase
* **Mappe dei componenti**: guide visive o testuali che mostrano come i componenti sono in relazione
* **Pattern comuni**: documentazione dei pattern e delle convenzioni usati di frequente
* **Istruzioni di configurazione**: come configurare l'ambiente di sviluppo ed eseguire il progetto
* **Prime attività**: suggerimenti per semplici primi contributi con cui prendere familiarità
I nuovi membri del team possono esplorare la codebase in modo conversazionale, ottenendo risposte immediate senza dover interrompere gli sviluppatori senior o passare ore a leggere il codice.
Il sottoagente Explorer di Verdent rende efficiente la scoperta della codebase per i nuovi arrivati. Possono porre domande ampie come "Mostrami tutti i componenti React" o query specifiche come "Dove è implementato il logging degli errori?" e ottenere risposte immediate e accurate.
***
## Best practice [#best-practice]
Inizia con domande di alto livello come "Qual è l'architettura?" prima di addentrarti in implementazioni specifiche. In questo modo costruisci il contesto in modo progressivo.
Per ricerche approfondite nell'intera codebase, menziona esplicitamente l'agente Explorer per assicurarti di non perdere alcuna occorrenza: "Usa Explorer per trovare tutti i controlli di autenticazione".
Comprendere le motivazioni dietro le decisioni è spesso più prezioso che comprendere l'implementazione. Chiedi "Perché è stato scelto questo pattern?" insieme a "Cosa fa questo codice?".
Quando generi documentazione, usa Plan Mode per rivedere l'approccio di Verdent, assicurarti che rispetti il tuo stile e perfezionare il piano prima dell'esecuzione.
Fai riferimento a file specifici quando vuoi spiegazioni dettagliate: "@components/UserProfile.tsx spiega questo componente" fa sì che Verdent si concentri sul codice giusto.
Prima di apportare modifiche, chiedi a Verdent di spiegare l'implementazione attuale. Questo aiuta Verdent a fornire suggerimenti migliori, in linea con i pattern esistenti.
Verdent mantiene il contesto della conversazione, così puoi porre domande di chiarimento, richiedere spiegazioni più approfondite o esplorare argomenti correlati senza ripetere il contesto.
***
## Vedi anche [#vedi-anche]
Scopri come scrivere nuove funzionalità e componenti con Verdent
Migliora e rifattorizza il codice esistente in modo sicuro con l'assistenza dell'AI