XPath insensible a mayúsculas y minúsculas contiene () posible?

Question 1

Estoy revisando todos los nodos de texto de mi DOM y verifico si el nodeValue contiene una determinada cadena.

/html/body//text()[contains(.,'test')]

Esto es sensible a mayúsculas y minúsculas. Sin embargo, también quiero atrapar Test, TEST o TesT. ¿Es eso posible con XPath (en JavaScript)?

Question 2

Esto es para XPath 1.0. Si su entorno es compatible con XPath 2.0, consulte aquí.

Si. Posible, pero no hermoso.

/html/body//text()[
  contains(
    translate(., 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'),
    'test'
  )
]

Esto funcionaría para cadenas de búsqueda donde el alfabeto se conoce de antemano. Agregue los caracteres acentuados que espera ver.

Si puedes, marca el texto que te interesa con algún otro medio, como encerrarlo en un <span> que tiene una cierta clase mientras construye el HTML. Esas cosas son mucho más fáciles de localizar con XPath que las subcadenas en el texto del elemento.

Si esa no es una opción, puede dejar que JavaScript (o cualquier otro lenguaje host que esté usando para ejecutar XPath) lo ayude a crear una expresión XPath dinámica:

function xpathPrepare(xpath, searchString) {
  return xpath.replace("$u", searchString.toUpperCase())
              .replace("$l", searchString.toLowerCase())
              .replace("$s", searchString.toLowerCase());
}

xp = xpathPrepare("//text()[contains(translate(., '$u', '$l'), '$s')]", "Test");
// -> "//text()[contains(translate(., 'TEST', 'test'), 'test')]"

^{(Sugerencia para la respuesta de @KirillPolishchuk: por supuesto, solo necesita traducir los caracteres que realmente está buscando por.)}

Este enfoque funcionaría para cualquier cadena de búsqueda, sin necesidad de un conocimiento previo del alfabeto, lo cual es una gran ventaja.

Ambos métodos anteriores fallan cuando las cadenas de búsqueda pueden contener comillas simples, en cuyo caso las cosas se complican más.

Question 3

no distingue entre mayúsculas y minúsculas contains

/html/body//text()[contains(translate(., 'EST', 'est'), 'test')]

Question 4

Soluciones XPath 2.0

Utilizar minúsculas():

/html/body//text()[contains(lower-case(.),'test')]
Utilizar partidos() coincidencia de expresiones regulares con su indicador que no distingue entre mayúsculas y minúsculas:

/html/body//text()[matches(.,'test', 'i')]

Question 5

Si. Puedes usar translate para convertir el texto que desea hacer coincidir a minúsculas de la siguiente manera:

/html/body//text()[contains(translate(., 
                                      'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
                                      'abcdefghijklmnopqrstuvwxyz'),
                   'test')]

Question 6

Si está utilizando XPath 2.0, puede especificar una intercalación como el tercer argumento de contains(). Sin embargo, los URI de intercalación no están estandarizados, por lo que los detalles dependen del producto que esté utilizando.

Tenga en cuenta que todas las soluciones dadas anteriormente usando translate() asumen que solo está usando el alfabeto inglés de 26 letras.

ACTUALIZAR: XPath 3.1 define un URI de intercalación estándar para la coincidencia entre mayúsculas y minúsculas.

Question 7

La forma en que siempre hice esto fue usando la función “traducir” en XPath. No diré que es muy bonito, pero funciona correctamente.

/html/body//text()[contains(translate(.,'abcdefghijklmnopqrstuvwxyz',
                                        'ABCDEFGHIJKLMNOPQRSTUVWXYZ'),'TEST')]

espero que esto ayude,

Soluciones XPath 2.0

¿Ha sido útil esta solución?