PHP XML Expat parser: how to read only part of the XML document?

As suggested in a comment earlier, you can alternatively use the XMLReader^Docs.

The XMLReader extension is an XML Pull parser. The reader acts as a cursor going forward on the document stream and stopping at each node on the way.

It is a class (with the same name: XMLReader) which can open a file. By default you use next() to move to the next node. You would then check if the current position is at an element and then if the element has the name you're looking for and then you could process it, for example by reading the outer XML of the element XMLReader::readOuterXml()^Docs.

Compared with the callbacks in the Expat parser, this is a little burdensome. To gain more flexibility with XMLReader I normally create myself iterators that are able to work on the XMLReader object and provide the steps I need.

They allow to iterate over the concrete elements directly with foreach. Here is such an example:

require('xmlreader-iterators.php'); // https://gist.github.com/hakre/5147685

$xmlFile = '../data/posts.xml';

$ids = array(3, 8);

$reader = new XMLReader();
$reader->open($xmlFile);

/* @var $users XMLReaderNode[] - iterate over all <user> elements */
$users = new XMLElementIterator($reader, 'user');

/* @var $filteredUsers XMLReaderNode[] - iterate over elements with id="3" or id="8" */
$filteredUsers = new XMLAttributeFilter($users, 'id', $ids);

foreach ($filteredUsers as $user) {
    printf("---------------nUser with ID %d:n", $user->getAttribute('id'));
    echo $user->readOuterXml(), "n";
}

I have create an XML file that contains some more posts like in your question, numbered in the id attribute from one and up:

$xmlFile = '../data/posts.xml';

Then I created an array with two ID values of the user interested in:

$ids = array(3, 8);

It will be used in the filter-condition later. Then the XMLReader is created and the XML file is opened by it:

$reader = new XMLReader();
$reader->open($xmlFile);

The next step creates an iterator over all <user> elements of that reader:

$users = new XMLElementIterator($reader, 'user');

Which are then filtered for the id attribute values stored into the array earlier:

$filteredUsers = new XMLAttributeFilter($users, 'id', $ids);

The rest is iterating with foreach now as all conditions have been formulated:

foreach ($filteredUsers as $user) {
    printf("---------------nUser with ID %d:n", $user->getAttribute('id'));
    echo $user->readOuterXml(), "n";
}

which will return the XML of the users with the IDs 3 and 8:

---------------
User with ID 3:
<user id="3">
        <post>
            <message>message</message>
            <client>client</client>
            <time>time</time>
        </post>
    </user>
---------------
User with ID 8:
<user id="8">
        <post>
            <message>message 8.1</message>
            <client>client</client>
            <time>time</time>
        </post>
        <post>
            <message>message 8.2</message>
            <client>client</client>
            <time>time</time>
        </post>
        <post>
            <message>message 8.3</message>
            <client>client</client>
            <time>time</time>
        </post>
    </user>

The XMLReaderNode which is part of the XMLReader iterators does also provide a SimpleXMLElement^Docs in case you want to easily read values inside of the <user> element.

The following example shows how to get the count of <post> elements inside the <user> element:

foreach ($filteredUsers as $user) {
    printf("---------------nUser with ID %d:n", $user->getAttribute('id'));
    echo $user->readOuterXml(), "n";
    echo "Number of posts: ", $user->asSimpleXML()->post->count(), "n";
}

This would then display Number of posts: 1 for the user ID 3 and Number of posts: 3 for the user ID 8.

However, if that outer XML is large, you don't want to do that and you want to continue to iterate inside that element:

// rewind
$reader->open($xmlFile);

foreach ($filteredUsers as $user) {
    printf("---------------nUser with ID %d:n", $user->getAttribute('id'));
    foreach ($user->getChildElements('post') as $index => $post) {
        printf(" * #%d: %sn", ++$index, $post->getChildElements('message'));
    }
    echo "Number of posts: ", $index, "n";
}

Which produces the following output:

---------------
User with ID 3:
 * #1: message 3
Number of posts: 1
---------------
User with ID 8:
 * #1: message 8.1
 * #2: message 8.2
 * #3: message 8.3
Number of posts: 3

This example shows: depending on how large the nested children are, you can traverse further with the iterators available via getChildElements() or you can use as well the common XML parser like SimpleXML or even DOMDocument on a subset of the XML.

WideDonkey, have you considered using the DOM instead? You can easily do :

$dom = new DOMDocument();
$dom->loadXML(file_get_contents('php://input'));

$data = $dom->getElementsByTagName('data');
$data = $data[0]->asXML();

Give LINQ to XML a try. XElement result = XElement.Load(@"C:div_kid.xml");

Querying in LINQ is brilliant but admittedly a little weird at the start. You select nodes from the Document in a SQL like syntax, or using lambda expressions. Then create anonymous objects (or use existing classes) containing the data you are interested in.

Best is to see it in action.

• miscellaneous examples of LINQ to XML
• simple sample using xquery and lambdas
• sample denoting namespaces
• There is tons more on msdn. Search for LINQ to XML.

Based on your sample XML and code, here's a specific example:

var element = XElement.Load(@"C:div_kid.xml");
var shopsQuery =
    from shop in element.Descendants("shop")
    select new
    {
        Name = (string) shop.Descendants("name").FirstOrDefault(),
        Company = (string) shop.Descendants("company").FirstOrDefault(),
        Categories = 
            from category in shop.Descendants("category")
            select new {
                Id = category.Attribute("id").Value,
                Parent = category.Attribute("parentId").Value,
                Name = category.Value
            },
        Offers =
            from offer in shop.Descendants("offer")
            select new { 
                Price = (string) offer.Descendants("price").FirstOrDefault(),
                Picture = (string) offer.Descendants("picture").FirstOrDefault()
            }

    };

foreach (var shop in shopsQuery){
    Console.WriteLine(shop.Name);
    Console.WriteLine(shop.Company);
    foreach (var category in shop.Categories)
    {
        Console.WriteLine(category.Name);
        Console.WriteLine(category.Id);
    }
    foreach (var offer in shop.Offers)
    {
        Console.WriteLine(offer.Price);
        Console.WriteLine(offer.Picture);
    }
}  

As an extra: Here's how to deserialize the tree of categories from the flat category elements. You need a proper class to house them, for the list of Children must have a type:

class Category
{
    public int Id { get; set; }
    public int? ParentId { get; set; }
    public List<Category> Children { get; set; }
    public IEnumerable<Category> Descendants {
        get
        {
            return (from child in Children
                    select child.Descendants).SelectMany(x => x).
                    Concat(new Category[] { this });
        }
    }
}

To create a list containing all distinct categories in the document:

var categories = (from category in element.Descendants("category")
                    orderby int.Parse( category.Attribute("id").Value )
                    select new Category()
                    {
                        Id = int.Parse(category.Attribute("id").Value),
                        ParentId = category.Attribute("parentId") == null ?
                            null as int? : int.Parse(category.Attribute("parentId").Value),
                        Children = new List<Category>()
                    }).Distinct().ToList();

Then organize them into a tree (Heavily borrowed from flat list to hierarchy):

var lookup = categories.ToLookup(cat => cat.ParentId);
foreach (var category in categories)
{
    category.Children = lookup[category.Id].ToList();
}
var rootCategories = lookup[null].ToList();

To find the root which contains theCategory:

var root = (from cat in rootCategories
            where cat.Descendants.Contains(theCategory)
            select cat).FirstOrDefault();