CodeKitHubChe cos'è questo strumento?
XPath (XML Path Language) è uno standard del W3C per navigare e selezionare nodi — elementi, attributi, testo — all'interno di un documento XML tramite una sintassi compatta simile a un percorso, ad esempio `//book[price>30]/title` seleziona ogni `<title>` il cui `<price>` fratello sia maggiore di 30, ovunque nel documento. Viene usato dai fogli di stile XSLT, dagli strumenti di validazione XML, dagli scraper web, dai framework di automazione del browser (Selenium, Playwright) e dalle librerie XML di molti linguaggi di programmazione.
La versione attuale implementata da tutti i principali browser — Chrome, Firefox, Safari, Edge — è XPath 1.0, la Raccomandazione W3C originale del 1999. Questo strumento usa esattamente quel motore nativo tramite l'API `document.evaluate()` del browser, quindi i risultati qui corrispondono a quelli che otterresti dagli strumenti per sviluppatori del browser o da qualsiasi JavaScript eseguito in un browser. Non implementa le specifiche successive XPath 2.0/3.0/3.1 (che aggiungono funzionalità come espressioni `for`, sequenze e corrispondenze con espressioni regolari): consulta le FAQ per capire cosa significa in pratica.
Un'espressione può restituire uno di due tipi di risultato: un insieme di nodi (node-set — zero o più elementi, attributi o nodi di testo corrispondenti, che questo strumento serializza ed elenca uno per riga insieme a un conteggio), oppure un valore scalare — un numero, una stringa o un booleano — quando l'espressione stessa calcola un valore, come `count(//book)` o `//book[1]/title = 'Dune'`.
Perché usarlo?
- Eseguire il debug di un'espressione XPath prima di inserirla in modo definitivo in uno scraper web, in un test Selenium/Playwright o in un foglio di stile XSLT.
- Verificare rapidamente se una determinata espressione XPath seleziona il nodo atteso su un campione reale di XML/HTML.
- Consultare conteggi di corrispondenze esatti e output serializzato invece di procedere per tentativi guardando il codice.
- Ottenere errori immediati e comprensibili in caso di XML malformato o sintassi XPath non valida, invece di uno stack trace criptico.
- 100% lato client: il tuo XML e la tua espressione non lasciano mai il browser.
Come si usa
- Incolla o modifica il tuo XML (o HTML) nel campo di input: un documento di esempio di una libreria è già precompilato così puoi vedere subito lo strumento in azione.
- Digita un'espressione XPath nel campo dedicato, oppure modifica l'esempio già precompilato.
- Clicca su "Valuta" (oppure premi Invio nel campo dell'espressione).
- Leggi i nodi corrispondenti mostrati sotto, con il conteggio in alto; i risultati scalari (numeri, stringhe, booleani) vengono mostrati direttamente.
- Se l'XML o l'espressione non sono validi, un messaggio di errore specifico sostituisce i risultati.
Esempio
Input
XML:
<bookstore>
<book><title>The Great Gatsby</title><price>12.99</price></book>
<book><title>Learning XPath</title><price>34.50</price></book>
<book><title>Dune</title><price>45.00</price></book>
</bookstore>
XPath: //book[price>30]/titleRisultato
✓ 2 node(s) matched
<title>Learning XPath</title>
<title>Dune</title>Solo 2 dei 3 libri hanno un prezzo superiore a 30, quindi vengono restituiti esattamente 2 elementi <title>: il terzo libro (Gatsby, 12,99 $) viene correttamente escluso.
XPath e selettori CSS a confronto
Entrambi i linguaggi selezionano nodi da un documento, ma risolvono problemi diversi. Usa questa tabella per scegliere lo strumento giusto per una determinata selezione.
| Capacità | XPath | Selettori CSS |
|---|---|---|
| Selezione per tag/classe/id scendendo nel documento | Sì | Sì, e di solito più veloce |
| Selezione per contenuto visibile/testuale | Sì — `contains(text(),'x')` | No |
| Risalita verso un genitore/antenato | Sì — `//div[span]/..` | No (`:has()` è un'eccezione parziale più recente) |
| Confronti tra valori di elementi fratelli (es. `price>30`) | Sì | No |
| Funziona fuori dal browser (strumenti XML lato server, XSLT) | Sì | No — i selettori CSS sono specifici del browser/DOM |
Strumenti correlati
Lavori con formati di dati strutturati? Questi strumenti si abbinano bene ai test XPath.
Domande frequenti
A cosa serve XPath?
XPath seleziona nodi — elementi, attributi o testo — da un documento XML o HTML usando una sintassi basata su percorsi. È il linguaggio di selezione alla base delle trasformazioni XSLT e di molti validatori XML, ed è ampiamente usato nel web scraping e nell'automazione dei test del browser (Selenium, Playwright, Cypress) per individuare elementi in una pagina, soprattutto quando i selettori CSS da soli non riescono a esprimere la condizione necessaria.
XPath o selettori CSS: quale usare?
Si sovrappongono ma non sono equivalenti. XPath può selezionare un elemento padre in base al contenuto di un figlio (`//div[span='Total']`), risalire verso gli antenati e selezionare in base al testo visibile (`//button[contains(text(),'Submit')]`) — i selettori CSS non possono risalire nell'albero né corrispondere in alcun modo al contenuto testuale. Se stai semplicemente selezionando per tag, classe o ID scendendo nel documento, i selettori CSS sono più semplici da scrivere e in genere più veloci da valutare. Ricorri a XPath in particolare quando ti serve "selezionare il genitore di questo testo" oppure "selezionare in base a cosa dice l'elemento", non solo in base a come è taggato o classificato.
Questo strumento supporta le funzioni di XPath 2.0 o 3.0?
No — e non lo fa nessun browser. I browser implementano XPath 1.0 (la Raccomandazione W3C del 1999) tramite `document.evaluate()`, e questo strumento usa esattamente quel motore nativo, quindi è fedele a ciò che otterresti eseguendo la stessa espressione negli strumenti per sviluppatori del browser o in JavaScript. Le funzioni e le funzionalità introdotte in XPath 2.0/3.0/3.1 (come le espressioni `for`, le sequenze o `matches()` con le regex) non sono disponibili: qui funzionano solo le funzioni della versione 1.0, come `contains()`, `starts-with()`, `substring()`, `count()`, `position()` e `last()`.
Quali sono alcune espressioni XPath comuni che dovrei conoscere?
`//tag` seleziona ogni `<tag>` presente nel documento. `//tag[@attr='value']` seleziona gli elementi `<tag>` il cui attributo `attr` è uguale a `value`. `//tag[contains(text(),'x')]` seleziona gli elementi `<tag>` il cui testo diretto contiene `x`. `//tag[1]` seleziona il primo `<tag>` fratello all'interno di ciascun genitore. `//parent/child` seleziona gli elementi `<child>` che sono figli diretti di `<parent>`. `count(//tag)` restituisce un numero invece di un insieme di nodi.
Questo strumento gestisce i namespace XML?
Viene gestito correttamente solo il caso comune senza namespace, che copre la stragrande maggioranza dell'XML/HTML scritto a mano o ottenuto tramite scraping. Se il tuo documento dichiara un namespace XML (ad esempio `xmlns="..."` sull'elemento radice), `document.evaluate` richiede una funzione di risoluzione consapevole dei namespace che associ i prefissi agli URI, cosa che questo semplice strumento non configura: le espressioni su XML con namespace possono quindi restituire zero corrispondenze anche quando sembrano corrette. Si tratta di un limite noto, non di un bug: rimuovi la dichiarazione del namespace dal tuo campione, oppure usa la funzione local-name() (ad esempio `//*[local-name()='title']`) come soluzione alternativa.
Il mio XML o la mia espressione XPath vengono inviati a un server?
No. Tutto viene eseguito localmente usando il `DOMParser` e il `document.evaluate()` integrati nel browser — lo stesso motore che il tuo browser usa già internamente. Nulla di ciò che digiti o incolli lascia mai il tuo dispositivo.