FAQ PerlConsultez toutes les FAQ

1
2
3
4
  
#!/usr/bin/perl 
use strict; 
use warnings;

1
2
  
print "Le contenu de la variable value est : $value \n";

1
2
3
4
  
my $value = "toto  "; 
# ... 
print "Le contenu de la variable value est : [$value] \n"; # imprime : "Le contenu de la variable value est : [toto  ]".

1
2
3
use Data::Dumper; 
# ... 
print "Le contenu du hachage est: ", Dumper( \%hachage ), "\n";

1
2
 
perl -d mon_programme.pl

use strict;

1
2
3
use strict "vars"; 
use strict "refs"; 
use strict "subs";

1
2
3
4
5
use strict; # en début de programme 
# ... du code Perl 
no strict "refs"; 
# une ou deux lignes de code utilisant des références symboliques 
use strict "refs";

1
2
3
4
5
6
7
use warnings; 
my @months = (); 
while (my $line = <>) { 
     my $mois = (split /;/, $line)[4]; 
     $months[$mois]++; 
} 
print "$_: $months[$_] \n" foreach 1..12;

Use of uninitialized value in concatenation (.) or string at ...

$months[$_] = 0 for 1..12;

1
2
3
for my $mois (1..12) { 
     print "$mois: $months[$mois] \n" if defined $months[$mois] 
}

1
2
3
4
5
6
7
8
9
10
11
use strict; 
use warnings; 
  
my $seed = shift; 
print somme($seed), "\n"; 
  
sub somme { 
     my $val = shift; 
     return $val if $val < 2; 
     return $val + somme ($val - 1); 
}

1
2
$ perl recursive_sum.pl 99 
4950

1
2
3
$ perl recursive_sum.pl 100 
Deep recursion on subroutine "main::somme" at recursive_sum.pl line 10. 
5050

1
2
3
$ perl recursive_sum.pl 1000000 
Deep recursion on subroutine "main::somme" at recursive_sum.pl line 10. 
500000500000

1
2
3
4
5
6
7
8
9
10
11
12
13
14
use strict; 
use warnings; 
  
my $seed = shift; 
die "Valeur en entrée trop élevée" if $seed > 1E6; # se prémunir contre les valeurs en entrée trop élevées 
print somme($seed), "\n"; 
  
sub somme { 
     my $val = shift; 
     return $val if $val < 2; 
     {    no warnings 'recursion'; 
          return $val + somme ($val - 1); 
     } 
}

1
2
3
4
5
6
sub somme { 
     my $val = shift; 
     return $val if $val < 2; 
     no warnings 'recursion'; 
     return $val + somme ($val - 1); 
}

1
2
3
4
5
6
 
$ perl -e 'use strict; use warnings; my %hash = (jan => 1, fev = 2); 
           print "true" if defined %hash;' 
defined(%hash) is deprecated at -e line 1. 
        (Maybe you should just omit the defined()?) 
true

1
2
3
4
5
6
7
8
9
10
11
 
$ perl -e 'use strict; use warnings; use diagnostics;  
           my %hash = (jan => 1, feb => 2,);  
           print "true" if defined %hash;' 
defined(%hash) is deprecated at -e line 1 (#1) 
    (D deprecated) defined() is not usually useful on hashes because it 
    checks for an undefined scalar value.  If you want to see if the hash 
    is empty, just use if (%hash) { # not empty } for example. 
 
        (Maybe you should just omit the defined()?) 
true

1
2
3
4
$ perl -e 'use strict; use warnings; use diagnostics; 
                 my %hash = (jan => 1, feb => 2,);  
                 print "true" if %hash;' 
true

1
2
3
4
5
6
7
8
9
10
11
$ perl recursive_sum.pl 100 
Deep recursion on subroutine "main::somme" at recursive_sum.pl line 13 (#1) 
    (W recursion) This subroutine has called itself (directly or indirectly) 
    100 times more than it has returned.  This probably indicates an 
    infinite recursion, unless you're writing strange benchmark programs, in 
    which case it indicates something else. 
 
    This threshold can be changed from 100, by recompiling the perl binary, 
    setting the C pre-processor macro PERL_SUB_DEPTH_WARN to the desired value. 
 
5050

1
2
3
4
$ echo toto | perl -e ' while (<>) { print "true\n" if $_ eq "toto"}' 
 
$ echo toto | perl -e ' while (<>) { print "true\n" unless $_ eq "toto"}' 
true

1
2
3
$ echo toto | perl -e ' while (<>) { print "[$_]\n"; print "true\n" if $_ eq "toto"}' 
[toto 
]

1
2
3
4
$ echo toto | perl -e ' while (<>) { chomp $_; print "true\n" if $_ eq "toto"}' 
true 
 
$ echo toto | perl -e ' while (<>) { chomp; print "true\n" unless $_ eq "toto"}'

1
2
 
% perl mon_programme.pl input.txt > output.txt

1
2
 
% perl mon_programme.pl input.txt | perl autre_programme.pl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
use strict; 
use warnings; 
use Carp qw/carp cluck/; 
  
my $val = 5; 
a($val); 
sub a { 
	my $arg = shift; 
	b($arg*2); 
} 
sub b { 
	c(3 * shift); 
} 
sub c { 
	my $d = shift; 
	carp "erreur sur la variable $d" if $d > 25; 
	print "La valeur obtenue est : $d \n"; 
}

1
2
3
4
5
erreur sur la variable 30 at test_carp.pl line 16 
        main::c(30) called at test_carp.pl line 12 
        main::b(10) called at test_carp.pl line 9 
        main::a(5) called at test_carp.pl line 6 
La valeur obtenue est : 30

1
2
3
4
5
use strict; 
use warnings; 
  
my @tableau = qw / janvier fevrier mars avril mai juin /; 
print @tableau, "\n";

1
2
$ perl print_tab.pl 
janvierfevriermarsavrimmaijuin

print "@tableau \n";

1
2
$ perl print_tab.pl 
janvier fevrier mars avril mai juin

1
2
3
4
5
6
7
8
use strict; 
use warnings; 
  
my @tableau = qw / janvier fevrier mars avril mai juin /; 
{ 
	local $" = "\n"; 
	print "@tableau \n"; 
}

1
2
3
4
5
6
7
 
janvier 
fevrier 
mars 
avril 
mai 
juin

1
2
3
4
{ 
	local $" = ", "; 
	print "@tableau \n"; 
}

1
2
 
janvier, fevrier, mars, avril, mai, juin

1
2
3
4
5
use strict; 
use warnings; 
  
my @tableau = qw / janvier fevrier mars avril mai juin /; 
print "$_ : $tableau[$_] \n" for 0..$#tableau;

1
2
3
4
5
6
0 : janvier 
1 : fevrier 
2 : mars 
3 : avril 
4 : mai 
5 : juin

1
2
3
4
5
6
use strict; 
use warnings; 
use Data::Dumper; 
  
my @tableau = qw / janvier fevrier mars avril mai juin /; 
print Dumper \@tableau;

1
2
3
4
5
6
7
8
$VAR1 = [ 
          'janvier', 
          'fevrier', 
          'mars', 
          'avril', 
          'mai', 
          'juin' 
        ];

1
2
3
4
5
6
7
8
9
10
use strict; 
use warnings; 
use Data::Dumper; 
  
my @tableau = qw / janvier fevrier mars avril mai juin /; 
my $iter = 1; 
my %hachage_1 = map {$_, $iter++} @tableau; 
$iter = 1; 
my %hachage_2 = map {$iter++, $_} @tableau; 
print Dumper \%hachage_1, \%hachage_2;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$VAR1 = { 
          'mai' => 5, 
          'juin' => 6, 
          'avril' => 4, 
          'mars' => 3, 
          'fevrier' => 2, 
          'janvier' => 1 
        }; 
$VAR2 = { 
          '6' => 'juin', 
          '4' => 'avril', 
          '1' => 'janvier', 
          '3' => 'mars', 
          '2' => 'fevrier', 
          '5' => 'mai' 
        };

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
use strict; 
use warnings; 
use Data::Dumper; 
  
my @savants = ( { Newton =>   { prenom => "Isaac",   
                                domaines => [qw /maths optique astronomie/], 
                                dates => { vie => {naissance => 1643, mort => 1727}}}}, 
                { Einstein => { prenom => "Albert",   
                                domaines => [qw /physique cosmologie/], 
                                dates => { vie => {naissance => 1879, mort => 1955}, 
                                           decouvertes => {  
                                                           "relativite restreinte" => 1905,  
                                                           quantas => 1905,  
                                                           "relativ. generale" => 1916,} 
                                         } 
                               } 
                }, 
                { Pasteur =>  { prenom => "Louis", 
                                domaines => [qw /chimie cristallographie medecine/], 
                                dates => { vie => {naissance => 1822, mort => 1895}, 
                                           decouvertes => { 
                                                           "dissymetrie moleculaire" => 1848, 
                                                           fermentation => "1857-67", 
                                                           pasteurisation => "1863-66", 
                                                           "microbes et vaccins" => "1876-1890" 
                                                        } 
                                         } 
  
                              } 
                } 
              ); 
print Dumper \@savants;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
$VAR1 = [ 
          { 
            'Newton' => { 
                          'prenom' => 'Isaac', 
                          'dates' => { 
                                       'vie' => { 
                                                  'mort' => 1727, 
                                                  'naissance' => 1643 
                                                } 
                                     }, 
                          'domaines' => [ 
                                          'maths', 
                                          'optique', 
                                          'astronomie' 
                                        ] 
                        } 
          }, 
          { 
            'Einstein' => { 
                            'prenom' => 'Albert', 
                            'dates' => { 
                                         'decouvertes' => { 
                                                            'quantas' => 1905, 
                                                            'relativite restreinte' => 1905, 
                                                            'relativ. generale' => 1916 
                                                          }, 
                                         'vie' => { 
                                                    'mort' => 1955, 
                                                    'naissance' => 1879 
                                                  } 
                                       }, 
                            'domaines' => [ 
                                            'physique', 
                                            'cosmologie' 
                                          ] 
                          } 
          }, 
          { 
            'Pasteur' => { 
                           'prenom' => 'Louis', 
                           'dates' => { 
                                        'decouvertes' => { 
                                                           'microbes et vaccins' => '1876-1890', 
                                                           'pasteurisation' => '1863-66', 
                                                           'fermentation' => '1857-67', 
                                                           'dissymetrie moleculaire' => 1848 
                                                         }, 
                                        'vie' => { 
                                                   'mort' => 1895, 
                                                   'naissance' => 1822 
                                                 } 
                                      }, 
                           'domaines' => [ 
                                           'chimie', 
                                           'cristallographie', 
                                           'medecine' 
                                         ] 
                         } 
          } 
        ];

1
2
3
4
5
6
7
  
use strict;  
use warnings;  
my $DEBUG = 1; # mettre $DEBUG à 1 quand on débogue et à 0 quand on ne débogue plus. 
  
# ... plus loin 
print "Valeur de variable: [$variable] \n" if $DEBUG;

1
2
  
my $DEBUG = 0; # mettre $DEBUG à 1 quand on débogue et à 0 quand on ne débogue plus.

1
2
3
4
5
6
7
  
use strict;  
use warnings;  
use constant DEBUG => 1; # mettre DEBUG à 1 quand on débogue et à 0 quand on ne débogue plus. 
  
# ... plus loin 
print "Valeur de variable: [$variable] \n" if DEBUG;

1
2
3
4
5
6
7
8
9
10
11
12
13
  
use strict;  
use warnings;  
use constant DEBUG => 1; # mettre DEBUG à 1 quand on débogue et à 0 quand on ne débogue plus. 
  
# ... plus loin 
log ("Valeur de variable: [$variable]"); 
#... 
sub log {  
     return unless DEBUG; 
     my $msg = shift; 
     print $msg, "\n"; 
}

1
2
3
4
5
6
7
  
use strict;  
use warnings;  
use Smart::Comments; # rend "magiques" les ### 
  
# ... plus loin 
### Valeur de variable: [$variable];

1
2
3
4
5
6
7
8
  
#!/usr/bin/perl 
use strict; 
use warnings; 
  
my $var = "3"; 
print $var > 2 ? "yes" : "no", "\n"; 
exit $var > 2 ? 1 : 0;

1
2
 
$ perl  test.pl ; echo $?

1
2
3
 
yes 
3

1
2
3
4
5
6
7
$ perl -MO=Deparse,-p test.pl 
use warnings; 
use strict 'refs'; 
(my $var = '3'); 
print((($var > 2) ? 'yes' : 'no'), "\n"); 
((exit($var) > 2) ? '???' : '???'); 
test.pl syntax OK

1
2
  
exit ($var > 2 ? 1 : 0);

1
2
3
4
 
$ perl test.pl; echo $? 
yes 
1

1
2
3
4
5
6
7
$ perl -MO=Deparse,-p  test.pl 
use warnings; 
use strict 'refs'; 
(my $var = '3'); 
print((($var > 2) ? 'yes' : 'no'), "\n"); 
exit((($var > 2) ? 1 : 0)); 
test.pl syntax OK

1
2
3
  
$ perl -e 'print "hello world!";' 
hello world!

perl -e "print 'hello world!';"

if($str1 =~ /$str2/gi){...

1
2
3
4
5
  
$  perl -E 'my $str1 = qq(one two three); my $str2 = qq(two); if ($str2 =~ m/$str1/) { say "Vrai";}' 
  
$  perl -E 'my $str1 = qq(one two three); my $str2 = qq(two); if ($str1 =~ m/$str2/) { say "Vrai";}' 
Vrai

1
2
 
$ perl -de 42

1
2
3
4
5
6
7
8
9
10
 
  DB<1> $str1 = qq(one two three); 
 
  DB<2>  $str2 = qq(two); 
 
  DB<3> print "Vrai" if $str2 =~ m/$str1/; 
 
  DB<4> print "Vrai" if $str1 =~ m/$str2/; 
Vrai 
  DB<5>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$ perl -de 42 
  
Loading DB routines from perl5db.pl version 1.33 
Editor support available. 
  
Enter h or `h h' for help, or `man perldebug' for more help. 
  
main::(-e:1):   42 
  DB<1> $c = "Larry wall"; # le createur de Perl 
  
  DB<2> print $c; # imprime la valeur de $c 
Larry wall 
  DB<3> p $c; # raccourci du debugger pour imprimer la valeur de $c 
Larry wall

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
  
  DB<4>  @tableau = qw / wall christiansen schwartz chromatic conway poe /; # quelques auteurs connus de Perl 
  
  DB<5> p @tableau; # imprime les éléments du tableau mis bout à bout. C'est très laid. 
wallchristiansenschwartzchromaticconwaypoe 
  DB<6> p "@tableau"; imprimer le tableau entre guillemets permet un affichage nettement plus satisfaisant 
wall christiansen schwartz chromatic conway poe 
  DB<7> x @tableau; # afficher la structure du tableau : élément 0 = wall, élément 1 = christiansen, etc. 
0  'wall' 
1  'christiansen' 
2  'schwartz' 
3  'chromatic' 
4  'conway' 
5  'poe' 
  DB<8> x \@tableau; # x sur une référence sur un tableau affiche encore plus clairement la structure des données 
0  ARRAY(0x6005009e8) 
   0  'wall' 
   1  'christiansen' 
   2  'schwartz' 
   3  'chromatic' 
   4  'conway' 
   5  'poe'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
  
  DB<9> print join ", ", @tableau; # tester un bout de code un peu plus complexe, avec un join  
wall, christiansen, schwartz, chromatic, conway, poe 
  
  DB<10> print map { $_ = ucfirst $_; "$_, " }  @tableau; # un peu plus complexe : lettre capitale initiale pour ces personnes 
Wall, Christiansen, Schwartz, Chromatic, Conway, Poe, 
  DB<11> x \@tableau; # attention : le map précédent, en modifiant $_, a modifié le contenu du tableau 
0  ARRAY(0x6005009e8) 
   0  'Wall' 
   1  'Christiansen' 
   2  'Schwartz' 
   3  'Chromatic' 
   4  'Conway' 
   5  'Poe'

1
2
3
4
5
6
7
8
9
10
11
12
13
  
  DB<1>   @AoH = (  { jan => 1, feb => 2, mar => 3}, { apr => 4, may => 5, june => 6} ); 
  
  DB<2> x \@AoH; 
0  ARRAY(0x600500b38) 
   0  HASH(0x60005f160) 
      'feb' => 2 
      'jan' => 1 
      'mar' => 3 
   1  HASH(0x6005008e0) 
      'apr' => 4 
      'june' => 6 
      'may' => 5

1
2
3
4
5
6
7
8
  
  DB<3> $hashref = $AoH[0]; 
  
  DB<4> x $hashref; 
0  HASH(0x60005f160) 
   'feb' => 2 
   'jan' => 1 
   'mar' => 3

1
2
3
4
5
6
7
8
  DB<5> p $hashref{jan}; # n'affiche rien 
  
  DB<6> x  $hashref{jan}; # ne fonctionne toujours pas, $hashref{jan} n'est pas défini 
0  undef 
  DB<7> p $hashref->{jan}; # cette fois, ça marche 
1 
  DB<8> x $hashref->{jan}; # $hashref n'est pas un hash, mais une référence vers un hash. Déréférençons avec -> 
0  1

1
2
3
4
5
6
7
8
  
  DB<9> p $hashref->{"jan", "feb"}; # ne fonctionne pas 
  
  DB<10> x $hashref->{"jan", "feb"}; # toujours pas 
0  undef 
  DB<11> x @$hashref{"jan", "feb"} ; # cette fois, c'est bon 
0  1 
1  2

1
2
3
4
5
6
7
8
  
  DB<12> @valeurs =  @$hashref{ qw/ jan feb mar / }; 
  
  DB<13> x \@valeurs 
0  ARRAY(0x60052b450) 
   0  1 
   1  2 
   2  3

1
2
3
4
5
6
7
8
9
10
  
  DB<14> for $href (@AoH) { push @allvalues, sort values %$href}; 
  
  DB<15> x @allvalues 
0  1 
1  2 
2  3 
3  4 
4  5 
5  6

1
2
3
4
5
6
 
  DB<1>  $string = "Une chaine avec \n un retour à la ligne"; 
 
  DB<2>  print $1 if $string =~ /Une (.+)ligne/ 
 
  DB<3>  p $1

1
2
 
  DB<7>  print $1 if $string =~ /Une(.+)ligne/m

1
2
3
4
5
 
  DB<10>  print $1 if $string =~ /Une(.+)ligne/s; 
 ligne avec 
 un retour à la 
  DB<11>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#!/usr/bin/perl 
  
use strict; 
use warnings; 
  
my $file = "1.00 InDev 01-Jun-2013 
1.00 InTest 15-Jul-2013 
1.00 InUAT 31-Jul-2013 
1.01 InDev 01-Jul-2013 
2.00 InDev 01-Aug-2013"; 
  
my @file_content = split( /\n/, $file ); 
my @full_data; 
  
push @full_data, [split] for @file_content; 
  
for my $line_ref (@full_data) { 
        print "$_\t" for @$line_ref; 
        print "\n"; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
 
$ perl -d table.pl 
 
Loading DB routines from perl5db.pl version 1.33 
Editor support available. 
 
Enter h or `h h' for help, or `man perldebug' for more help. 
 
main::(table.pl:6):     my $file = "1.00 InDev 01-Jun-2013 
main::(table.pl:7):     1.00 InTest 15-Jul-2013 
main::(table.pl:8):     1.00 InUAT 31-Jul-2013 
main::(table.pl:9):     1.01 InDev 01-Jul-2013 
main::(table.pl:10):    2.00 InDev 01-Aug-2013";

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
  DB<1> h 
List/search source lines:               Control script execution: 
  l [ln|sub]  List source code            T           Stack trace 
  - or .      List previous/current line  s [expr]    Single step [in expr] 
  v [line]    View around line            n [expr]    Next, steps over subs 
  f filename  View source in file         <CR/Enter>  Repeat last n or s 
  /pattern/ ?patt?   Search forw/backw    r           Return from subroutine 
  M           Show module versions        c [ln|sub]  Continue until position 
Debugger controls:                        L           List break/watch/actions 
  o [...]     Set debugger options        t [expr]    Toggle trace [trace expr] 
  <[<]|{[{]|>[>] [cmd] Do pre/post-prompt b [ln|event|sub] [cnd] Set breakpoint 
  ! [N|pat]   Redo a previous command     B ln|*      Delete a/all breakpoints 
  H [-num]    Display last num commands   a [ln] cmd  Do cmd before line 
  = [a val]   Define/list an alias        A ln|*      Delete a/all actions 
  h [db_cmd]  Get help on command         w expr      Add a watch expression 
  h h         Complete help page          W expr|*    Delete a/all watch exprs 
  |[|]db_cmd  Send output to pager        ![!] syscmd Run cmd in a subprocess 
  q or ^D     Quit                        R           Attempt a restart 
Data Examination:     expr     Execute perl code, also see: s,n,t expr 
  x|m expr       Evals expr in list context, dumps the result or lists methods. 
  p expr         Print expression (uses script's current package). 
  S [[!]pat]     List subroutine names [not] matching pattern 
  V [Pk [Vars]]  List Variables in Package.  Vars can be ~pattern or !pattern. 
  X [Vars]       Same as "V current_package [Vars]".  i class inheritance tree. 
  y [n [Vars]]   List lexicals in higher scope <n>.  Vars same as V. 
  e     Display thread id     E Display all thread ids. 
For more help, type h cmd_letter, or run man perldebug for all docs.

1
2
3
4
5
6
 
main::(table.pl:6):     my $file = "1.00 InDev 01-Jun-2013 
main::(table.pl:7):     1.00 InTest 15-Jul-2013 
main::(table.pl:8):     1.00 InUAT 31-Jul-2013 
main::(table.pl:9):     1.01 InDev 01-Jul-2013 
main::(table.pl:10):    2.00 InDev 01-Aug-2013";

1
2
3
4
5
6
7
8
9
10
11
 
  DB<2> p $file 
 
  DB<3> s 
main::(table.pl:12):    my @file_content = split( /\n/, $file ); 
  DB<3> p $file 
1.00 InDev 01-Jun-2013 
1.00 InTest 15-Jul-2013 
1.00 InUAT 31-Jul-2013 
1.01 InDev 01-Jul-2013 
2.00 InDev 01-Aug-2013

1
2
3
4
5
6
7
8
9
10
 
  DB<4> s 
main::(table.pl:13):    my @full_data; 
  DB<4> x  \@file_content 
0  ARRAY(0x6003c9d28) 
   0  '1.00 InDev 01-Jun-2013' 
   1  '1.00 InTest 15-Jul-2013' 
   2  '1.00 InUAT 31-Jul-2013' 
   3  '1.01 InDev 01-Jul-2013' 
   4  '2.00 InDev 01-Aug-2013'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
  DB<6> x  \@full_data 
0  ARRAY(0x60025cba0) 
   0  ARRAY(0x600513fd0) 
      0  1.00 
      1  'InDev' 
      2  '01-Jun-2013' 
   1  ARRAY(0x60006f300) 
      0  1.00 
      1  'InTest' 
      2  '15-Jul-2013' 
   2  ARRAY(0x6005ebc30) 
      0  1.00 
      1  'InUAT' 
      2  '31-Jul-2013' 
   3  ARRAY(0x600501a88) 
      0  1.01 
      1  'InDev' 
      2  '01-Jul-2013' 
   4  ARRAY(0x6004a8508) 
      0  2.00 
      1  'InDev' 
      2  '01-Aug-2013'

1
2
3
4
5
6
7
8
 
  DB<7> c 
1.00    InDev   01-Jun-2013 
1.00    InTest  15-Jul-2013 
1.00    InUAT   31-Jul-2013 
1.01    InDev   01-Jul-2013 
2.00    InDev   01-Aug-2013 
Debugged program terminated.  Use q to quit or R to restart,

1
2
3
4
5
6
7
 
  DB<2> w $d 
  DB<3> c 
Watchpoint 0:   $d changed: 
    old value:  '' 
    new value:  '30' 
main::c(test.pl:16):               print $d if $d > 20;

1
2
3
4
5
6
use strict; 
use warnings; 
  
for my $i (1..10) {  
	print 2 * $i, "\n";  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
$ perl -d test_break.pl 
 
Loading DB routines from perl5db.pl version 1.33 
Editor support available. 
 
Enter h or `h h' for help, or `man perldebug' for more help. 
 
main::(test_break.pl:4):        for my $i (1..10) { 
  DB<1> b 5 $i > 7 
  DB<2> c 
2 
4 
6 
8 
10 
12 
14 
main::(test_break.pl:5):                print 2 * $i, "\n"; 
  DB<2> p $i 
8 
  DB<3> c 
16 
main::(test_break.pl:5):                print 2 * $i, "\n"; 
  DB<3> p $i 
9 
  DB<4> c 
18 
main::(test_break.pl:5):                print 2 * $i, "\n"; 
  DB<4> c 
20 
Debugged program terminated.  Use q to quit or R to restart,

Use of uninitialized value...

1
2
3
4
5
6
7
8
9
10
11
12
  
use strict; 
use warnings; 
  
my @array = 0..5; 
$array[$_] = $_ for 7..10; 
  
foreach (@array) { 
	my $count = $_ + 5; 
	print $count, "\n"; 
} 
print "end\n";

1
2
3
4
5
6
7
8
9
10
11
12
  DB<2> x @array 
0  0 
1  1 
2  2 
3  3 
4  4 
5  5 
6  undef 
7  7 
8  8 
9  9 
10  10

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$ perl  test_debug_warn.pl 
5 
6 
7 
8 
9 
10 
Use of uninitialized value $_ in addition (+) at test_debug_warn.pl line 11. 
5 
12 
13 
14 
15 
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
$ perl -d test_debug_warn.pl 
 
Loading DB routines from perl5db.pl version 1.33 
Editor support available. 
 
Enter h or `h h' for help, or `man perldebug' for more help. 
 
main::(test_debug_warn.pl:6):   my @array = 0..5; 
  DB<1> c 
5 
6 
7 
8 
9 
10 
Use of uninitialized value $_ in addition (+) at test_debug_warn.pl line 11. 
 at test_debug_warn.pl line 11 
5 
12 
13 
14 
15 
end 
Debugged program terminated.  Use q to quit or R to restart, 
  use o inhibit_exit to avoid stopping after program termination, 
  h q, h R or h o to get additional info.

1
2
3
4
5
6
7
8
9
10
11
12
sub afterinit  
{ 
    $::SIG{'__WARN__'} = sub { 
        my $warning = shift; 
        if ( $warning =~ m{uninitialized}xms ) { 
            $DB::single = 1;    # point d'arrêt, le débogueur s'arrête ici 
        } 
        warn $warning; 
    }; 
    print "sigwarn handler installed!\n"; 
    return; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
$ perl -d test_debug_warn.pl 
 
Loading DB routines from perl5db.pl version 1.33 
Editor support available. 
 
Enter h or `h h' for help, or `man perldebug' for more help. 
 
sigwarn handler installed! 
main::(test_debug_warn.pl:6):   my @array = 0..5; 
  DB<1> c 
5 
6 
7 
8 
9 
10 
Use of uninitialized value $_ in addition (+) at test_debug_warn.pl line 11. 
main::(test_debug_warn.pl:12):          print $count, "\n"; 
  DB<1> x $_ 
0  undef