export_symbol php xml analysis function code page 1/2

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. At the same time, examples can show you
how to:
Build your own processing functions
Convert XML documents into your own PHP data structures
Introduce Expat
XML parsers, also called XML processors, allow programs to access XML documents structure and content. 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 parsers: Convert 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 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 of a "Hello-World" XML document:

Hello World

The event-based parser will report as three events:
Start element: greeting
CDATA item Starts with the value: Hello World
Ending element: greeting
Unlike tree-based parsers, event-based parsers do not produce a structure that describes the document. In CDATA items, the event-based parser will not let you get the 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 Hello-World example above includes the 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 DTDs 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 child elements of the element
Note: For demonstration purposes, we use PHP to generate a structure to save the parent element and child elements of the element
Preparation
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 the MySQL function 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 appearance of an external entity
Unparsed external entity xml_set_unparsed_entity_decl_handler() The occurrence of unresolved external entity
The occurrence of processing instruction xml_set_processing_instruction_handler() The occurrence of processing instruction
The occurrence of notation declaration xml_set_notation_decl_handler() The occurrence of notation declaration
Default xml_set_default_handler() Other events without specified handler function
All The callback function must take an instance of the parser as its first argument (in addition to other arguments).
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 requires 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
The callback function must exist when starting to parse the XML document. 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 starting element, and the third parameter contains all attributes of the element and an array of values.
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 preparations, now the script can finally parse the XML document:
Xml_parse_from_file(), a custom function that opens the file specified in the parameter and parses it in 4kb size
xml_parse() and Like xml_parse_from_file(), when an error occurs, that is, 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, the callback function is called.
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 array_pop() and
array_push() functions to make scripts 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 properties (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 - the parent element
$childs - child elements
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 statistics
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 results, 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 examples are designed to be called from the command line via PHP's CGI method. 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 connected to XML documents, but if the document is not well-formed it will stop with an error message.
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.

Current page 1/2 12Next page

The above introduces the export_symbol php xml analysis function code page 1/2, including the content of export_symbol. I hope it will be helpful to friends who are interested in PHP tutorials.