regulares - Compruebe si la cadena es un prefijo de un Javascript RegExp

regex javascript online

Question

En Javascript, he definido una expresión regular y ahora un usuario está escribiendo una cadena. Quiero decirle si su cadena todavía podría coincidir con RegExp si continúa escribiendo o si ya está en el camino equivocado. Por ejemplo:

var re = /a*b/;

"a".isPrefixOf( re ); // true
"x".isPrefixOf( re ); // false

¿Cómo podría ser una implementación de isPrefixOf ?

Actualización: Gracias por sus respuestas, hacer la expresión regular a prueba de prefijos, como sugiere brad, parece ser una buena solución. Pero todavía estoy tratando de encontrar una solución general.

Tal vez de esta manera: creamos una nueva expresión regular con la entrada del usuario seguida de .* . Esta expresión regular describe todas las palabras que el usuario aún puede ingresar. Si la intersección de esta expresión regular creada y la expresión regular original está vacía, entonces el usuario ya está en el camino equivocado. Si no es así, él está bien. Por ejemplo:

var re = /a*b/;
var sInput = "a";
var reInput = new RegExp( sInput + ".*" );

reIntersection = re.intersect( reInput );
reIntersection.isEmpty(); // false

intersect() devuelve una nueva expresión regular que acepta solo la palabra que reInput tanto re como reInput . La función aún no existe, pero podemos implementarla usando look-ahead:

RegExp.prototype.intersect = function( pattern2 ) { 
    return new RegExp( ''(?='' + this.source  + '')'' + pattern2.source );
}

Lo que permanece abierto es la función isEmpty() . ¿Cómo podríamos comprobar si una expresión regular de JavaScript coincide con una palabra o si está vacía?

Answer 1

Creo que tu mejor opción es hacer tu Regex a prueba de prefijos. Para el ejemplo que proporcionó, /a*b/ , creo que probablemente podría usar /a*b?/.test(userinput) . Para patrones más complejos, esto podría ser cada vez más difícil, pero todavía creo que se puede hacer anidando cada subexpresión en una serie de cuantificadores opcionales ( ? ). Por ejemplo:

/a*bcd*e/

El prefijo regex podría ser:

/a*(b(c(d*e?)?)?)?/

Es un poco desordenado, pero creo que resolverá tu problema bastante bien.

Answer 2

La gente parece estar dividida de manera uniforme sobre cómo interpretan esta pregunta, por lo que voy a demostrar el concepto con un ejemplo de Java.

import java.util.regex.*;

public class Test
{

  public static void main(String[] args) throws Exception
  {
    tryMatch("^a*b+$", "a", "ab", "abc");
  }

  public static void tryMatch(String regex, String... targets)
  {
    Pattern p = Pattern.compile(regex);
    Matcher m = p.matcher("");
    System.out.printf("%nregex: %s%n", regex);
    System.out.printf("target | matches() | hitEnd()%n");
    for (String str : targets)
    {
      m.reset(str);
      System.out.printf("%-6s | %-9B | %-9B%n",
          str, m.matches(), m.hitEnd());
    }
  }
}

salida:

regex: ^a*b+$
target | matches() | hitEnd()
a      | FALSE     | TRUE
ab     | TRUE      | TRUE
abc    | FALSE     | FALSE

La cadena de destino "a" no coincide porque la expresión regular requiere al menos una b , pero podría ser el prefijo de una coincidencia exitosa, por lo que hitEnd() devuelve true . La cadena "ab" tiene todo lo que se necesita para una coincidencia, pero también coincidiría si agregamos más b al final, por lo que hitEnd() aún devuelve true . Con "abc" el intento de coincidencia falla antes de que llegue al final de la cadena objetivo, por lo que la expresión regular no puede coincidir con ninguna cadena que comience con "abc".

Por lo que yo sé, Javascript no tiene nada que hitEnd() método hitEnd() Java, pero podría ser posible falsificarlo. Si alguien sabe cómo, será Flagrant Badass, Steven Levithan .

Answer 3

Pregunta muy interesante. En mi búsqueda rápida, no encontré nada predefinido (ni siquiera en Perl) que resuelva este problema.

EDITAR: Ouch, parece que Java tiene algo similar llamado hitEnd () - ver la respuesta de Alan M. Lo que hace HitEnd () es decir que el resultado de match () (verdadero o falso) puede ser modificado por una entrada adicional. El libro ''Mastering Regular Expressions'' dice que no es muy confiable (no estoy seguro de por qué, la página 392 no está disponible en los libros de Google).

Dependiendo de las características de las expresiones regulares que use, un truco rápido como escribir algún tipo de prefijo de su expresión regular:

por ejemplo, para a + a * b + c tus prefijos serán:

a+ a+a* a+a*b+ a+a*b+c

y trate de hacer coincidir cualquiera de ellos con su cadena podría funcionar. Este truco rápido se hace difícil si usa el operador de elección, si usa el operador de rango {n, m} o referencias retrospectivas.

Dicho esto, creo que la buena solución es modificar ligeramente el algoritmo de coincidencia.

El algoritmo de emparejamiento normalmente empleado es un algoritmo de retroceso (que funciona bien en la práctica, incluso si el peor de los casos es exponencial). Este algoritmo finaliza exitosamente siempre que ha llegado al final de la expresión regular (incluso si no se consumió toda la cadena). Lo que debe hacer es modificar la condición de terminación de manera que también termine exitosamente cuando haya consumido toda la entrada.

Dicho esto, probablemente tendrías que implementar el algoritmo en JavaScript. Esperemos que esto se convierta en parte de bibliotecas como Jquery.

Para obtener más referencias y teoría sobre el algoritmo, consulte este artículo:

http://swtch.com/~rsc/regexp/regexp1.html

(incluso si presenta un caso en contra del algoritmo de retroceso y sugiere un algoritmo basado en FA (pero el FA no puede manejar referencias anteriores)).

Answer 4

Primero define su expresión regular como: var re = new RegExp (/ ^ (regexp aquí) $ /);

en el evento onKeypress, comprueba la expresión regular de esta manera:

text.match (regexp) - donde el texto es la cadena ingresada.

¿Está claro?

Answer 5

Una forma de hacer esto podría ser enlazar al evento onKeyUp de un cuadro de texto y probar el texto con la expresión regular. Mi suposición es, por supuesto, que quieres hacer una coincidencia de expresiones regulares. No estoy seguro de si esto es exactamente lo que necesita, de hecho su código:

"a".isPrefixOf( re ); // true

nunca coincidirá ya que es necesario que también tenga un carácter "b" posterior (es posible que desee modificar la expresión regular). Por ejemplo, este código se comparará con cualquier cadena que coincida con este formato:

a-n(n)-b

Aquí está el código, guárdelo como una página y cárguelo en su navegador:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="it">
<body>
    <input type="text" size="20" id="txtData" onkeyup="showResult()" />
    <div id="dvResult" />
</body>
</html>
<script type="text/javascript">
//<![CDATA[

    theRegExp = /^a/-/d{1,2}/-b$/;

    function isPrefixOf( aText, aRegExp )
    {
        return aRegExp.test( aText );
    }

    function showResult()
    {
        res = document.getElementById( "dvResult" );
        res.innerHTML = isPrefixOf( document.getElementById( "txtData" ).value, theRegExp ) ? "Correct" : "Bad input";
    }

//]]>
</script>