regex - pattern - ¿Cómo usar una variable en el lado de reemplazo del operador de sustitución de Perl?

matching pattern perl

Question

Me gustaría hacer lo siguiente:

$find="start (.*) end";
$replace="foo /1 bar";
$var = "start middle end";
$var =~ s/$find/$replace/;

Esperaría $ var contener "foo middle bar", pero no funciona. Tampoco lo hace:

$replace=''foo /1 bar'';

De alguna manera me falta algo sobre el escape.

Arreglé los "faltantes"

Answer 1

Como otros han sugerido, puede usar lo siguiente:

my $find = ''start (.*) end'';
my $replace = ''foo $1 bar''; # ''foo /1 bar'' is an error.
my $var = "start middle end";
$var =~ s/$find/$replace/ee;

Lo anterior es corto para lo siguiente:

my $find = ''start (.*) end'';
my $replace = ''foo $1 bar'';
my $var = "start middle end";
$var =~ s/$find/ eval($replace) /e;

Prefiero el segundo al primero, ya que no oculta el hecho de que se usa eval(EXPR) . Sin embargo, los dos errores de silencio anteriores, por lo que lo siguiente sería mejor:

my $find = ''start (.*) end'';
my $replace = ''foo $1 bar'';
my $var = "start middle end";
$var =~ s/$find/ my $r = eval($replace); die $@ if $@; $r /e;

Pero como puede ver, todo lo anterior permite la ejecución de código Perl arbitrario. Lo siguiente sería mucho más seguro:

use String::Substitution qw( sub_modify );
my $find = ''start (.*) end'';
my $replace = ''foo $1 bar'';
my $var = "start middle end";
sub_modify($var, $find, $replace);

Answer 2

Deparse nos dice que esto es lo que se está ejecutando:

$find = ''start (.*) end'';
$replace = "foo /cA bar";
$var = ''start middle end'';
$var =~ s/$find/$replace/;

Sin embargo,

 /$find/foo /1 bar/

Se interpreta como:

$var =~ s/$find/foo $1 bar/;

Desafortunadamente, parece que no hay una manera fácil de hacerlo.

Puedes hacerlo con una evaluación de cadena, pero eso es peligroso.

La solución más sensata que funciona para mí fue esta:

$find = "start (.*) end";
$replace = ''foo /1 bar'';
$var = "start middle end";
sub repl {
my $find = shift;
my $replace = shift;
my $var = shift;
# Capture first
my @items = ( $var =~ $find );
$var =~ s/$find/$replace/;
for( reverse 0 .. $#items ){
my $n = $_ + 1;
# Many More Rules can go here, ie: /g matchers and /{ }
$var =~ s///$n/${items[$_]}/g ;
$var =~ s//$$n/${items[$_]}/g ;
}
return $var;
}
print repl $find, $replace, $var;

Una refutación contra la técnica ee:

Como dije en mi respuesta, evito las evaluaciones por una razón.

$find="start (.*) end";
$replace=''do{ print "I am a dirty little hacker" while 1; "foo $1 bar" }'';
$var = "start middle end";
$var =~ s/$find/$replace/ee;
print "var: $var/n";

este código hace exactamente lo que crees que hace.

Si su cadena de sustitución está en una aplicación web, acaba de abrir la puerta a la ejecución de código arbitrario.

Buen trabajo.

Además, NO funcionará con las manchas activadas por esta misma razón.

$find="start (.*) end";
$replace=''"'' . $ARGV[0] . ''"'';
$var = "start middle end";
$var =~ s/$find/$replace/ee;
print "var: $var/n"
$ perl /tmp/re.pl ''foo $1 bar''
var: foo middle bar
$ perl -T /tmp/re.pl ''foo $1 bar''
Insecure dependency in eval while running with -T switch at /tmp/re.pl line 10.

Sin embargo, la técnica más cuidadosa es sensata, segura y no contamina. (Tenga la seguridad de que la cadena que emite todavía está contaminada, por lo que no pierde seguridad).

Answer 3

En el lado de reemplazo, debe usar $ 1, no / 1.

Y solo puede hacer lo que quiera haciendo que replace sea una expresión evalable que le dé el resultado que desea y diciéndole a s /// que lo evalúe con el modificador / ee de la siguiente manera:

$find="start (.*) end";
$replace=''"foo $1 bar"'';
$var = "start middle end";
$var =~ s/$find/$replace/ee;
print "var: $var/n";

Para ver por qué se necesitan "" y double / e, vea el efecto de la doble evaluación aquí:

$ perl
$foo = "middle";
$replace=''"foo $foo bar"'';
print eval(''$replace''), "/n";
print eval(eval(''$replace'')), "/n";
__END__
"foo $foo bar"
foo middle bar

Answer 4

No estoy seguro de qué es lo que estás tratando de lograr. Pero tal vez puedas usar esto:

$var =~ s/^start/foo/;
$var =~ s/end$/bar/;

Es decir, dejo solo el medio y reemplazo el inicio y el final.

Answer 5

Sugeriría algo como:

$text =~ m{(.*)$find(.*)};
$text = $1 . $replace . $2;

Es bastante legible y parece ser seguro. Si se necesita reemplazo múltiple, es fácil:

while ($text =~ m{(.*)$find(.*)}){
$text = $1 . $replace . $2;
}

Answer 6

Vea ESTA publicación anterior SO sobre el uso de una variable en el lado de reemplazo de s/// en Perl. Mire tanto la respuesta aceptada como la respuesta de rebuttal .

Lo que intenta hacer es posible con el formulario s///ee que realiza una doble eval en la cadena de la derecha. Consulte la cotización perlop como operadores para más ejemplos.

Tenga en cuenta que existen impILcaciones de seguridad de eval y que esto no funcionará en el modo de contaminación.

Answer 7

# perl -de 0
$match="hi(.*)"
$sub=''$1''
$res="hi1234"
$res =~ s/$match/$sub/gee
p $res
1234

Ten cuidado, sin embargo. Esto provoca que se produzcan dos capas de eval , una para cada e al final de la expresión regular:

1. $ sub -> $ 1
2. $ 1 -> valor final, en el ejemplo, 1234

Answer 8

#!/usr/bin/perl
$sub = "//1";
$str = "hi1234";
$res = $str;
$match = "hi(.*)";
$res =~ s/$match/$1/g;
print $res

Esto me dio el ''1234''.