regex - online - probar expresiones regulares

¿Cómo puedo encontrar la ubicación de una coincidencia de expresiones regulares en Perl?

Question

Necesito escribir una función que reciba una cadena y una expresión regular. Necesito comprobar si hay una coincidencia y devolver la ubicación inicial y final de una coincidencia. (La expresión regular ya estaba compilada por qr// .)

La función también podría recibir una bandera "global" y luego debo devolver los pares (inicio, final) de todas las coincidencias.

No puedo cambiar la expresión regular, ni siquiera add () a su alrededor ya que el usuario podría usar () y /1 . Tal vez puedo usar (?:) .

Ejemplo: dado "ababab" y la expresión regular qr/ab/ , en el caso global necesito recuperar 3 pares de (inicio, fin).

Answer 1

La función pos te da la posición del partido. Si coloca su expresión regular entre paréntesis, puede obtener la longitud (y, por lo tanto, el final) con una length $1 . Me gusta esto

sub match_positions {
    my ($regex, $string) = @_;
    return if not $string =~ /($regex)/;
    return (pos($string), pos($string) + length $1);
}
sub all_match_positions {
    my ($regex, $string) = @_;
    my @ret;
    while ($string =~ /($regex)/g) {
        push @ret, [pos($string), pos($string) + length $1];
    }
    return @ret
}

Answer 2

Las variables incorporadas @- y @+ mantienen las posiciones inicial y final, respectivamente, de la última coincidencia exitosa. $-[0] y $+[0] corresponden a todo el patrón, mientras que $-[N] y $+[N] corresponden a las $N ( $1 , $2 , etc.).

Answer 3

Olvide mi publicación anterior, tengo una mejor idea.

sub match_positions {
    my ($regex, $string) = @_;
    return if not $string =~ /$regex/;
    return ($-[0], $+[0]);
}
sub match_all_positions {
    my ($regex, $string) = @_;
    my @ret;
    while ($string =~ /$regex/g) {
        push @ret, [ $-[0], $+[0] ];
    }
    return @ret
}

Esta técnica no cambia la expresión regular de ninguna manera.

Editado para agregar: para cotizar de Perlvar en $ 1 .. $ 9. "Estas variables son todas de solo lectura y tienen un alcance dinámico para el BLOQUE actual". En otras palabras, si desea usar $ 1 ... $ 9, no puede usar una subrutina para hacer la comparación.

Answer 4

También puede usar la variable $ `obsoleta, si está dispuesto a que todas las RE en su programa se ejecuten más lentamente. Desde perlvar:

   $‘      The string preceding whatever was matched by the last successful pattern match (not
           counting any matches hidden within a BLOCK or eval enclosed by the current BLOCK).
           (Mnemonic: "`" often precedes a quoted string.)  This variable is read-only.

           The use of this variable anywhere in a program imposes a considerable performance penalty
           on all regular expression matches.  See "BUGS".

Answer 5

#!/usr/bin/perl

# search the postions for the CpGs in human genome

sub match_positions {
    my ($regex, $string) = @_;
    return if not $string =~ /($regex)/;
    return (pos($string), pos($string) + length $1);
}
sub all_match_positions {
    my ($regex, $string) = @_;
    my @ret;
    while ($string =~ /($regex)/g) {
        push @ret, [(pos($string)-length $1),pos($string)-1];
    }
    return @ret
}

my $regex=''CG'';
my $string="ACGACGCGCGCG";
my $cgap=3;    
my @pos=all_match_positions($regex,$string);

my @hgcg;

foreach my $pos(@pos){
    push @hgcg,@$pos[1];
}

foreach my $i(0..($#hgcg-$cgap+1)){
my $len=$hgcg[$i+$cgap-1]-$hgcg[$i]+2;
print "$len/n"; 
}