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:
61:
62:
63:
64:
65:
66:

#! /usr/bin/perl
use strict;
use warnings;
use  HTML::Parser;

# Hier stehen dann nachher die Links drin
my @links;

# Das ist einfach nur Beispiel Text und der geht von qq~ bis ~ nicht von " bis " !!! ;)
my $string = qq~<a href="url1">linktext1</a> Ein anderer Text
                <a href="url2">linktext2</a> text~;

# Ein Object vom Parser erstellen
my $p =  HTML::Parser->new();

# Hier wird eine Rückruf Sub (Callback oder auch Handler genannt) festgelegt.
# Der Parser ruft diese Funktion immer genau dann auf wenn er einen Anfang eines Tags
# findet.
# Der erste Parameter gibt an des es eben der Handler für den Start eines Tags ist
# Der zweite Parameter gibt an, das die Parameter die dem Handler übergeben werden
# sollen in der Reihenfolge tagname, attr, self sind bzw. sein sollen. 
# tagname ist der Name des gefunden Tags logisch oder ;)
# attr ist ein Hash von den attributen die das Tag hat
# und self ist das Object vom Parser also im endeffekt in diesem Beispiel wieder das $p
# von ein paar Zeilen drüber
$p->handler(start => \&start_handler,"tagname,attr,self");

# hier fängt der eigentlich Parse Vorgang an
$p->parse($string);

# nur die Ausgabe nachdem alles fertig ist ;)
foreach my $link(@links){
  print "Linktext: ",$link->[1],"\tURL: ",$link->[0],"\n";
}

# Hier unser start Handler
sub start_handler{
  # wir errinnern uns, der erste Parameter war tagname
  # d.h. wenn der Tagname nicht "a" ist, von dem Tag was gefunden wurde 
  # wird hier nix gemacht
  return if(shift ne 'a');

  # der zweite Parameter waren die attribute 
  # und hier wird der Inhalt des Attributes href rausgeholt und abgelegt.
  my ($class) = shift->{href};

  # jetzt noch unser $p holen 
  my $self = shift;

  my $text;

  # hier werden jetzt dynamisch sub erzeugt und als handler angegeben
  # Dieser handler ist für den Text <a>TEXT</a> zuständig und wird
  # aufgerufen wenn der Text gefunden wurde, der erste Parameter des Subs wird
  # hier festgelegt auf den Text ansich. Mehr Parameter für das Sub werden hier nicht 
  # benötigt.
  $self->handler(text => sub{$text = shift;},"dtext");

  # Dieser Handler ist für das Ende Tag zuständig also für </a> bzw. er wird dann 
  # aufgerufen wenn das Ende gefunden wurde.
  # hier wird wieder ein Sub dynamisch erzeugt, und als Parameter bekommt dieses sub 
  # nur den Tagnamen also "a". Wird das Sub aufgerufen, prüft es nach ob der erste 
  # Parameter ein "a" ist, wenn dann wird in das Array @links ein Array reingepusht mit 
  # dem Text der im Texthandler und mit dem link der im Starthandler 
  # im Attribute href gefunden wurde.
  $self->handler(end => sub{push(@links,[$class,$text]) if(shift eq 'a')},"tagname");

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:

 my $parser =  HTML::Parser->new(
    start_h => [ \&_starttag, 'self, tagname, attr' ],
    end_h   => [ \&_endtag,   'self, tagname' ],
    text_h  => [ \&_text,     'self, dtext' ]
  );

$parser->parse($email_text);

sub _starttag {
    my ($self, $tag, $attr) = @_;
    $self->{'_body'} = 1 if($tag eq 'body');
}

sub _endtag {
    my ($self, $tag) = @_;
    $self->{'_body' } = 0 if($tag eq 'body'  );
}

sub _text {
    my ($self, $dtext) = @_;

    $dtext =~ s/\A\s+//;
    $dtext =~ s/\s+\z//;
    return() unless ( length($dtext) > 0 and $dtext =~ /[^\s]/ );

    if ($self->{'_body'}    == 1) {
      print $dtext;
    }
}

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:

# hier wird ein neues objekt (namens $parser) der klasse  HTML::Parser erzeugt.
# als events werden start_h, end_h und text_h mit eingebunden, welche eine referenz
# auf die funktionen _starttag, _endtag und _text enthalten. am ende jeder zeile werden
# die benötigten attribute mit übergeben, self steht dabei für das objekt (hier $parser).
my $parser =  HTML::Parser->new( 
    start_h => [ \&_starttag, 'self, tagname, attr' ], 
    end_h   => [ \&_endtag,   'self, tagname' ], 
    text_h  => [ \&_text,     'self, dtext' ] 
  ); 

# aufruf der methode ?parse? mit dem übergabewert $email_text
$parser->parse($email_text); 

# funktion die bei jedem start_h event ausgeführt wird, also wenn ein  HTML-tag
# im text beginnt
sub _starttag { 
    my ($self, $tag, $attr) = @_; 
    # wenn der aktuelle start- HTML-tag = ?body? entspricht, setze die eigenschaft _body des
    # aktuellen objekts (hier $self was im grunde für $parser steht) = 1.
  $self->{'_body'} = 1 if($tag eq 'body'); 
} 

# funktion die bei jedem end_h event ausgeführt wird, also wenn ein  HTML-tag
# im text geschlossen wird
sub _endtag { 
    my ($self, $tag) = @_; 
    # wenn der aktuelle end- HTML-tag = ?body? entspricht, setze die eigenschaft _body des
    # aktuellen objekts (hier $self was im grunde für $parser steht) = 0.
    $self->{'_body' } = 0 if($tag eq 'body'  ); 
} 

# funktion die bei jedem text_h event ausgeführt wird
sub _text { 
    my ($self, $dtext) = @_; 

    # am anfang und ende des strings steuerzeichen entfernen
    $dtext =~ s/\A\s+//; 
    $dtext =~ s/\s+\z//; 
    # prüfen, ob der string mehr als 0 zeichen und nicht nur steuerzeichen enthält
    return() unless ( length($dtext) > 0 and $dtext =~ /[^\s]/ ); 

    # solange man sich zwischen den body-tags befindet (siehe funktion _startag und _endtag)  
    # ausgabe von $dtext (enthält alles zwischen den beiden aktuellen tags)
    if ($self->{'_body'}    == 1) { 
      print $dtext; 
    } 
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

#!/usr/bin/perl -w

use strict;
use warnings;
use  HTML::FormatText;
use  HTML::Parse;

my $ HTML;
my $formatter;


$ HTML =  HTML::Parse::parse_htmlfile("beispiel. HTML");
# alternativ ginge auch... $ HTML =  HTML::Parse::parse_html($text);
# ...um den  HTML-Text aus einer Variablen zu holen

$formatter =  HTML::FormatText->new();

print $formatter->format($ HTML);