probar - expresiones regulares java pdf

Grupos con nombre Regex en Java

Question

Tengo entendido que el paquete java.regex no tiene soporte para grupos con nombre ( http://www.regular-expressions.info/named.html ) entonces, ¿puede alguien señalarme hacia una biblioteca de terceros que sí lo haga?

Miré jregex pero su último lanzamiento fue en 2002 y no funcionó para mí (admití que solo lo intenté brevemente) en java5.

Answer 1

¿Qué tipo de problema obtienes con jregex ? Me funcionó bien en java5 y java6.

Jregex hace bien el trabajo (incluso si la última versión es de 2002), a menos que desee esperar a Java 7 .

Answer 2

( Actualización : agosto de 2011 )

Como geofflane menciona en su respuesta , Java 7 ahora admite grupos con nombre .
tchrist señala en el comentario que el soporte es limitado.
Él detalla las limitaciones en su gran respuesta " Java Regex Helper "

El soporte del grupo denominado Java 7 regex se presentó en septiembre de 2010 en el blog de Oracle .

En el lanzamiento oficial de Java 7, los constructos para soportar el grupo de captura nombrado son:

• (?<name>capturing text) para definir un nombre de grupo "nombre"
• /k<name> para referenciar un grupo llamado "nombre"
• ${name} para hacer referencia al grupo capturado en la cadena de reemplazo de Matcher
• Matcher.group(String name) para devolver la subsecuencia de entrada capturada por el "grupo nombrado" dado.

Otras alternativas para pre-Java 7 fueron:

• Google named-regex (ver la answer John Hardy )
  Gábor Lipták menciona (noviembre de 2012) que este proyecto podría no estar activo (con varios errores sobresalientes ), y que su bifurcación GitHub podría considerarse en su lugar.
• jregex (Ver la answer Brian Clozel )

( Respuesta original : enero de 2009 , con los siguientes dos enlaces ahora rotos)

No puede hacer referencia al grupo con nombre, a menos que codifique su propia versión de Regex ...

Eso es precisamente lo que Gorbush2 hizo en este hilo .

Regex2

(Implementación limitada, como lo señaló nuevamente tchrist , ya que solo busca identificadores ASCII. Tchrist detalla la limitación como:

solo puede tener un grupo nombrado por el mismo nombre (sobre el que no siempre se tiene control) y no poder usarlos para la recursión en regex.

Nota: Puede encontrar ejemplos de recursión de expresiones regulares reales en expresiones regulares de Perl y PCRE, como se menciona en Regexp Power , especificaciones de PCRE y diapositiva de cadenas coincidentes con paréntesis equilibrados )

Ejemplo:

Cuerda:

"TEST 123"

RegExp:

"(?<login>//w+) (?<id>//d+)"

Acceso

matcher.group(1) ==> TEST
matcher.group("login") ==> TEST
matcher.name(1) ==> login

Reemplazar

matcher.replaceAll("aaaaa_$1_sssss_$2____") ==> aaaaa_TEST_sssss_123____
matcher.replaceAll("aaaaa_${login}_sssss_${id}____") ==> aaaaa_TEST_sssss_123____ 

(extracto de la implementación)

public final class Pattern
    implements java.io.Serializable
{
[...]
    /**
     * Parses a group and returns the head node of a set of nodes that process
     * the group. Sometimes a double return system is used where the tail is
     * returned in root.
     */
    private Node group0() {
        boolean capturingGroup = false;
        Node head = null;
        Node tail = null;
        int save = flags;
        root = null;
        int ch = next();
        if (ch == ''?'') {
            ch = skip();
            switch (ch) {

            case ''<'':   // (?<xxx)  look behind or group name
                ch = read();
                int start = cursor;
[...]
                // test forGroupName
                int startChar = ch;
                while(ASCII.isWord(ch) && ch != ''>'') ch=read();
                if(ch == ''>''){
                    // valid group name
                    int len = cursor-start;
                    int[] newtemp = new int[2*(len) + 2];
                    //System.arraycopy(temp, start, newtemp, 0, len);
                    StringBuilder name = new StringBuilder();
                    for(int i = start; i< cursor; i++){
                        name.append((char)temp[i-1]);
                    }
                    // create Named group
                    head = createGroup(false);
                    ((GroupTail)root).name = name.toString();

                    capturingGroup = true;
                    tail = root;
                    head.next = expr(tail);
                    break;
                }

Answer 3

Para aquellos que ejecutan pre-java7, los grupos con nombre son compatibles con joni (puerto de Java de la biblioteca de Oniguruma de Oniguruma ). La documentación es escasa, pero nos ha funcionado bien.
Los binarios están disponibles a través de Maven ( http://repository.codehaus.org/org/jruby/joni/joni/ ).

Answer 4

Para las personas que llegan tarde: Java 7 agrega grupos con nombre. Matcher.group (String groupName) documentación.

Answer 5

Sí, pero su desordenado hackear las clases de sol. Hay una manera más simple:

http://code.google.com/p/named-regexp/

named-regexp es una envoltura delgada para la implementación estándar de expresiones regulares JDK, con el único propósito de manejar grupos de captura nombrados en el estilo .net: (? ...).

Se puede usar con Java 5 y 6 (se usan genéricos).

Java 7 manejará grupos de captura nombrados, por lo que este proyecto no debe durar.

Answer 6

Una pregunta un poco vieja, pero me encontré que necesitaba esto también y que las sugerencias anteriores eran inadecuadas, y como tal, desarrollé una envoltura delgada: https://github.com/hofmeister/MatchIt