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 , the stack is filled as follows:
Start element book: assign "book" to the first element of the stack ($ stack[0]).
Start element title: Assign "title" to the top of the stack ($stack[1]).
End element title: Remove the top element from the stack ($stack[1]).
End element title: Remove the top element from the stack ($stack[0]).
PHP3.0 implements the example by manually controlling the nesting of elements through a $depth variable. This makes the script look more complex. PHP4.0 uses the array_pop() and
array_push() functions to make the script look more concise.
Collect data
In order to collect information about each element, the script needs to remember the events of each element. Save all the different elements
in the document by using a global array variable $elements. The items of the array are instances of the element class and have 4 attributes (variables of the class)
$count - the number of times the element was found in the document
$chars - the number of bytes of character events in the element
$parents - Parent element
$childs - Child element
As you can see, saving class instances in an array is a piece of cake.
Note: A feature of PHP is that you can traverse the entire class structure through while(list() = each())loop, just like you traverse the entire corresponding array. All class variables
(and method names when you use PHP3.0) are output as strings.
When an element is found, we need to increment its corresponding counter to keep track of how many times it appears in the document. The count element in the corresponding $elements item is also incremented by one.
We also need to let the parent element know that the current element is its child element. Therefore, the name of the current element will be added to the item in the $childs array of the parent element. Finally, the current
element should remember who its parent is. Therefore, the parent element is added to the item in the $parents array of the current element.
Display statistical information
The remaining code loops through the $elements array and its subarrays to display its statistical results. This is the simplest nested loop. Although it outputs the correct result, the code is neither simple nor has any special skills. It is just a loop that you may use every day to complete your work.
The script example is designed to be called through the command line in PHP's CGI mode. Therefore, the statistical result output format is text format. If you want to use the script on the Internet
, then you need to modify the output function to generate HTML format.
Summary
Exapt is an XML parser for PHP. As an event-based parser, it does not produce a structural description of the document. But by providing low-level access, this allows for better utilization of resources and faster access.
As a parser that does not check validity, Expat ignores DTDs attached to XML documents, but it will stop with an error message if the document is not well-formed.
Provide event handling functions to process documents
Build your own event structures such as stacks and trees to get the advantages of XML structured information markup.
New XML programs appear every day, and PHP's support for XML is constantly being strengthened (for example, support for the DOM-based XML parser LibXML has been added).
With PHP and Expat, you can prepare for the coming standards that are valid, open, and platform-independent.

http://www.bkjia.com/PHPjc/319455.html