Bueno, es cierto que podemos hacer la trampa con poner un
no strict 'vars';o
no strict 'refs';pero... es eso: estamos haciendo trampas.
Una solución, también tramposa, es decir que si el error se produce por que Perl no sabe de dónde viene la variable
$VAR1, lo que hacemos es declararla en nuestro programa:
Using perl Syntax Highlighting
#!/usr/bin/perl
use v5.12;
use autodie;
use Data::Dumper;
my %frecuencias = (
A => 1,
B => [
1,2,3,
],
C => 'Hola',
);
# Guardo el hash
open my $ofh, ">", "tmp.txt";
print $ofh Dumper \%frecuencias;
close $ofh;
# Recupero el hash
my $VAR1; # esto es hacer trampas, pero así el modo 'strict' no salta
open my $ifh, "<", "tmp.txt";
my $cadena;
{
local $/; # así, sin más, crea una copia local e indefinida, de $/
$cadena = <$ifh>;
}
close $ifh;
eval $cadena;
say Dumper $VAR1; # debe salir lo mismo que %frecuencias
say $VAR1->{C}; # 'Hola'
Coloreado en 0.002 segundos, usando
GeSHi 1.0.8.4
Entonces, hacemos el Dumper(), sabemos que en el archivo comienza por un
$VAR1 = { ..., así que unas líneas antes declaramos esa variable.
Claro, es un poco tramposo, porque sabemos que el primer Dumper lo hace de esa manera. El caso es que no podemos fiarnos de que siempre sea así.
Entonces, otra solución puede ser. El volcado tiene este aspecto:
Using text Syntax Highlighting
$VAR1 = {
'A' => 1,
'C' => 'Hola',
'B' => [
1,
2,
3
]
};
Coloreado en 0.000 segundos, usando
GeSHi 1.0.8.4
entonces... lo único que falta ahí... ¡es un
my delante!
Pues eso hacemos:
Using perl Syntax Highlighting
#!/usr/bin/perl
use v5.14;
use autodie;
use Data::Dumper;
my %frecuencias = (
A => 1,
B => [
1,2,3,
],
C => 'Hola',
);
# Guardo el hash
open my $ofh, ">", "tmp.txt";
print $ofh Dumper \%frecuencias;
close $ofh;
# Recupero el hash
open my $ifh, "<", "tmp.txt";
my $cadena;
{
local $/; # así, sin más, crea una copia local e indefinida, de $/
$cadena = <$ifh>;
}
close $ifh;
my $hash_ref = eval "my $cadena"; # el 'my' es necesario para que el 'strict' no lo marque como error
# El resultado de eval() es el valor de la última expresión ejecutada.
# Entonces, lo que hemos hecho es:
#
# my($hash_ref) = my($VAR1) = { ... }
say Dumper $hash_ref; # debe salir lo mismo que %frecuencias
say $hash_ref->{C}; # 'Hola'
Coloreado en 0.002 segundos, usando
GeSHi 1.0.8.4
Ahora, el eval() ya no se come ningún error porque "my $cadena" contiene un trozo de código válido. El problema es ese mini-programa consta solamente de una declaración y definición de una variable: $VAR1. Y resulta que esa variable NO es conocida por nuestro programa (no está declarada en ninguna otra línea). Así que no tenemos acceso a ella.
La solución viene de leer la documentación de eval(): devuelve el valor de la última instrucción ejecutada. Pues bien, la última (y única) instrucción ejecutada por eval() es un
my $VAR1 (la asignación de una referencia a un
hash). Si eso lo guardamos en una variable "en nuestro lado del universo", seguiremos teniendo una ref. a un
hash.
Bueno, todo esto suena muy complicado, así que podemos abreviar algunas cosas. Por ejemplo, todas las líneas encargadas de abrir el archivo en modo lectura, guardarlas a una variable, y luego evaluarlas... todo eso lo hace una función en un solo paso: do().
En la documentación de do() (
perldoc -f do) sale esto:
do EXPR
Usa el valor de EXPR como el nombre de un archivo y ejecuta los contenidos del archivo como un script Perl.
do 'stat.pl';
es igual que
eval `cat stat.pl`;
excepto que es más eficiente y conciso, mantiene el nombre del archivo en los mensajes de error, busca en los directorios @INC...
Bueno, pues entonces lo aprovecharemos:
Using perl Syntax Highlighting
#!/usr/bin/perl
use v5.14;
use autodie;
use Data::Dumper;
my %frecuencias = (
A => 1,
B => [
1,2,3,
],
C => 'Hola',
);
# Guardo el hash
open my $ofh, ">", "tmp.txt";
print $ofh Dumper \%frecuencias; # el archivo contiene $VAR1 = { ... }
close $ofh;
# Recupero el hash
my $hash_ref = do "tmp.txt"; # obtenemos una ref. a un hash
say Dumper $hash_ref; # debe salir lo mismo que %frecuencias
say $hash_ref->{C}; # 'Hola'
Coloreado en 0.002 segundos, usando
GeSHi 1.0.8.4
El código queda mucho más corto, haciendo lo mismo que antes. Naturalmente, una vez que tenemos $hash_ref, podemos recuperar el
hash original con
%frecuencias = %{ $hash_ref }, pero te lo he dejado también así, con acceso con referencias, para que veas que no es tan necesario.
ATENCIÓN: realmente, sí son distintos eval() y do(). En concreto, a la hora de re-interpretar el código. do() siempre re-interpreta el código, así que no es aconsejable meterlo dentro de un bucle (se vuelve lento).
Bueno, queda una cosilla suelta... En el archivo de volcado sigue apareciendo la dichosa variable $VAR1. Leyendo la página de manual de Data::Dumper, vemos que podemos dejarlo algo mejor:
Using perl Syntax Highlighting
#!/usr/bin/perl
use v5.14;
use autodie;
use Data::Dumper;
our %frecuencias = (
A => 1,
B => [
1,2,3,
],
C => 'Hola',
);
# Guardo el hash
open my $ofh, ">", "tmp.txt";
print $ofh Data::Dumper->Dump([ \%frecuencias ], ['*frecuencias']); # en el archivo se guarda %frecuencias = ( ...
close $ofh;
# Recupero el hash
undef %frecuencias;
do "tmp.txt";
say Data::Dumper->Dump([ \%frecuencias ], ['*frecuencias']); # debe salir lo mismo que %frecuencias
say $frecuencias{C}; # 'Hola'
Coloreado en 0.002 segundos, usando
GeSHi 1.0.8.4
con lo que ahora, si en el archivo se guarda
%frecuencias = ( ... ), al hacer el do(), conseguimos recuperar nuestro
hash de forma directa.
Bueno... no tan "directa"... hemos tenido que escribir un montón de cosas "raras" para hacer el volcado con el método Dump().
De toda esa morralla es de la que se encarga
Data::Dumper::Simple:
Using perl Syntax Highlighting
#!/usr/bin/perl
use v5.14;
use autodie;
use Data::Dumper::Simple;
our %frecuencias = ( # variable global
A => 1,
B => [
1,2,3,
],
C => 'Hola',
);
# Guardo el hash
open my $ofh, ">", "tmp.txt";
print $ofh Dumper %frecuencias; # en el archivo se guarda %frecuencias = ( ...
close $ofh;
# Recupero el hash
undef %frecuencias;
do "tmp.txt";
say Dumper %frecuencias; # debe salir lo mismo que %frecuencias
say $frecuencias{C}; # 'Hola'
Coloreado en 0.002 segundos, usando
GeSHi 1.0.8.4
Y ya tenemos un programa muy limpio.
Como complemento, decir que esto se hace tanto, que desde hace muchos años que existe el módulo Storable, que sirve para "congelar" y "descongelar" variables, a disco:
Using perl Syntax Highlighting
#!/usr/bin/perl
use v5.14;
use Storable;
my %frecuencias = ( # variable global
A => 1,
B => [
1,2,3,
],
C => 'Hola',
);
# Guardo el hash
store \%frecuencias, "tmp.txt";
# Recupero el hash
undef %frecuencias;
my $frecuencias_ref = retrieve "tmp.txt";
say $frecuencias_ref->{C}; # 'Hola'
%frecuencias = %{ $frecuencias_ref };
use Data::Dumper;
say Dumper \%frecuencias; # debe salir lo mismo que %frecuencias
say $frecuencias{C}; # 'Hola'
Coloreado en 0.001 segundos, usando
GeSHi 1.0.8.4
Hay una ventaja clara: con las versiones anteriores con Dump() y Dumper(), se creaba un archivo de más de 220 bytes. Con Storable, se crea un archivo binario de 59 bytes.
Y así termina la lección de hoy.
a base de estrellarme contra esta pequeña pieza de código.
