perldebtut - Online en la nube

PROGRAMA:

NOMBRE

perldebtut - Tutorial de depuración de Perl

DESCRIPCIÓN

Una introducción (muy) ligera en el uso del depurador de Perl, y un puntero para
fuentes de información existentes y más profundas sobre el tema de la depuración de programas perl.

Hay una cantidad extraordinaria de personas que parecen no saber nada.
sobre el uso del depurador de Perl, aunque usan el lenguaje todos los días. Esto es para ellos.

use estricto

En primer lugar, hay algunas cosas que puede hacer para hacer su vida mucho más sencilla.
cuando se trata de depurar programas de Perl, sin usar el depurador en absoluto. A
Demuestre, aquí hay una secuencia de comandos simple, llamada "hola", con un problema:

#!/ usr / bin / perl

$ var1 = 'Hola mundo'; # siempre quise hacer eso :-)
$ var2 = "$ varl \ n";

imprimir $ var2;
Salida;

Si bien esto se compila y se ejecuta felizmente, probablemente no hará lo que se espera, es decir,
no imprime "Hola mundo \ n" en absoluto; Por otro lado, hará exactamente lo que era.
dijo que hiciera, las computadoras están un poco inclinadas a esa dirección. Es decir, imprimirá una nueva línea.
carácter, y obtendrá lo que parece una línea en blanco. Parece que hay 2 variables
cuando (debido al error tipográfico) hay realmente 3:

$ var1 = 'Hola mundo';
$varl = indef;
$ var2 = "\ n";

Para detectar este tipo de problema, podemos forzar la declaración de cada variable antes de que la utilice
tirando del módulo estricto, poniendo 'use estricto;' después de la primera línea del guión.

Ahora, cuando lo ejecuta, perl se queja de las 3 variables no declaradas y obtenemos cuatro errores
mensajes porque se hace referencia a una variable dos veces:

El símbolo global "$ var1" requiere un nombre de paquete explícito en ./t1 línea 4.
El símbolo global "$ var2" requiere un nombre de paquete explícito en ./t1 línea 5.
El símbolo global "$ varl" requiere un nombre de paquete explícito en ./t1 línea 5.
El símbolo global "$ var2" requiere un nombre de paquete explícito en ./t1 línea 7.
La ejecución de ./hello se canceló debido a errores de compilación.

¡Luvverly! y para solucionar esto, declaramos todas las variables explícitamente y ahora nuestro script se ve
Me gusta esto:

#!/ usr / bin / perl
uso estricto

my $ var1 = 'Hola mundo';
my $ varl = undef;
my $ var2 = "$ varl \ n";

imprimir $ var2;
Salida;

Luego hacemos (siempre es una buena idea) una verificación de sintaxis antes de intentar ejecutarlo nuevamente:

> perl -c hola
hola sintaxis OK

Y ahora, cuando lo ejecutamos, obtenemos "\ n" todavía, pero al menos sabemos por qué. Solo obteniendo esto
script para compilar ha expuesto la variable '$ varl' (con la letra 'l'), y simplemente
cambiar $ varl por $ var1 resuelve el problema.

Buscando at datos y -w y v

Ok, pero ¿qué tal cuando realmente quieres ver tus datos, qué hay en esa variable dinámica,
justo antes de usarlo?

#!/ usr / bin / perl
uso estricto

my $ key = 'bienvenido';
mi% datos = (
'esto' => qw (eso),
'tom' => qw (y jerry),
'welcome' => q (Hola mundo),
'zip' => q (bienvenido),
);
my @data = claves% datos;

imprimir "$ datos {$ clave} \ n";
Salida;

Parece que está bien, después de haber pasado por la verificación de sintaxis (perl -c scriptname), lo ejecutamos y todo
obtenemos es una línea en blanco de nuevo! Hmmmm.

Un enfoque de depuración común aquí sería esparcir generosamente algunas declaraciones impresas,
para agregar un cheque justo antes de imprimir nuestros datos, y otro justo después:

imprimir "Todo OK \ n" si grep ($ clave, claves% datos);
imprimir "$ datos {$ clave} \ n";
imprimir "hecho: '$ datos {$ clave}' \ n";

E intenta de nuevo:

> datos de perl
Todo bien

hecho: ''

Después de mucho mirar la misma pieza de código y no ver la madera de los árboles durante
en algún momento, tomamos una taza de café y probamos otro enfoque. Es decir, traemos el
caballería dándole a perl el '-d'enciende la línea de comando:

> perl -d datos
Manejador de troquel predeterminado restaurado.

Cargando rutinas DB desde perl5db.pl versión 1.07
Soporte de editor disponible.

Introduzca ho 'hh' para obtener ayuda, o 'man perldebug' para obtener más ayuda.

main :: (./ data: 4): my $ key = 'welcome';

Ahora, lo que hemos hecho aquí es iniciar el depurador de Perl integrado en nuestro script. Es
se detuvo en la primera línea del código ejecutable y está esperando una entrada.

Antes de continuar, querrá saber cómo salir del depurador: use solo el
carta 'q', no las palabras' salir 'o' salir ':

DB <1> q
>

Eso es todo, estás de vuelta en casa de nuevo.

ayuda

Encienda el depurador nuevamente en su secuencia de comandos y veremos el menú de ayuda. Hay una
un par de formas de llamar a la ayuda: un simple 'h'obtendrá la lista de ayuda resumida,'|h'(tubería-h)
canalizará la ayuda a través de su localizador (que es (probablemente 'más' o 'menos'), y finalmente,
'h h'(h-espacio-h) le dará toda la pantalla de ayuda. Aquí está la página de resumen:

D1h

Líneas de origen de lista / búsqueda: Ejecución del script de control:
l [ln | sub] Lista de código fuente T Seguimiento de pila
- o . Listar la línea anterior / actual s [expr] Un solo paso [en expr]
v [línea] Ver alrededor de la línea n [expr] A continuación, pasa por encima de los subs
f nombre de archivo Ver código fuente en el archivo Repetir la última n o s
/ patrón /? patt? Buscar w / backw r Regresar desde subrutina
M Mostrar versiones del módulo c [ln | sub] Continuar hasta la posición
Controles del depurador: L Pausa de lista/observación/acciones
o [...] Establecer opciones del depurador t [expr] Alternar rastreo [trace expr]
<[<] | {[{] |> [>] [cmd] Do pre / post-prompt b [ln | event | sub] [cnd] Establecer punto de interrupción
! [N | pat] Rehacer un comando anterior B ln | * Eliminar a / todos los puntos de interrupción
H [-num] Mostrar los últimos números de comandos a [ln] cmd Hacer cmd antes de la línea
= [a val] Definir / enumerar un alias A ln | * Eliminar a / todas las acciones
h [db_cmd] Obtener ayuda sobre el comando w expr Agregar una expresión de observación
hh Página de ayuda completa W expr | * Eliminar a / todas las exprs del reloj
| [|] db_cmd ¡Enviar salida al paginador! [!] syscmd Ejecutar cmd en un subproceso
q o ^ D Salir R Intentar reiniciar
Examen de datos: expr Ejecute el código perl, consulte también: s, n, t expr
x | m expr Evalúa expr en contexto de lista, vuelca el resultado o enumera métodos.
p expr Expresión de impresión (usa el paquete actual del script).
S [[!] Pat] Lista de nombres de subrutinas que [no] coinciden con el patrón
V [Pk [Vars]] Lista de variables en el paquete. Las Vars pueden ser ~ patrón o! Patrón.
X [Vars] Igual que "V current_package [Vars]".
y [n [Vars]] Lista de léxicos en un alcance superior . Vars igual que V.
Para obtener más ayuda, escriba h cmd_letter o ejecute man perldebug para todos los documentos.

¡Más opciones confusas de las que puedas imaginar! No es tan malo como parece y
es muy útil saber más sobre todo, ¡y divertido también!

Hay un par de útiles que debe conocer de inmediato. No pensarías que estamos
utilizando cualquier biblioteca en este momento, pero 'M'mostrará qué módulos están actualmente
cargado y su número de versión, mientras que 'm'mostrará los métodos, y'S'muestra todo
subrutinas (por patrón) como se muestra a continuación. 'V"Y"X'mostrar variables en el programa por
alcance del paquete y puede estar restringido por patrón.

DB <2> S str
dumpvar :: stringify
estricto :: bits
estricto :: importación
estricto :: unimport

El uso de 'X' y primos requiere que no use los identificadores de tipo ($ @%), solo el 'nombre':

DM <3> X ~ err
FileHandle (stderr) => archivono(2)

Recuerde que estamos en nuestro pequeño programa con un problema, deberíamos echar un vistazo a dónde estamos,
y cómo se ven nuestros datos. En primer lugar, veamos algo de código en nuestra posición actual.
(la primera línea de código en este caso), a través de 'v':

DB <4> v
1#!/ usr / bin / perl
2: use estricto;
3
4 ==> my $ key = 'bienvenido';
5: mi% datos = (
6 'esto' => qw (eso),
7 'tom' => qw (y jerry),
8 'bienvenido' => q (Hola mundo),
9 'zip' => q (bienvenido),
10);

En la línea número 4 hay un puntero útil que le indica dónde se encuentra ahora. Para ver más
código, escriba 'v' de nuevo:

DB <4> v
8 'bienvenido' => q (Hola mundo),
9 'zip' => q (bienvenido),
10);
11: my @data = claves% datos;
12: imprime "Todo OK \ n" si grep ($ key, keys% data);
13: imprime "$ datos {$ clave} \ n";
14: print "hecho: '$ data {$ key}' \ n";
15: salir;

Y si desea volver a enumerar la línea 5, escriba 'l 5', (observe el espacio):

DB <4> l 5
5: mi% datos = (

En este caso, no hay mucho que ver, pero, por supuesto, normalmente hay páginas de cosas para
vadear, y 'l' puede ser muy útil. Para restablecer su vista a la línea que estamos a punto de
ejecutar, escriba un punto solitario '.':

DB <5>.
main :: (./ data_a: 4): my $ key = 'welcome';

La línea que se muestra es la que está a punto de ejecutarse. Next, todavía no ha sucedido. Entonces
mientras que podemos imprimir una variable con la letra 'p', en este punto todo lo que obtendríamos es un vacío
valor (indefinido) de nuevo. Lo que tenemos que hacer es pasar por el siguiente ejecutable.
declaración con un 's':

DB <6> s
principal :: (./ datos_a: 5): mi% datos = (
main :: (./ data_a: 6): 'esto' => qw (eso),
main :: (./ data_a: 7): 'tom' => qw (y jerry),
main :: (./ data_a: 8): 'bienvenido' => q (Hola mundo),
main :: (./ data_a: 9): 'zip' => q (bienvenido),
principal :: (./ datos_a: 10):);

Ahora podemos echar un vistazo a esa primera variable ($ clave):

DB <7> p $ clave
bienvenido

la línea 13 es donde está la acción, así que sigamos hasta allí a través de la letra 'c', cuales
por cierto, inserta un punto de interrupción 'solo una vez' en la línea o subrutina dada:

DB <8> c 13
Todo bien
main :: (./ data_a: 13): print "$ data {$ key} \ n";

Pasamos nuestro cheque (donde se imprimió 'Todo OK') y nos detuvimos justo antes de la
carne de nuestra tarea. Podríamos intentar imprimir un par de variables para ver qué es
sucediendo:

DB <9> p $ datos {$ clave}

No hay mucho allí, echemos un vistazo a nuestro hash:

DB <10> p% datos
Hola mundoziptomandwelcomejerrywelcomethisthat

DB <11> p claves% datos
Hola mundo

Bueno, esto no es muy fácil de leer, y usando el útil manual (h h), la 'x'comando
parece prometedor:

DB <12> x% datos
0 'Hola mundo'
1 'cremallera'
2 'tom'
3 'y'
4 'bienvenido'
5 indef
6 'jerry'
7 'bienvenido'
8 'esto'
9 'eso'

Eso no es de mucha ayuda, un par de bienvenidas allí, pero no hay indicios de cuáles son las llaves,
y cuáles son valores, es solo un volcado de matriz enumerado y, en este caso, no particularmente
servicial. El truco aquí es usar un referencia a la estructura de datos:

DB <13> x \% datos
0 Hachís(0x8194bc4)
'Hola mundo' => 'zip'
'jerry' => 'bienvenido'
'esto' => 'eso'
'tom' => 'y'
'bienvenido' => undef

La referencia está realmente descartada y finalmente podemos ver a qué nos enfrentamos. Nuestra cotización
era perfectamente válido pero incorrecto para nuestros propósitos, con 'y jerry' siendo tratados como 2
palabras separadas en lugar de una frase, eliminando así la estructura hash emparejada
alineación.

El '-w'switch nos habría dicho sobre esto, si lo hubiéramos usado al principio, y nos hubiera ahorrado un
muchos problemas:

> perl -w datos
Número impar de elementos en la asignación hash en ./data línea 5.

Arreglamos nuestra cita: 'tom' => q (y jerry), y lo ejecutamos nuevamente, esta vez obtenemos nuestro esperado
salida:

> perl -w datos
Hola Mundo

Mientras estamos aquí, eche un vistazo más de cerca al 'x'comando, es realmente útil y
volcar alegremente referencias anidadas, objetos completos, objetos parciales, casi
lo que sea que le arrojes:

Hagamos un objeto rápido y lo modifiquemos, primero iniciaremos el depurador: quiere algo
forma de entrada de STDIN, por lo que le damos algo no comprometido, un cero:

> perl -de 0
Manejador de troquel predeterminado restaurado.

Cargando rutinas DB desde perl5db.pl versión 1.07
Soporte de editor disponible.

Introduzca ho 'hh' para obtener ayuda, o 'man perldebug' para obtener más ayuda.

principal :: (- e: 1): 0

Ahora construya un objeto sobre la marcha sobre un par de líneas (observe la barra invertida):

DB<1> $obj = bendecir({'unique_id'=>'123', 'attr'=>
cont: {'col' => 'black', 'things' => [qw (this that etc)]}}, 'MY_class')

Y echémosle un vistazo:

DB <2> x $ obj
0 MY_class =Hachís(0x828ad98)
'attr' => Hachís(0x828ad68)
'col' => 'negro'
'cosas' => FORMACIÓN(0x828abb8)
0 'esto'
1 'eso'
2 'etc'
'unique_id' => 123
DB <3>

Útil, ¿eh? Puede evaluar casi cualquier cosa allí y experimentar con bits de código o
expresiones regulares hasta que las vacas regresen a casa:

DB <3> @data = qw (esto que la otra guadaña de la teoría del cuero del ateísmo)

DB <4> p 'saw ->'. ($ Cnt + = map {print "\ t: \ t $ _ \ n"} grep (/ the /, sort @data))
ateísmo
cuero
other
guadaña
de la forma más
teoría
sierra -> 6

Si desea ver el historial de comandos, escriba un 'H':

DB <5> H
4: p 'saw ->'. ($ Cnt + = map {print "\ t: \ t $ _ \ n"} grep (/ the /, sort @data))
3: @data = qw (esto que la otra guadaña de la teoría del cuero del ateísmo)
2: x $ obj
1: $ obj = bless ({'unique_id' => '123', 'attr' =>
{'col' => 'negro', 'cosas' => [qw (esto que, etc.)]}}, 'MI_clase')
DB <5>

Y si desea repetir cualquier comando anterior, use la exclamación: '!':

DB <5>! 4
p 'saw ->'. ($ cnt + = map {print "$ _ \ n"} grep (/ the /, sort @data))
ateísmo
cuero
other
guadaña
de la forma más
teoría
sierra -> 12

Para obtener más información sobre las referencias, consulte perlref y perlreftut.

Stepping atravesar código

Aquí hay un programa simple que convierte entre Celsius y Fahrenheit, también tiene un
problema:

#!/ usr / bin / perl -w
uso estricto

my $ arg = $ ARGV [0] || '-c20';

if ($ arg = ~ /^\-(c|f)((\-|\+)*\d+(\.\d+)*)$/) {
mi ($ grado, $ num) = ($ 1, $ 2);
mi ($ entrada, $ salida) = ($ num, $ num);
if ($ deg eq 'c') {
$ grados = 'f';
$ salida = & c2f ($ num);
} Else {
$ grado = 'c';
$ salida = & f2c ($ num);
}
$ fuera = sprintf ('% 0.2f', $ fuera);
$ fuera = ~ s / ^ ((\ - | \ +) * \ d +) \. 0 + $ / $ 1 /;
imprimir "$ out $ deg \ n";
} Else {
imprimir "Uso: $ 0 - [c | f] num \ n";
}
Salida;

secundario f2c {
my $ f = turno;
mi $ c = 5 * $ f - 32/9;
return $ c;
}

sub c2f {
my $ c = turno;
mi $ f = 9 * $ c / 5 + 32;
return $ f;
}

Por alguna razón, la conversión de Fahrenheit a Celsius no devuelve el resultado esperado.
Esto es lo que hace:

> temp -c0.72
33.30 f

> temp -f33.3
162.94 c

¡No muy consistente! Estableceremos un punto de interrupción en el código manualmente y lo ejecutaremos bajo el
depurador para ver qué está pasando. Un punto de interrupción es una bandera, a la que se ejecutará el depurador
sin interrupción, cuando alcanza el punto de interrupción, detendrá la ejecución y ofrecerá un
Solicitar una mayor interacción. En uso normal, estos comandos del depurador son completamente
ignorados, y son seguros, si están un poco desordenados, para dejarlos en el código de producción.

mi ($ entrada, $ salida) = ($ num, $ num);
$ DB :: sencillo = 2; # inserte en la línea 9!
si ($ deg eq 'c')
...

> perl -d temp -f33.3
Manejador de troquel predeterminado restaurado.

Cargando rutinas DB desde perl5db.pl versión 1.07
Soporte de editor disponible.

Introduzca ho 'hh' para obtener ayuda, o 'man perldebug' para obtener más ayuda.

principal: :( temp: 4): my $ arg = $ ARGV [0] || '-c100';

Simplemente continuaremos hasta nuestro punto de interrupción preestablecido con un 'c':

DB <1> c
principal: :( temp: 10): if ($ deg eq 'c') {

Seguido de un comando de vista para ver dónde estamos:

DB <1> v
7: mi ($ grado, $ num) = ($ 1, $ 2);
8: mi ($ entrada, $ salida) = ($ num, $ num);
9: $ DB :: sencillo = 2;
10 ==> if ($ deg eq 'c') {
11: $ deg = 'f';
12: $ salida = & c2f ($ num);
13} else {
14: $ deg = 'c';
15: $ salida = & f2c ($ num);
16}

Y una impresión para mostrar qué valores estamos usando actualmente:

DB <1> p ​​$ grado, $ num
f33.3

Podemos poner otro punto de ruptura en cualquier línea que comience con dos puntos, usaremos la línea 17 como
así es como salimos de la subrutina, y nos gustaría hacer una pausa allí más adelante:

DB <2> b 17

No hay comentarios de esto, pero puede ver qué puntos de interrupción se establecen usando la lista
Comando 'L':

DB <3> L
temperatura:
17: imprime "$ out $ deg \ n";
romper si (1)

Tenga en cuenta que para eliminar un punto de interrupción se utiliza 'B'.

Ahora continuaremos hacia nuestra subrutina, esta vez en lugar de por el número de línea,
use el nombre de la subrutina, seguido de la ahora familiar 'v':

DB <3> c f2c
main :: f2c (temp: 30): my $ f = shift;

DB <4> v
24: salir;
25
26 sub f2c {
27 ==> my $ f = turno;
28: mi $ c = 5 * $ f - 32/9;
29: devuelve $ c;
30}
31
32 sub c2f {
33: mi $ c = turno;

Tenga en cuenta que si hubiera una llamada de subrutina entre nosotros y la línea 29, y quisiéramos de un solo
paso a través de él, podríamos usar el 's'comando, y para pasar por encima de él usaríamos'n' cual
ejecutaría el submarino, pero no descendería a él para su inspección. Sin embargo, en este caso
simplemente continúe hasta la línea 29:

DB <4> c 29
main :: f2c (temp: 29): return $ c;

Y eche un vistazo al valor de retorno:

DB <5> p $ c
162.944444444444

Esta no es la respuesta correcta en absoluto, pero la suma parece correcta. Me pregunto si es algo
que ver con la precedencia del operador? Intentaremos un par de otras posibilidades con nuestra suma:

DB <6> p (5 * $ f - 32/9)
162.944444444444

DB <7> p 5 * $ f - (32/9)
162.944444444444

DB <8> p (5 * $ f) - 32/9
162.944444444444

DB <9> p 5 * ($ f - 32) / 9
0.722222222222221

:-) ¡Eso es más parecido! Ok, ahora podemos establecer nuestra variable de retorno y regresaremos de
el sub con una 'r':

DB <10> $ c = 5 * ($ f - 32) / 9

DB <11> r
retorno de contexto escalar de main :: f2c: 0.722222222222221

Se ve bien, continuemos con el final del guión:

DB <12> c
0.72 c
El programa depurado finalizó. Use q para salir o R ​​para reiniciar,
use O inhibit_exit para evitar detenerse después de la terminación del programa,
hq, h R o h O para obtener información adicional.

Una solución rápida a la línea ofensiva (inserte los paréntesis que faltan) en el programa real
y terminamos.

marcador de posición for a, w, t, T

Acciones, variables de observación, seguimientos de pila, etc .: en la lista TODO.

a

w

t

T

REGULAR EXPRESIONES

¿Alguna vez quisiste saber cómo era una expresión regular? Necesitará perl compilado con el
Bandera de DEPURACIÓN para este:

> perl -Dr -e '/ ^ pe (a) * rl $ / i'
Compilar REx `^ pe (a) * rl $ '
talla 17 primero en 2
char más raro
en 0
1: BOL(2)
2: EXACTF (4)
4: CURLYN [1] {0,32767} (14)
6: NADA(8)
8: EXACTF (0)
12: MIENTRAS(0)
13: NADA(14)
14: EXACTF (dieciséis)
16: EOL(17)
17: FIN(0)
flotante `'$ en 4..2147483647 (comprobando flotante) stclass` EXACTF '
anclado (BOL) minlen 4
Omitiendo el soporte de $ `$ & $ '.

EJECUTANDO ...

Liberando REx: `^ pe (a) * rl $ '

¿De verdad querías saberlo? :-) Para obtener más detalles sangrientos sobre cómo obtener expresiones regulares
trabajar, echar un vistazo a perlre, perlretut, y decodificar las misteriosas etiquetas (BOL y
CURLYN, etc., arriba), ver perldebguts.

SALIDA Pronósticos

Para obtener todos los resultados de su registro de errores y no perder ningún mensaje a través de operaciones útiles
almacenamiento en búfer del sistema, inserte una línea como esta, al comienzo de su secuencia de comandos:

$ | = 1;

Para ver la cola de un archivo de registro que crece dinámicamente, (desde la línea de comando):

tail -f $ error_log

Envolver todas las llamadas de dado en una rutina de controlador puede ser útil para ver cómo y desde dónde,
están siendo llamados, perlvar tiene más información:

BEGIN {$ SIG {__ DIE__} = sub {require Carp; Carpa :: confesar (@_)}}

Varias técnicas útiles para la redirección de identificadores de archivos STDOUT y STDERR son
explicado en perlopentut y perlfaq8.

CGI

Aquí solo una pista rápida para todos aquellos programadores CGI que no saben cómo diablos
supere el indicador de 'esperando entrada', cuando ejecute su script CGI desde el comando-
línea, intente algo como esto:

> perl -d my_cgi.pl -nodebug

Por supuesto, CGI y perlfaq9 le dirán más.

GUI

La interfaz de línea de comandos está estrechamente integrada con un emacs extensión y hay una vi
interfaz también.

Sin embargo, no tiene que hacer todo esto en la línea de comandos, hay algunas opciones de GUI disponibles
allí. Lo bueno de estos es que puede pasar el mouse sobre una variable y un volcado de
sus datos aparecerán en una ventana apropiada, o en un globo emergente, no más tedioso
escribiendo 'x $ varname' :-)

En particular, busque lo siguiente:

ptkdb contenedor basado en perlTK para el depurador incorporado

Anuncios clasificados entre particulares en las Islas Baleres depurador de visualización de datos

PerlDevKit y PerlBuilder son específicos de NT

NÓTESE BIEN. (Se agradecería más información sobre estos y otros).

RESUMEN

Hemos visto cómo fomentar las buenas prácticas de codificación con use estricto y -w. Podemos ejecutar el
depurador de perl perl -d nombre de la secuencia de comandos para inspeccionar sus datos desde el depurador de Perl con
de la forma más p y x comandos. Puede recorrer su código, establecer puntos de interrupción con b y paso
a través de ese código con s or n, continua con c y volver de un sub con r. Equitativamente
cosas intuitivas cuando te pones manos a la obra.

Por supuesto, hay mucho más para averiguar, esto acaba de arañar la superficie. El
La mejor manera de aprender más es usar perldoc para obtener más información sobre el idioma, leer el
ayuda en línea (perldebug es probablemente el siguiente lugar al que debe ir) y, por supuesto, experimente.

Use perldebtut en línea usando los servicios de onworks.net