Expresión regular para que coincida con el patrón

Estoy tratando de obtener coincidencias para comandos como este;

[AUTR| <version_software> | <version_protocol> | <msg> ]
[PING]

¿Cuál es la expresión regular que encuentra esta coincidencia para el primer comando?

AUTR
version_software
version_protocol
msg

este es el código que analiza eso:

String[] tokens =  msg.replace('<',' ').replace('>',' ').replace('[', ' ').replace(']', ' ').split("\\|");
for (int i=0; i<tokens.length; i++) tokens[i] = tokens[i].trim();

Solo me pregunto cómo se puede hacer con una solución de expresiones regulares.

EDIT:

Estoy tratando de hacer coincidir grupos con expresiones más fáciles, y con este código, la llamada a m.groupCount devuelve uno... pero cuando trato de imprimirlo... arroja esta excepción "java.lang.IllegalStateException: No se encontró coincidencia "

    Pattern pattern = Pattern.compile("([\\w+])");
    Matcher m = pattern.matcher("[AUTR]");

    for (int i=0; i<m.groupCount();i++)
    {
        System.out.println(m.group(i));
    } 

preguntado el 12 de junio de 12 a las 18:06

¿Qué expresiones regulares has probado que no funcionaron? -

Parece que ^[(AUTR)|\s<(version_software)>\s|\s<(version_protocol)>\s|\s<(msg)\s]$ haría el truco perfectamente. -

"[AUTR| <version_software> | <version_protocol> | <msg> ]".split("[\\[\\]|\\s<>]+") devolverle una serie de artículos -

Tengo muchos descriptores de comandos y quiero recuperar los nombres de los parámetros, y 'sí', puedo analizarlos fácilmente... pero me pregunto cómo se hace con una expresión regular:

1 Respuestas

EDITAR: http://fiddle.re/6ykc

Expresión regular:

\[([\w]+)(\s*\|\s*<([\w. ]+)>\s*)*\]

Cadena de expresiones regulares de Java:

"\\[([\\w]+)(\\s*\\|\\s*<([\\w. ]+)>\\s*)*\\]"

Tenga en cuenta que ahora esto es para comandos variables y que todos los parámetros adicionales deben coincidir con el siguiente conjunto de caracteres [a-zA-Z_0-9. ] (Incluye puntos y espacios).

Edición: Hay un problema con los comandos de longitud variable que no puede capturar más de un grupo con una agrupación de tipo variable.

La entrada capturada asociada con un grupo es siempre la subsecuencia con la que el grupo coincidió más recientemente. Si un grupo se evalúa por segunda vez debido a la cuantificación, su valor capturado previamente, si lo hubiera, se conservará si falla la segunda evaluación. Haciendo coincidir la cadena "aba" con la expresión (a(b)?)+, por ejemplo, deja el grupo dos establecido en "b". Toda la entrada capturada se descarta al comienzo de cada partido. http://docs.oracle.com/javase/6/docs/api/java/util/regex/Pattern.html#cg

EDIT 2:

Para obtenerlos todos, puede hacer 2 expresiones regulares, una para tomar el comando:

String command_regex = "\\[([\\w]+)";

Y encuentre eso y luego encuentre los parámetros que puede usar <> como su carácter clave para seleccionar:

String parameters = "<([\\w. ]+)>";

Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(string_to_match);

while (matcher.find()) {
    System.out.println(matcher.group());
}

Espero que ayude.


ORIGINAL:

No estoy exactamente seguro del formato, son "<" y ">" y "|" ¿requerido? ¿Y cuáles son los formatos para el comando, versión_software, versión_protocolo y mensaje? Sin embargo, este es mi intento para expresiones regulares (probado en Python)

\[(\w+)\s*\|\s*<([\w.]+)>\s*\|\s*<(\w+)>\s*\|\s*<([\w\s]+)>\s*\]

Debe asegurarse de escapar de los corchetes y los símbolos de tubería (agregué \s* condiciones entre porque no sé si habrá espacios o no. Si lo hace:

>> search.re("expression above", line) 
>> search.groups()

Debería dar todos los tokens en python al menos. Lo dejé más codificado para dejar espacio para los ajustes en cada ficha que quería tomar, de lo contrario, podría reducir las últimas 3 partes convirtiéndolo en un grupo y diciendo que se repita 3 veces. Déjame saber los resultados?

Respondido el 12 de junio de 12 a las 19:06

Lo siento... pero no funciona... tal vez los caracteres de escape... porque Java dijo que la expresión regular tenía caracteres de escape ilegales y he agregado una barra invertida a cada uno en su expresión regular para permitirme compilar... Patrón patrón = Patrón.compilar("\[(\\w+)\\s*\\|\\s*<([\\w.]+)>\\s*\\|\\s*<(\\w+ )>\\s*\\|\\s*<([\\w\\s]+)>\\s*\]");... pero no coincide con nada... - Azul

Ah, está bien, investigaré Java ya que estoy usando Python. - richardsu

¿Qué estás usando para probar estas expresiones? - richardsu

Estoy usando Pattern pattern = Pattern.compile("([w+])"); Matcher m = patrón.matcher("[AUTR]"); y también estoy probando con esta herramienta en línea regexplanet.com/advanced/java/index.html - Azul

Bueno, por supuesto que no coincide con [AUTR], el patrón está intentando coincidir con [AUTR| | | ]. Entonces, ¿quieres que coincida con todo tipo de patrones? Parecía que querías uno para el primer patrón de comandos. Para un comando sería simplemente "\[([\\w]+)\]" (No se permiten espacios alrededor del comando). - richardsu

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.