Probador de XPath y JSONPath

Funciones

• Una sola pantalla, dos sintaxis: XPath para HTML / XML, JSONPath para JSON
• Ejes de XPath: hijo `/` y descendiente `//`, los dos que necesita la extracción
• Pruebas de nodo de XPath: nombres de etiqueta, `*`, `@atributo` y `text()`, sin distinguir mayúsculas
• Predicados de XPath: `[1]`, `[last()]`, `[@a]`, `[@a="v"]`, `[contains(@a,"v")]`, `[starts-with(@a,"v")]` y más
• JSONPath: `.key`, `["key"]`, `[*]`, `..` para descendientes, `[0]` con uniones y cortes `[1:3]`
• Filtros de JSONPath: `[?(@.price < 100)]` con comparaciones `==` `!=` `<` `>`, `&&`, `||` y paréntesis
• JSONPath también puede imprimir la ubicación de cada coincidencia (ruta con `$`), lista para pegar en el código
• Cuatro salidas: texto/valor, código HTML, ubicación o solo la cantidad
• Los predicados de posición siguen la semántica real de XPath: `//a[1]` es el primer `a` bajo cada padre
• Cada resultado lleva un índice desde 1 y se copia por separado; los objetos se copian con el JSON embellecido
• Una frase cuando no coincide nada, en vez de un panel vacío
• La sintaxis no admitida da error, así que nunca se confunde con una coincidencia vacía
• El HTML mal formado también se analiza: una etiqueta sin cerrar no tumba la consulta

Cómo se usa

1. Elige la sintaxis: XPath (HTML / XML) o JSONPath (JSON)
2. Pega el código o el JSON y escribe una expresión, como //a/@href o $.store.book[*].title
3. Elige la salida: texto/valor, código HTML, ubicación o solo la cantidad
4. El resultado se actualiza al escribir; copia una fila con su botón

Preguntas frecuentes

¿Qué sintaxis de XPath se admite?

Los ejes son hijo `/` y descendiente `//`; las pruebas de nodo son nombres de etiqueta, `*`, `@atributo` y `text()`; los predicados son `[1]`, `[last()]`, `[@a]`, `[@a="v"]`, `[text()="v"]`, `[contains(@a,"v")]`, `[starts-with(@a,"v")]` y dos unidos con `and`; y la única función es un `count(...)` por fuera. Cualquier cosa fuera de eso da «no admitido», por ejemplo `position()>1`, comparaciones `!=`, ejes como `ancestor::` y espacios de nombres. Se da error en vez de devolver nada porque ambas cosas se ven igual en pantalla, y el caso vacío te enviaría a buscar un fallo en un selector que estaba bien.

¿Por qué `//a[1]` selecciona varios elementos?

Porque selecciona el primer `a` bajo cada padre, no el primer `a` del documento: eso es lo que especifica XPath (`//a` significa «los hijos `a` de cualquier nodo», y un predicado de posición se aplica dentro de cada grupo por separado). Para la primera coincidencia del documento se escribiría `(//a)[1]`, que esta herramienta no admite; toma la primera fila del resultado. Es la parte de XPath que más se malinterpreta, y por eso se conserva la semántica estándar en vez de «arreglarla» por comodidad.

¿Por qué mi extracción de enlaces salió vacía?

Comprueba tres cosas: si el nombre del atributo es correcto (`href`, no `link`); si el enlace está en otro atributo (algunos sitios usan `data-href` u `onclick`); y si el contenido lo genera un script: esta herramienta analiza el código que pegaste, así que si ese código salió de «ver código fuente» en una página renderizada con JavaScript, los elementos nunca estuvieron ahí. Copia el HTML ya renderizado desde el panel Elements. La herramienta nunca pide la URL, y es a propósito.

¿Qué sintaxis de JSONPath se admite?

La raíz `$` (opcional), el acceso a hijos `.key` y `['key']`, los comodines `[*]` y `.*`, la búsqueda en descendientes `..`, los índices y uniones `[0]` y `[0,2]`, los cortes `[1:3]` y las expresiones de filtro `[?(@.price < 100)]` con comprobación de existencia, comparaciones `==` `!=` `<` `<=` `>` `>=`, `&&`, `||`, paréntesis y negación `!`. Cualquier otra cosa da error: extensiones de función (`length()`, `count()`, `match()`, `search()`, `value()`), expresiones regulares y rutas absolutas con `$` dentro de un filtro.

¿Por qué mi JSONPath se diferencia del que da la biblioteca de mi código?

Porque JSONPath todavía no tiene un único estándar. El RFC 9535 no llegó hasta 2024 y, antes, las bibliotecas `jsonpath` de JavaScript, `jsonpath-ng` de Python y Jayway de Java iban cada una por su lado, sin coincidir en tres puntos: los límites de los cortes (¿`:3` incluye el tercer elemento?), si la búsqueda en descendientes incluye el propio nodo (¿puede `$..a` seleccionar el `a` de arriba del todo?) y si los filtros comparan entre tipos (`@.price < "10"` comparando una cadena con un número). Aquí se sigue el RFC 9535 en todo: los cortes son abiertos por la derecha, la búsqueda en descendientes incluye el propio nodo y las comparaciones entre tipos son falsas. Así que úsala para confirmar que una ruta está bien mientras depuras en local y luego verifícala con datos reales en tu biblioteca antes de publicarla.

¿Para qué sirve la salida «ubicación»?

Imprime, para cada coincidencia, su ruta dentro del documento, como `$.store.book[2].title`. Lo habitual suele ser al revés: ves qué aspecto tiene un valor pero necesitas su posición en la estructura para fijar una ruta hacia él. Los valores por sí solos solo te dicen que hay resultados; las ubicaciones te dicen dónde están. Ojo: una clave con caracteres especiales se escribe `['a.b']`, que es lo que la mantiene distinta de `.a.b`.