Home >Backend Development >PHP Tutorial >PHP xml analysis function code page 1/2_PHP tutorial
First of all I have to admit that I love computer standards. If everyone followed the industry's standards, the Internet would be a better medium. The use of standardized data exchange formats makes open and platform-independent computing models feasible. That's why I'm an XML enthusiast.
Fortunately, my favorite scripting language not only supports XML but is increasingly supporting it. PHP allows me to quickly publish XML documents to the Internet, collect statistical information about XML documents, and convert XML documents into other formats. For example, I often use PHP's XML processing capabilities to manage articles and books I write in XML.
In this article, I will discuss any use of PHP's built-in Expat parser to process XML documents. Through examples, I will demonstrate the processing method of Expat. In the meantime, examples can show you
how to:
Build your own processing functions
Convert XML documents into your own PHP data structures
Introduce Expat
XML parser, also known as XML processor allows programs to access the structure and content of XML documents. Expat is an XML parser for the PHP scripting language. It is also used in
other projects, such as Mozilla, Apache and Perl.
What is an event-based parser?
Two basic types of XML parsers:
Tree-based parser: converts XML documents into tree structures. This type of parser parses the entire article while providing an API to access each element of the resulting tree. The commonly used standard is DOM (Document Object Mode).
Event-based parser: Treat XML documents as a series of events. When a special event occurs, the parser will call the function provided by the developer to handle it.
The event-based parser has a data-focused view of the XML document, which means that it focuses on the data part of the XML document, not its structure. These parsers process the document from beginning to end and report events like - start of element, end of element, start of feature data, etc. - to the application through callback functions.
The following is an example XML document for "Hello-World":
Hello World
The event-based parser will report as three Event:
Start element: greeting
Start of CDATA item, value: Hello World
End element: greeting
Unlike tree-based parser, event-based parser does not generate a description document structure. In CDATA items, the event-based parser will not let you get information about the parent element
greeting.
However, it provides a lower level access, which allows for better utilization of resources and faster access. This way, there is no need to fit the entire document into memory
; in fact, the entire document can even be larger than the actual memory value.
Expat is such an event-based parser. Of course, if you use Expat, it can also generate a complete native tree structure in PHP if necessary.
The above Hello-World example includes complete XML format. But it is invalid because there is neither a DTD (Document Type Definition) associated with it nor an embedded DTD.
With Expat, this makes no difference: Expat is a parser that does not check validity, and therefore ignores any DTD associated with the document. It should be noted, however, that the document still needs to be in complete
format, otherwise Expat (like other XML-compliant parsers) will stop with an error message.
As a parser that does not check validity, Exapt’s speed and lightweight make it ideal for Internet programs.
Compile Expat
Expat can be compiled into PHP3.0.6 version (or above). Starting from Apache 1.3.9, Expat has been included as part of Apache. On Unix systems, you can compile it into PHP by configuring PHP with the -with
-xml option.
If you compile PHP as an Apache module, Expat will be included as part of Apache by default. In Windows, you must load the XML dynamic link library.
XML Example: XMLstats
One way to understand Expat's functions is through examples. The example we are going to discuss is using Expat to collect statistics on XML documents.
For each element in the document, the following information will be output:
The number of times the element is used in the document
The amount of character data in the element
The parent element of the element
The element's Child elements
Note: For demonstration purposes, we use PHP to generate a structure to save the parent element and child elements of the element
Prepare
The function used to generate an XML parser instance is xml_parser_create(). This instance will be used for all future functions. This idea is very similar to the
connection tag of MySQL functions in PHP. Before parsing the document, event-based parsers usually require you to register a callback function - to be called when a specific event occurs.Expat has no exception events. It
defines the following seven possible events:
Object XML parsing function description
Element xml_set_element_handler() The beginning and end of the element
Character data xml_set_character_data_handler() The beginning of character data External entity XML_SET_EXTERNAL_ENTITY_REF_HANDLER () The external entity appears. ing_inStruction_handler () The emergence of the processing instruction
Remembering the method xml_set_notation_deCl_Handler () Occurrences of
Default xml_set_default_handler() Other events that do not specify a handler
All callback functions must take an instance of the parser as their first parameter (in addition to other parameters).
For the sample script at the end of this article. What you need to note is that it uses both element processing functions and character data processing functions. The callback handler function of the element is registered through
xml_set_element_handler().
This function takes three parameters:
Instance of the parser
The name of the callback function that handles the starting element
The name of the callback function that handles the ending element
When starting to parse the XML document, the callback The function must exist. They must be defined consistent with the prototypes described in the PHP manual.
For example, Expat passes three parameters to the handler function of the starting element. In the script example, it is defined as follows:
function start_element($parser, $name, $attrs)
The first parameter is the parser identifier, the second parameter is the name of the start element, and the third parameter is An array containing all attributes and values of the element.
Once you start parsing the XML document, Expat will call your start_element() function and pass the parameters whenever it encounters the start element.
XML Case Folding option
Use the xml_parser_set_option () function to turn off the Case folding option. This option is on by default, causing element names passed to handler functions to be automatically converted to
uppercase. But XML is case-sensitive (so case is very important for statistical XML documents). For our example, the case folding option must be turned off.
Parse the document
After completing all the preparation work, now the script can finally parse the XML document:
Xml_parse_from_file(), a custom function, opens the file specified in the parameter and does it in 4kb size Parsing
xml_parse() is the same as xml_parse_from_file(). When an error occurs, that is, when the format of the XML document is incomplete, false will be returned.
You can use the xml_get_error_code() function to get the numeric code of the last error. Pass this numeric code to the xml_error_string() function to get the
error text message.
Output the current line number of XML, making debugging easier.
During the parsing process, call the callback function.
Describe the document structure
When parsing a document, the question that needs to be emphasized for Expat is: How to maintain a basic description of the document structure?
As mentioned before, the event-based parser itself does not produce any structural information.
However, the tag structure is an important feature of XML. For example, the element sequence
http://www.bkjia.com/PHPjc/319455.html