1. Este site usa cookies. Ao continuar a usar este site está a concordar com o nosso uso de cookies. Saber Mais.

Dúvida com regex

Discussão em 'Programação' iniciada por souto, 20 de Novembro de 2008. (Respostas: 5; Visualizações: 696)

  1. souto

    souto To fold or to FOLD?

    Olá,

    Queria fazer uma regex para extrair um conteúdo de uma string, mas não faço a mínima ideia de como o fazer.

    A string tem o formato s(1,2,[a,b,c],5) .

    Queria extrair individualmente o 1, o 2, o [a,b,c] e o 5, cada um para a sua string.

    Alguém me consegue dar umas luzes?

    Thanks ;)
     
  2. Granadafeup

    Granadafeup Power Member

    A expressões regulares suportam grupos. Isto é, se a expressão for valida o conteúdo de cada grupo pode ser acedido. Geralmente são representados por ( ).

    No teu caso se tiver uma expressão regular (\w+),(\w+),(\[.*\]),(\w+)
    Comparando a '1,2,[a,b,c],5' a tua expressão deve devolver

    Grupo - resultado
    0 - '1,2,[a,b,c],5'
    1 - '1'
    2 - '2'
    3 - '[a,b,c]'
    4 - '5'


    Espero que tenha sido útil e claro.
     
  3. slack_guy

    slack_guy Power Member

    Como não referiste a linguagem, aqui fica uma sugestão em Perl:

    Código:
    #!/usr/bin/perl 
    
    use strict;
    use warnings;
    use Data::Dumper;
    
    my @strings = (
    	q|s(1,2,[a,b,c],5)|, # válido
    	q|d(a,2,[a,b,c],5)|, # inválido
    	q|s(1,2,a,b,c],5)|,  # inválido
    	q|s(1,2,[a,b,c]5)|,  # inválido
    	q|s(1,2,[a,b,c],i)|, # inválido
    	q|s(1,2,[a,b,c],10)|,# inválido
    	q|a(8,1,[x,y,z],9)|, # válido
    );
    
    my @substrings = ();
    
    foreach (@strings) {
    	if ( /\w\((\d)\,(\d)\,(\[\w\,\w\,\w\])\,(\d)\)/g) {
    		push @substrings, [ $1, $2, $3, $4 ];
    	}
    }
    
    print Dumper(\@substrings);
    
    Resultado:
    Código:
    $VAR1 = [
              [
                '1',
                '2',
                '[a,b,c]',
                '5'
              ],
              [
                '8',
                '1',
                '[x,y,z]',
                '9'
              ]
            ];
    
    Nota: Tomei a tua string à letra, ou seja:
    s(1,2,[a,b,c],5) = um caracter alfanumérico, um parêntesis curvo (abrir), um dígito, uma vírgula, um dígito, uma vírgula, um parêntesis recto (abrir) + um caracter alfanumérico + uma vírgula + um caracter alfanumérico + uma vírgula + um parêntesis recto (fechar), uma vírgula, um dígito, um parêntesis curvo (fechar).
     
    Última edição: 20 de Novembro de 2008
  4. souto

    souto To fold or to FOLD?

    Obrigado desde já pelas respostas :)

    Entendi ambas. Infelizmente, estou a usar Java...
    Pelo que percebi, é necessário um padrão diferente, pelo menos da forma que estou a usar.

    Estou a usar um método da classe String, split(String regex)...

    Pelo que percebi, tem que se fornecer um padrão, tal que a string-alvo desse método é separada nos pontos onde esse padrão "bate certo". Penso que é um raciocínio diferente...

    Basicamente tendo a string s(1,2,[b,a],3) e invocando o método split(regex), devolver-me-ia a array de strings contendo a tal solução.

    Se há forma mais directa de fazer isto, melhor. Foi a que me apareceu à frente... não sei se é a melhor, porque só trabalhei com expressões muito simples.

    Obrigado mais uma vez :)

    Bom, já tenho algo... Mas ainda nao está perfeito... fiz da seguinte forma:

    Código:
    public class RegExTest {
    
        public static void main(String[] args) {
            CharSequence inputStr = "s(18,23,[a,b,c],3)";
            String patternStr = ".({1}(\\w+),(\\w+),(\\[.*\\]),(\\w+)){1}";
    
            // Compile and use regular expression
            Pattern pattern = Pattern.compile(patternStr);
            Matcher matcher = pattern.matcher(inputStr);
            boolean matchFound = matcher.find();
    
            if (matchFound) {
                // Get all groups for this match
                for (int i = 0; i <= matcher.groupCount(); i++) {
                    String groupStr = matcher.group(i);
                    System.out.println(groupStr);
                }
            }
            else System.out.println("no match");
        }
    }
    
    Com o resultado...

    Código:
    (18,23,[a,b,c],3
    18,23,[a,b,c],3
    18
    23
    [a,b,c]
    3
    
    Agora só me falta filtrar aquele "ruido" lá em cima :P

    Bom, penso que já entendi isto melhor :) principalmente o conceito dos grupos e tal...
    Acabei por usar um híbrido de ambas as soluções... Muito obrigado ;)
    A expressão foi esta:
    Código:
    (\d+),(\d+),(\[.*\]),(\d+)
     
    Última edição: 20 de Novembro de 2008
  5. souto

    souto To fold or to FOLD?

    Mais uma vez, estou com um grande problema...
    Basicamente agora descobri que existe um bug numa API e está-me a devolver um resultado num formato extremamente esquisito, abaixo:

    [,(18,,([10],,([17,19,26],[26,27,28]))),,(26,,([25,27,10],,([18,34],[27,28]))),,...]

    Que deveria ser:

    [(18,[10],[17,19,26],[26,27,28]), (26,[25,27,10],[18,34],[27,28]),...]

    Basicamente é uma lista de tuplos em Prolog, de tamanho variável.
    Isto acontece-me com o PrologBeans.

    Será possível construir uma expressão regular que me permita obter a lista de baixo, sem aquelas vírgulas e parentesis a mais?

    Se não fosse este bug gigante, já tinha isto acabado :(

    Qualquer ajuda seria muito apreciada!!
     
  6. fLaSh_CF

    fLaSh_CF Banido

    Boas :)

    Experimenta desta forma:
    Compr.
     
    Última edição: 27 de Novembro de 2008

Partilhar esta Página