¿Qué significa "CÓDIGO" para variable?

Question

En Perl quería depurar algún código del módulo, por lo que añade temporalmente la línea siguiente a dicho código fuente:

print $${${$${$$h[1]{$j}}{proxy_cache}}{$e}}{'fetch_handler'}{'ownerDocument'} 

... e imprime:

CODE(0x9b2b3e0) 

Qué "CODE "significa? Esperaba HASH(0x???????). Soy bastante nuevo en Perl, así que por favor explícame esto, como goooooogling para + Perl + CODE no es útil :)

Estaba buscando url de ownerDocument información, por cierto.

[ACTUALIZACIÓN]

Estoy tratando de utilizar el módulo WWW::Scripter para mis necesidades y yo ya encontré varios errores que el autor de este módulo (Padre Chrysostomos) ya fijado sobre la base de mis entradas.

Ahora estoy "depurando" algunos problemas con imágenes creadas dinámicamente en JavaScript (por ejemplo ((new Image()).src='http://...'), ya que esas imágenes no están ahora incluidas en los resultados $w->images.

Si se echa un vistazo a sub update_html en fuente del módulo [http://cpansearch.perl.org/src/SPROUT/WWW-Scripter-0.026/lib/WWW/Scripter.pm], hay una línea que comienza con

 $h && $h->eval($self, $code ... 

Esta es una sección que tengo que depurar. Estoy tratando de "buscar" nuevas imágenes en DOM después de evaluar el script. Yo era capaz de encontrar elementos de imagen bastante fácil, pero ahora que estoy tratando de encontrar la información a la que el documento al que pertenecen, mientras que necesito get con referer correcta información. Algunas imágenes se crean dentro de marcos, iframes, scripts, etc. Si se utiliza información de referencia incorrecta, puede dar lugar a una respuesta incorrecta, ya que la mayoría de esas imágenes (new Image()).src='http://...' se utilizan para rastrear con cookies, no para contenido de imagen real. Para obtener el contenido correcto del documento, todas estas imágenes especiales necesitan ser adecuadamente procesados ​​y sin árbitro correcta no funciona ...

Answer 1

Esto es un poco demasiado desea un comentario, pero no es una respuesta directa a su pregunta.

Quería averiguar la estructura de datos, que Soy plenamente consciente de que no podría controlar. Tengo curiosidad por saber por qué tienes que lidiar con eso, y si te queda algo de cabello o cordura.

Las múltiples referencias son un poco doloroso, pero también me recuerda cosas estúpidas que solía hacer con referencias y que incluso he presentado en la Primera Conferencia Perl.

Cuando empecé a usar referencias, pensé, estúpidamente, que cada vez que quería pasar una referencia que tenía que tomar una referencia, incluso si la cosa ya era una referencia. Que iba a terminar con algo feo como $$$$ref:

my $string = 'Buster'; 

some_sub(\$string); 

sub some_sub { 
    my $ref = shift; 
    some_other_sub(\$ref); 
    } 

sub some_other_sub { 
    my $ref = shift; 
    yet_another_sub(\$ref); 
    } 

sub yet_another_sub { 
    my $ref = shift; 
    print "$$$$ref\n"; #fuuuuugly! 
    } 

Esto se agrava cuando empiece a tomar a las referencias a los agregados, que es lo que creo que está pasando en su estructura de datos.Como una referencia a una referencia es solo un escalar, como lo es la referencia original, no puede desreferenciarla al alinear subíndices. Por lo tanto, todos los $${ } en su línea.

No pude ver lo que estaba pasando hasta que comencé de adentro hacia afuera, e incluso entonces solo usé prueba y error hasta que conseguí las cosas que funcionaron.

El primer nivel es una referencia a un array que contiene una referencia a un hash en el índice 1. Que no es tan difícil o feo:

my $j = 'foo'; 
my $e = 'baz'; 

my $h = []; 

$h->[1] = { foo => 'bar' }; # to get to $$h[1]{$j} 

print "1: $h->[1]{$j}\n"; 

El siguiente nivel es un poco raro. Para obtener $${ ... }{proxy_cache}, necesita una referencia a una referencia a un hash:

$h->[1] = { 
    foo => \ { proxy_cache => 'duck' } # ref to hash reference 
    }; 

print "2. $${ $$h[1]{$j} }{proxy_cache}\n"; 

No estoy seguro de cómo se está construyendo esta estructura de datos, sino que debe buscar lugares en los que ya tiene una referencia a un hash y no tomar otra árbitro. Esa es la estupidez que estaba haciendo en mi juventud. Podría verse así:

sub some_sub { 
    my $hash = shift; 

    $h->[1] = { 
     foo => \ $hash # don't do that! 
     }; 

La siguiente parte no es tan mala. Es sólo una referencia a un hash regular como el valor (en lugar de duck):

$h->[1] = { 
    foo => \ { proxy_cache => { $e => 'quux' } } 
    }; 

print "3. ${ $${ $$h[1]{$j} }{proxy_cache} }{$e}\n"; 

El siguiente nivel es otra referencia a una referencia a un hash:

$h->[1] = { 
    foo => \ { 
     proxy_cache => { 
      $e => \ { fetch_handler => 'zap' } 
      } 
     } 
    }; 

print "4. $${ ${ $${ $$h[1]{$j} }{proxy_cache} }{$e} }{'fetch_handler'}\n"; 

Finalmente, llego a la última tecla, ownerDocument y asignar una referencia subrutina:

$h->[1] = { 
    foo => \ { 
     proxy_cache => { 
      $e => \ { fetch_handler => { 
        ownerDocument => sub { print "Buster\n" }, 
        } 
       } 
      } 
     } 
    }; 

print "5. $${ ${ $${ $$h[1]{$j} }{proxy_cache} }{$e} }{'fetch_handler'}{'ownerDocument'}\n"; 

la salida es la CODE(0x.......) que ya ha visto.

Quería simplificar eso, pero no hay mucho que eliminar debido a esas molestas referencias no agregadas. Esto elimina sólo tres no está en blanco de caracteres para alinear la tecla {$e}:

print "6. "; 

print $${ $${ $h->[1]{$j} }{proxy_cache}{$e} }{'fetch_handler'}{'ownerDocument'}; 

print "\n"; 

Answer 2

Es una referencia de código, por ejemplo:

my $var = sub { ... }; 
print "$var\n";