¿Perl detecta matrices?

Question

tengo este script

#!/usr/bin/perl 

use warnings; 
use strict; 
use Data::Dumper; 

my %x1 =(); 
$x1{"a"} = "e"; 

my %x2 =(); 
$x2{"a"} = ["b","c"]; 

p(\%x1); 
p(\%x2); 

sub p { 
    my $x = shift @_; 
    print $x->{a}; 
    print "\n"; 
} 

que da salida a

e 
ARRAY(0x2603fa0) 

El problema es que no sé cuando la entrada es una matriz o un escalar, y cuando es una matriz que le gustaría imprime esos valores también.

¿Se puede modificar p para hacer esto?

Answer 1

Sí, Perl puede detectar qué tipo es una variable es. Use la función ref(). Por ejemplo:

if(ref($var) eq 'ARRAY') { 
    # Do stuff 
} 

Ver más en this perlmonks discussion.

Answer 2

Si lo que desea es imprimir bastante variable, reemplazar su print ... con print Dumper ...:

$Data::Dumper::Indent = 0; 
print Dumper($x); 

de salida para el ejemplo sería:

$VAR1 = {'a' => 'e'}; 
$VAR1 = {'a' => ['b','c']}; 

Answer 3

Si necesita la respuesta de forma dinámica, use la función ref.

Answer 4

Existen varias formas de detectar una matriz en Perl, cada una con diferentes funcionalidades.

Dadas las siguientes variables:

my $array = [1, 2, 3]; 
my $arrayobj = bless [1, 2, 3] => 'ARRAY'; 
my $object = bless [1, 2, 3] => 'Some::Object'; 
my $overload = bless {array => [1, 2, 3]} => 'Can::Be::Array'; 
{package Can::Be::Array; 
    use overload fallback => 1, '@{}' => sub {$_[0]{array}} 
} 

• la función incorporada ref

  ref $array eq 'ARRAY' 
  ref $arrayobj eq 'ARRAY' 
  ref $object eq 'Some::Object' 
  ref $overload eq 'Can::Be::Array' 
  

• la función reftype desde el módulo de núcleo Scalar::Util

  reftype $array eq 'ARRAY' 
  reftype $arrayobj eq 'ARRAY' 
  reftype $object eq 'ARRAY' 
  reftype $overload eq 'HASH' 
  

• la función blessed de Scalar :: Util que se usa principalmente para determinar si una variable contiene un objeto al que puede llamar métodos.

  blessed $array eq undef 
  blessed $arrayobj eq 'ARRAY' 
  blessed $object eq 'Some::Object' 
  blessed $overload eq 'Can::Be::Array' 
  

• la captura de una excepción

  my $x = eval {\@$array } or die $@; # ok 
  my $x = eval {\@$arrayobj} or die $@; # ok 
  my $x = eval {\@$object} or die $@; # ok 
  my $x = eval {\@$overload} or die $@; # also ok, since overloaded 
  

En el último ejemplo, la \@ par elimina referencia del argumento como un ARRAY, y luego toma inmediatamente la referencia a la misma. Esta es una operación transparente que devuelve el mismo valor si ese valor es ARRAY. Si el valor está sobrecargado, devolverá la matriz ref que creó el módulo. Sin embargo, si no se puede desreferenciar el valor como ARRAY, perl lanzará una excepción.