I find generally that XML::Simple ain't. Try XML::TreeBuilder or XML::Twig instead:

use strict;
use warnings;

use XML::TreeBuilder;
use XML::Twig;

my $xml = do {local $/; <DATA>};

print "Using TreeBuilder:\n";

my $root = XML::TreeBuilder->new ();
$root->parse ($xml);

my @itemNodes = $root->look_down ('_tag', 'item');
my $nodeCount;

for my $nodeIndex (0 .. @itemNodes - 1) {
    my @titles = $itemNodes[$nodeIndex]->look_down ('_tag', 'title');
   
    print "Item node " . ($nodeIndex + 1) . "\n";
    print "   ", $_->as_text (), "\n" for @titles;
}

print "\nUsing  Twig\n";

my $t= XML::Twig->new (twig_roots => {item => \&data});

$t->parse ($xml);


sub data {
    my ($t, $data) = @_;
   
    ++$nodeCount;
    print "Item node $nodeCount\n";
   
    my @titles = $data->descendants ('title');
   
    print "   ", $_->trimmed_text (), "\n" for @titles;
}


__DATA__
<inbox>
    <item>
        <title>Foo</title>
        <description>Bar</description>
    </item>
    <item>
        <title>Baz</title>
        <description>Foobar</description>
    </item>
</inbox>
[download]

Prints:

Using TreeBuilder:
Item node 1
   Foo
Item node 2
   Baz

Using  Twig
Item node 1
   Foo
Item node 2
   Baz
[download]

I will agree with GrandFather, unless the document is very simple XML, XML::Simple takes some work to get right. Use XML::Twig, it might take a little while to figure it out but is more scalable than XML::Simple.

I am writing my first ever Perl script, and without this example I would be lost. Thanks a lot for posting this!

Does anyone know what I would need to do to loop through each item under inbox?

Sure. Determine what $d looks like and then walk that data structure.

use Data::Dump::Streamer;
my $xml = XML::Simple->new();
my $d = $xml->XMLin("sample.xml",ForceArray => 1, KeepRoot => 1);
Dump $d;
[download]

Gives

$HASH1 = { 
  inbox => [ 
    { 
      item => [
        {
          description => [ 'Bar' ],
          title       => [ 'Foo' ]
        },
        {
          description => [ 'Foobar' ],
          title       => [ 'Baz' ]
        }
      ] 
    } 
  ] 
};
[download]

Now, for that sample XML it seems to have lots of redundant hashes and arrays if what you care about are the items. So, maybe don't use the extra options:

my $d = $xml->XMLin("sample.xml");
[download]

Gives:

$HASH1 = { 
  item => [
    {
      description => 'Bar',
      title       => 'Foo'
    },
    {
      description => 'Foobar',
      title       => 'Baz'
    }
  ] 
};
[download]

So with that, $d->{item} would appear to be an AOH. Loop through it like this:

for my $item ( @{ $d->{item} } ) {
  print "$item->{title}\n";          # for example
}
[download]

This is a bit problematic since if there ever was XML that'd contain only one <item> tag the structure would look different. With recent enough XML::Simple you can specify what tags to force to arrays$xml->XMLin("sample.xml",ForceArray => ['item']).

In case the XML starts to get bigger, it may be better to start using something different. XML::Twig or ... everyone guessed by now ... XML::Rules ;-)

use XML::Rules;

my $parser = XML::Rules->new(
 rules => [
  'description,title' => 'content',
  'item' => sub {
    print "$_[1]->{title}: $_[1]->{description}\n"
    return;
  },
  'inbox' => '',
 ],
);

$parser->parse('sample.xml');
[download]

Jenda


Support Denmark! Defend the free world!