¿Cómo realizo una sustitución de Perl en una cadena mientras mantengo el original?

En Perl, ¿cuál es una buena manera de realizar un reemplazo en una cadena usando una expresión regular y almacenar el valor en una variable diferente, sin cambiar el original?

Por lo general, solo copie la cadena a una nueva variable y luego la s///asocio a la expresión regular que reemplaza la nueva cadena, pero me preguntaba si hay una mejor manera de hacer esto.

$newstring = $oldstring;
$newstring =~ s/foo/bar/g;

Este es el idioma que siempre he usado para obtener una copia modificada de una cadena sin cambiar el original:

(my $newstring = $oldstring) =~ s/foo/bar/g;

En perl 5.14.0 o posterior, puede usar el nuevo /r modificador de sustitución no destructivo :

my $newstring = $oldstring =~ s/foo/bar/gr; 

Nota: Las soluciones anteriores también funcionan sin ellas g. También funcionan con cualquier otro modificador.

La declaración:

(my $newstring = $oldstring) =~ s/foo/bar/g;

Lo que es equivalente a:

my $newstring = $oldstring;
$newstring =~ s/foo/bar/g;

Alternativamente, a partir de Perl 5.13.2 puede usar /rpara hacer una sustitución no destructiva:

use 5.013;
#...
my $newstring = $oldstring =~ s/foo/bar/gr;

Debajo use strict, di:

(my $new = $original) =~ s/foo/bar/;

en lugar.

La solución de una línea es más útil como un shibboleth que un buen código; los buenos codificadores de Perl lo sabrán y lo entenderán, pero es mucho menos transparente y legible que el acoplado de dos líneas para copiar y modificar con el que está comenzando.

En otras palabras, una buena manera de hacerlo es la forma en que ya lo estás haciendo. La concisión innecesaria a costa de la legibilidad no es una victoria.

Otra solución anterior a la 5.14: http://www.perlmonks.org/?node_id=346719 (ver la publicación de japhy)

A medida que utiliza su enfoque map, también funciona bien para las matrices, pero requiere una conexión mapen cascada para producir una matriz temporal (de lo contrario, el original se modificaría):

my @orig = ('this', 'this sucks', 'what is this?');
my @list = map { s/this/that/; $_ } map { $_ } @orig;
# @orig unmodified

Odio foo y bar ... ¿quién soñó estos términos no descriptivos en la programación de todos modos?

my $oldstring = "replace donotreplace replace donotreplace replace donotreplace";

my $newstring = $oldstring;
$newstring =~ s/replace/newword/g; # inplace replacement

print $newstring;
%: newword donotreplace newword donotreplace newword donotreplace

Si escribe Perl con use strict;, encontrará que la sintaxis de una línea no es válida, incluso cuando se declara.

Con:

my ($newstring = $oldstring) =~ s/foo/bar/;

Usted obtiene:

Can't declare scalar assignment in "my" at script.pl line 7, near ") =~"
Execution of script.pl aborted due to compilation errors.

En cambio, la sintaxis que ha estado utilizando, aunque es una línea más larga, es la forma sintácticamente correcta de hacerlo use strict;. Para mí, usar use strict;es solo un hábito ahora. Lo hago de forma automática. Todos deberían.

#!/usr/bin/env perl -wT

use strict;

my $oldstring = "foo one foo two foo three";
my $newstring = $oldstring;
$newstring =~ s/foo/bar/g;

print "$oldstring","\n";
print "$newstring","\n";