Basic use of SimpleXML. Parsing XML Example #6 Comparing elements and attributes with text

Thus, in parts as you wish, you can send a large file to the processor.

Now let's look at how this data is processed and how to obtain it.

Let's start with the opening tags function startElement ($parser, $name, $attrs)
Let's assume that processing has reached the line
< ingredient amount = "3" unit = "стакан" >Flour
Then inside the function the variable $name will be equal to ingredient that is, the name of the open tag (it hasn’t come to closing the tag yet).
Also in this case, an array of attributes of this tag $attrs will be available, which will contain data amount = "3" and unit = "glass".

After this, the data of the open tag was processed by the function data ($parser, $data)
The $data variable will contain everything that is between the opening and closing tags, in our case this is the text Muka

And the processing of our string by the function ends endElement ($parser, $name)
This is the name of the closed tag, in our case $name will be equal to ingredient

And after that everything went in circles again.

The above example only demonstrates the principle of XML processing, but for real application it needs to be modified.
Typically, you have to parse large XML to enter data into the database, and to properly process the data you need to know which open tag the data belongs to, what level of tag nesting and which tags are open in the hierarchy above. With this information, you can process the file correctly without any problems.
To do this, you need to introduce several global variables that will collect information about open tags, nesting and data.
Here's an example you can use

Function webi_xml ($file)
{
global $webi_depth ; // counter to track nesting depth
$webi_depth = 0 ;
global $webi_tag_open ; // will contain an array of currently open tags
$webi_tag_open = array();
global $webi_data_temp ; // this array will contain the data of one tag

####################################################
### data function
function data ($parser, $data)
{
global $webi_depth ;
global $webi_tag_open ;
global $webi_data_temp ;
// add data to the array indicating nesting and currently open tag
$webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "data" ].= $data ;
}
############################################

####################################################
### opening tag function
function startElement ($parser, $name, $attrs)
{
global $webi_depth ;
global $webi_tag_open ;
global $webi_data_temp ;

// if the nesting level is no longer zero, then one tag is already open
// and the data from it is already in the array, you can process it
if ($webi_depth)
{

" ;

print "
" ;
print_r($webi_tag_open); // array of open tags
print "

// after processing the data, delete it to free up memory
unset($GLOBALS [ "webi_data_temp" ][ $webi_depth ]);
}

// now the next tag is opened and further processing will occur in the next step
$webi_depth++; // increase nesting

$webi_tag_open [ $webi_depth ]= $name ; // add an open tag to the information array
$webi_data_temp [ $webi_depth ][ $name ][ "attrs" ]= $attrs ; // now add tag attributes

}
###############################################

#################################################
## closing tag function
function endElement ($parser, $name) (
global $webi_depth ;
global $webi_tag_open ;
global $webi_data_temp ;

// data processing begins here, for example adding to the database, saving to a file, etc.
// $webi_tag_open contains a chain of open tags by nesting level
// for example $webi_tag_open[$webi_depth] contains the name of the open tag whose information is currently being processed
// $webi_depth tag nesting level
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["attrs"] array of tag attributes
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["data"] tag data

Print "data" . $webi_tag_open [ $webi_depth ]. "--" .($webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "data" ]). "
" ;
print_r ($webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "attrs" ]);
print "
" ;
print_r($webi_tag_open);
print "

Unset($GLOBALS [ "webi_data_temp" ]); // after processing the data, we delete the entire array with the data, since the tag was closed
unset($GLOBALS [ "webi_tag_open" ][ $webi_depth ]); // delete information about this open tag... since it closed

$webi_depth --; // reduce nesting
}
############################################

$xml_parser = xml_parser_create();
xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, true);

// indicate which functions will work when opening and closing tags
xml_set_element_handler($xml_parser, "startElement", "endElement");

// specify a function for working with data
xml_set_character_data_handler($xml_parser, "data");

// open the file
$fp = fopen($file, "r");

$perviy_vxod = 1 ; // flag to check the first entry into the file
$data = "" ; // here we collect data from the file in parts and send it to the xml parser

// loop until the end of the file is found
while (! feof ($fp ) and $fp )
{
$simvol = fgetc ($fp); // read one character from the file
$data .= $simvol ; // add this character to the data to be sent

// if the character is not the end tag, then go back to the beginning of the loop and add another character to the data, and so on until the end tag is found
if($simvol != ">" ) ( continue;)
// if the closing tag was found, now we will send this collected data for processing

// check if this is the first entry into the file, then we will delete everything that is before the tag// since sometimes you may encounter garbage before the beginning of the XML (clumsy editors, or the file was received by a script from another server)
if($perviy_vxod ) ( $data = strstr ($data , "

// now throw the data into the xml parser
if (! xml_parse ($xml_parser, $data, feof ($fp))) (

// here you can process and receive validity errors...
// as soon as an error is encountered, parsing stops
echo "
XML Error: " . xml_error_string(xml_get_error_code($xml_parser));
echo "at line" . xml_get_current_line_number ($xml_parser);
break;
}

// after parsing, discard the collected data for the next step of the cycle.
$data = "" ;
}
fclose($fp);
xml_parser_free($xml_parser);
// removing global variables
unset($GLOBALS [ "webi_depth" ]);
unset($GLOBALS [ "webi_tag_open" ]);
unset($GLOBALS [ "webi_data_temp" ]);

Webi_xml("1.xml");

?>

The entire example is accompanied by comments, now test and experiment.
Please note that in the function of working with data, data is not simply inserted into an array, but rather added using " .=" since the data may not arrive in its entirety, and if you just make an assignment, then from time to time you will receive the data in chunks.

Well, that’s all, now there is enough memory when processing a file of any size, but the script’s running time can be increased in several ways.
Insert a function at the beginning of the script
set_time_limit(6000);
or
ini_set ("max_execution_time" , "6000" );

Or add text to the .htaccess file
php_value max_execution_time 6000

These examples will increase the script running time to 6000 seconds.
You can increase the time in this way only when safe mode is turned off.

If you have access to edit php.ini you can increase the time using
max_execution_time = 6000

For example, on the Masterhost hosting, at the time of writing this article, increasing the script time is prohibited, despite safe mode being turned off, but if you are a pro, you can make your own PHP build on the Masterhost, but that is not the subject of this article.

Now we will study working with XML. XML is a format for exchanging data between sites. It is very similar to HTML, but XML allows its own tags and attributes.

Why is XML needed for parsing? Sometimes it happens that the site that you need to parse has an API with which you can get what you want without much effort. Therefore, just a piece of advice - before parsing a site, check whether it has an API.

What is an API? This is a set of functions with which you can send a request to this site and receive the desired response. This answer most often comes in XML format. So let's start studying it.

Working with XML in PHP

Let's say you have XML. It can be in a string, or stored in a file, or served upon request to a specific URL.

Let the XML be stored in a string. In this case, you need to create an object from this string using new SimpleXMLElement:

$str = " Kolya 25 1000 "; $xml = new SimpleXMLElement($str);

Now we have in the variable $xml an object with parsed XML is stored. By accessing the properties of this object, you can access the contents of the XML tags. We’ll look at how exactly below.

If the XML is stored in a file or sent by accessing a URL (which is most often the case), then you should use the function simplexml_load_file, which makes the same object $xml:

Kolya 25 1000

$xml = simplexml_load_file(path to file or URL);

Working methods

In the examples below, our XML is stored in a file or URL.

Let the following XML be given:

Kolya 25 1000

Let's get the employee's name, age and salary:

$xml = simplexml_load_file(path to file or URL); echo $xml->name; //will display "Kolya" echo $xml->age; //will output 25 echo $xml->salary; //will output 1000

As you can see, the $xml object has properties corresponding to the tags.

You may have noticed that the tag does not appear anywhere in the appeal. This is because it is the root tag. You can rename it, for example, to - and nothing will change:

Kolya 25 1000

$xml = simplexml_load_file(path to file or URL); echo $xml->name; //will display "Kolya" echo $xml->age; //will output 25 echo $xml->salary; //will output 1000

There can only be one root tag in XML, just like the in regular HTML.

Let's modify our XML a little:

Kolya 25 1000

In this case, we will get a chain of calls:

$xml = simplexml_load_file(path to file or URL); echo $xml->worker->name; //will display "Kolya" echo $xml->worker->age; //will output 25 echo $xml->worker->salary; //will output 1000

Working with attributes

Let some data be stored in attributes:

Number 1

$xml = simplexml_load_file(path to file or URL); echo $xml->worker["name"]; //will display "Kolya" echo $xml->worker["age"]; //will output 25 echo $xml->worker["salary"]; //will output 1000 echo $xml->worker; //will display "Number 1"

Tags with hyphens

XML allows tags (and attributes) with a hyphen. In this case, accessing such tags occurs like this:

Kolya Ivanov

$xml = simplexml_load_file(path to file or URL); echo $xml->worker->(first-name); //will display "Kolya" echo $xml->worker->(last-name); //will display "Ivanov"

Looping

Let us now have not one employee, but several. In this case, we can iterate over our object using a foreach loop:

Kolya 25 1000 Vasya 26 2000 Peter 27 3000

$xml = simplexml_load_file(path to file or URL); foreach ($xml as $worker) ( echo $worker->name; //will display "Kolya", "Vasya", "Petya" )

From object to normal array

If you're not comfortable working with the object, you can convert it to a normal PHP array using the following trick:

$xml = simplexml_load_file(path to file or URL); var_dump(json_decode(json_encode($xml), true));

More information

Parsing based on sitemap.xml

Often a site has a sitemap.xml file. This file stores links to all pages of the site for ease of indexing by search engines (indexing is essentially site parsing by Yandex and Google).

In general, we shouldn’t worry much about why this file is needed, the main thing is that if it exists, you don’t have to crawl through the pages of the site using any tricky methods, but simply use this file.

How to check the presence of this file: let us parse the site site.ru, then go to site.ru/sitemap.xml in the browser - if you see something, then it’s there, and if you don’t see it, then alas.

If there is a sitemap, then it contains links to all pages of the site in XML format. Calmly take this XML, parse it, separate links to the pages you need in any way convenient for you (for example, by analyzing the URL, which was described in the spider method).

As a result, you get a list of links for parsing; all you have to do is go to them and parse the content you need.

Read more about the sitemap.xml device on Wikipedia.

What should you do next:

Start solving problems using the following link: problems for the lesson.

When you decide everything, move on to studying a new topic.