PHP操作XML详解

由 ·

 

    XML是一种流行的半结构化文件格式，以一种类似数据库的格式存储数据。在实际应用中，一些简单的、安全性较低的数据往往使用 XML文件的格式进行存储。这样做的好处一方面可以通过减少与数据库的交互性操作提高读取效率，另一方面可以有效利用 XML的优越性降低程序的编写难度。
       PHP提供了一整套的读取 XML文件的方法，很容易的就可以编写基于 XML的脚本程序。本章将要介绍 PHP与 XML的操作方法，并对几个常用的 XML类库做一些简要介绍。
1 XML简介
XML是“可扩展性标识语言（eXtensible Markup Language）”的缩写，是一种类似于 HTML的标记性语言。但是与 HTML不同，XML主要用于描述数据和存放数据，而 HTML主要用于显示数据。
XML是一种“元标记”语言，开发者可以根据自己的需要创建标记的名称。例如，下面的 XML代码可以用来描述一条留言。

  1. <thread>
  2. <title>Welcome</title>
  3. <author>Simon</author>
  4. <content>Welcome to XML guestbook!!</content>
  5. </thread>

其中，<thread>与</thread>标签标记了这是一段留言。在留言中有标题、作者、内容，完整的表述了一条留言信息。
在一个 XML文件的顶部，通常使用<?xml version=”1.0″?>来标识 XML数据的开始和 XML数据使用标准的版本信息。在浏览器中访问 XML文件可以看到层次分明的 XML数据信息，如图 1所示。

XML的发展非常迅速，近些年来很多软件开发商都开始采用 XML的开发标准进行应用程序的开发。并且，很多新兴技术都架构在 XML数据之上。这意味着 XML将与 HTML一样成为 Web技术不可或缺的一部分。
2 简单的 XML操作
在实际应用中，PHP与 XML的交互操作应用非常广泛。SimpleXML组件是 PHP5新增加的一个简
单的 XML操作组件，与传统的 XML组件相比，SimpleXML组件的使用非常简单。本节将对使用
SimpleXML组件操作 XML的方法做一下详细介绍。
2.1 创建一个 SimpleXML对象
SimpleXML对象是用来临时存储 XML数据的临时变量，对 XML进行的操作都是通过操作 SimpleXML对象来完成的。SimpleXML组件提供了两种创建 SimpleXML对象的方法。第一种方法是使用 simplexml_load_string函数读取一个字符串型变量中的 XML数据来完成创建的，其语法格式如下所示。
simplexml_load_string(string data)
这里的 data变量用于存储 XML数据。以下代码使用 simplexml_load_string函数创建了一个 SimpleXML对象

  1. <hr><?php
  2. $data = <<<XML //定义 XML数据
  3. <?xml version=’1.0′?>
  4.       <departs>
  5.           <depart>
  6.           <name>production support</name>
  7.          <employees>
  8.             <employee>
  9.               <serial_no>100001</serial_no>
  10.                     <name>Simon</name>
  11.                     <age>24</age>
  12.                     <birthday>1982-11-06</birthday>
  13.                     <salary>5000.00</salary>
  14.                    <bonus>1000.00</bonus>
  15.            </employee>
  16.           <employee>
  17.                      <serial_no>100002</serial_no>
  18.                      <name>Elaine</name>
  19.                      <age>24</age>
  20.                      <birthday>1982-01-01</birthday>
  21.                     <salary>6000.00</salary>
  22.                    <bonus>2000.00</bonus>
  23.            </employee>
  24. </employees>
  25. </depart>
  26. <depart>
  27.           <name>testing center</name>
  28.             <employees>
  29.               <employee>
  30.                     <serial_no>110001</serial_no>
  31.                     <name>Helen</name>
  32.                     <age>23</age>
  33.                     <birthday>1983-07-21</birthday>
  34.                     <salary>5000.00</salary>
  35.                    <bonus>1000.00</bonus>
  36.             </employee>
  37.         </employees>
  38. </depart>
  39. </departs>
  40. XML;
  41. $xml = simplexml_load_string($data); //创建 SimpleXML对象
  42. print_r($xml);         //输出 XML
  43. ?><hr>

在上面的例子中，$data变量存储了一段 XML数据。 simplexml_load_string函数将变量$data转化成 SimpleXML对象。通过 print_r函数的输出可以看出该对象的结构，运行结果如下所示。

  1. SimpleXMLElement Object
  2. (
  3.     [depart] => Array
  4. (
  5.             [0] => SimpleXMLElement Object
  6. (
  7.                     [name] => production support
  8.                     [employees] => SimpleXMLElement Object
  9. (                            [employee] => Array (
  10.                                     [0] => SimpleXMLElement Object
  11. (                                           [serial_no] => 100001                                            
  12.             [name] => Simon                                          
  13.             [age] => 24                                            
  14.             [birthday] => 1982-11-06                                            
  15.             [salary] => 5000.00                                            
  16.             [bonus] => 1000.00
  17. )
  18.                                     [1] => SimpleXMLElement Object
  19. (                                           [serial_no] => 100002                                            
  20.             [name] => Elaine                                          
  21.             [age] => 24                                            
  22.             [birthday] => 1982-01-01                                            
  23.             [salary] => 6000.00                                            
  24.             [bonus] => 2000.00
  25.                         )
  26.               )
  27.        )
  28. )
  29.             [1] => SimpleXMLElement Object
  30. (
  31.                 [name] => testing center
  32.                 [employees] => SimpleXMLElement Object
  33. (
  34.                 [employee] => SimpleXMLElement Object
  35. (
  36.                 [serial_no] => 110001
  37.                 [name] => Helen
  38.                 [age] => 23
  39.                 [birthday] => 1983-07-21
  40.                 [salary] => 5000.00
  41.                 [bonus] => 1000.00
  42.                      )
  43.                )
  44.           )
  45.      )
  46. )

从输出结果可以看出，SimpleXML对象的结构与 XML数据的格式完全相同。
第二种方法是使用 simplexml_load_flie函数读取一个 XML文件来完成创建的，其语法格式如下所示。
simplexml_load_file(string filename)
这里的 filename变量是用于存储 XML数据文件的文件名及其所在路径。以下代码使用 simplexml_load_file函数来创建了一个 SimpleXML对象。

  1. <?php
  2. $xml = simplexml_load_file(’example.xml’); //创建 SimpleXML对象
  3. print_r($xml);         //输出 XML
  4. ?>

其中，example.xml存储的数据与上面的$data完全相同，运行结果也与上面完全相同。
上面两种方法实现了同样的功能，其区别就在于 XML的数据源不同。如果 XML的数据源在 PHP脚本文件中，则需要使用 simplexml_load_string来进行创建。如果 XML的数据源在一个单独的 XML文件中，则需要使用 simplexml_load_file来进行创建。
2.2 读取 SimpleXML对象中的 XML数据
前面介绍了使用 print_r函数来读取 SimpleXML对象中的数据，其返回结果与数组的结构类似。显然，这种显示方式在实际应用中是不可取的。在这里将介绍其他的几种读取 SimpleXML对象中 XML数据的方法。
1．var_dump函数显示对象详细信息
var_dump函数可以用于显示 SimpleXML对象的详细信息，与 print_r函数相比，var_dump函数显示的信息更为完整，其语法如下所示。
void var_dump(object1, object2 … )
以下代码使用 var_dump函数输出了上面例子中对象的详细信息。

  1. <?php $xml = simplexml_load_file(’example.xml’); //创建 SimpleXML对象 var_dump($xml); //输出 XML
  2. ?>

运行结果如下所示。

  1. object(SimpleXMLElement)#1 (1) {   [“depart”]=>  array(2) {
  2.     [0]=>
  3.     object(SimpleXMLElement)#2 (2) {
  4.       [“name”]=>
  5.       string(18) “production support”
  6.       [“employees”]=>
  7.       object(SimpleXMLElement)#4 (1) {
  8.         [“employee”]=>
  9.         array(2) {
  10.           [0]=>
  11.           object(SimpleXMLElement)#5 (6) {
  12.             [“serial_no”]=>
  13.             string(6) “100001″
  14.             [“name”]=>
  15.             string(5) “Simon”
  16.             [“age”]=>
  17.             string(2) “24″
  18.             [“birthday”]=>
  19.             string(10) “1982-11-06″
  20.             [“salary”]=>
  21.             string(7) “5000.00″
  22.             [“bonus”]=>
  23.             string(7) “1000.00″
  24. }
  25.           [1]=>
  26.           object(SimpleXMLElement)#6 (6) {
  27.             [“serial_no”]=>
  28.             string(6) “100002″
  29.             [“name”]=>
  30.             string(6) “Elaine”
  31.             [“age”]=>
  32.             string(2) “24″
  33.             [“birthday”]=>
  34.             string(10) “1982-01-01″
  35.             [“salary”]=>
  36.             string(7) “6000.00″
  37.             [“bonus”]=>
  38.             string(7) “2000.00″
  39. }
  40. }
  41. }
  42. }
  43.     [1]=>
  44.     object(SimpleXMLElement)#3 (2) {
  45.       [“name”]=>
  46.       string(14) “testing center”
  47.       [“employees”]=>
  48.       object(SimpleXMLElement)#7 (1) {
  49.         [“employee”]=>
  50.         object(SimpleXMLElement)#8 (6) {
  51.           [“serial_no”]=>
  52.           string(6) “110001″
  53.           [“name”]=>
  54.           string(5) “Helen”
  55.           [“age”]=>
  56.           string(2) “23″
  57.           [“birthday”]=>
  58.           string(10) “1983-07-21″
  59.           [“salary”]=>
  60.           string(7) “5000.00″
  61.           [“bonus”]=>
  62.           string(7) “1000.00″
  63. }
  64. }
  65. }
  66. }
  67. }

与前面 print_r输出的结果相比较，var_dump函数的输出结果的结构更为严谨，并且将对象中的每一个属性的数据类型均作出分析。在实际应用中，var_dump函数往往用于程序调试时的对象检测。
2．读取 XML数据中的标签
与操作数组类型的变量类似，读取 XML也可以通过类似的方法来完成。例如，如果需要读取上面 XML数据中每一个“ depart”标签下的“name”属性，可以通过使用 foreach函数来完成，如以下代码
所示。

  1. <?php $xml = simplexml_load_file(’example.xml’); foreach($xml->depart as $a)
  2. {
  3. echo “$a->name <BR>”;
  4. }
  5. ?>

运行结果如下所示。
production support
testing center
//读取 XML文件 //循环读取 XML数据中的每一个 depart标签
//输出其中的 name属性
也可以使用方括号“ []”来直接读取 XML数据中指定的标签。以下代码输出了上面 XML数据中的第一个“depart”标签的“name”属性。

  1. <?php
  2. $xml = simplexml_load_file(’example.xml’); //读取 XML文件
  3. echo $xml->depart->name[0]; //输出节点
  4. ?>

运行结果如下所示。
production support
对于一个标签下的所有子标签，SimpleXML组件提供了 children方法进行读取。例如，对于上面的 XML数据中的“ depart”标签，其下包括两个子标签：“ name”和“employees”。以下代码实现了对第一个“depart”标签下的子标签的读取。

  1. <?php
  2. $xml = simplexml_load_file(’example.xml’);
  3. foreach ($xml->depart->children() as $depart) //循环读取 depart标签下的子标签
  4. {
  5. var_dump($depart); //输出标签的 XML数据
  6. }
  7. ?>

运行结果如下所示。

  1. object(SimpleXMLElement)#3 (1) {
  2. [0]=>
  3.   string(18) “production support”
  4. }
  5. object(SimpleXMLElement)#5 (1) {
  6.   [“employee”]=>
  7.   array(2) {
  8.     [0]=>
  9.     object(SimpleXMLElement)#3 (6) {
  10.       [“serial_no”]=>
  11.       string(6) “100001″
  12.       [“name”]=>
  13.       string(5) “Simon”
  14.       [“age”]=>
  15.       string(2) “24″
  16.       [“birthday”]=>
  17.       string(10) “1982-11-06″
  18.       [“salary”]=>
  19.       string(7) “5000.00″
  20.       [“bonus”]=>
  21.       string(7) “1000.00″
  22. }
  23.     [1]=>
  24.     object(SimpleXMLElement)#6 (6) {
  25.       [“serial_no”]=>
  26.       string(6) “100002″
  27.       [“name”]=>
  28.       string(6) “Elaine”
  29.       [“age”]=>
  30.       string(2) “24″
  31.       [“birthday”]=>
  32.       string(10) “1982-01-01″
  33.       [“salary”]=>
  34.       string(7) “6000.00″
  35.       [“bonus”]=>
  36.       string(7) “2000.00″
  37. }
  38. }
  39. }

可以看出，使用 children方法后，所有的子标签均被当作一个新的 XML文件进行处理。
3．基于 XML数据路径的查询
SimpleXML组件提供了一种基于 XML数据路径的查询方法。 XML数据路径即从 XML的根到某一个标签所经过的全部标签。这种路径使用斜线“ /”隔开标签名。例如，对于上面的 XML数据，要查询所有的标签“name”中的值，从根开始要经过 departs、depart、employees和 employee标签，则其路径
为“/departs/depart/employees/employee/name”。 SimpleXML组件使用 xpath方法来解析路径，其语法格式如下所示。
xpath(string path)
其中的 path为路径。该方法返回了一个包含有所有要查询标签值的数组。以下代码查询了上面 XML数据中的所有 name标签。

  1. <?php
  2. $xml = simplexml_load_file(’example.xml’); //读取 XML文件
  3. $result = $xml->xpath(’/departs/depart/employees/employee/name’);  //定义节点
  4. var_dump($result); //输出节点
  5. ?>

运行结果如下所示。

  1. array(3) {
  2. [0]=> object(SimpleXMLElement)#2 (1) {
  3.     [0]=> string(5) “Simon”
  4. }
  5. [1]=>  object(SimpleXMLElement)#3 (1) {
  6.     [0]=> string(6) “Elaine”
  7. }
  8. [2]=>  object(SimpleXMLElement)#4 (1) {
  9.     [0]=> string(5) “Helen”
  10. }
  11. }

可以看出，所有的 name标签均被查询出来。
2.3 XML数据的修改
对于 XML数据的修改与读取 XML数据中的标签方法类似。即通过直接修改 SimpleXML对象中的标签的值来实现。以下代码实现了对上面 XML数据中第一个“ depart”标签的“ name”子标签的修改。

  1. <?php
  2. $xml = simplexml_load_file(’example.xml’); //读取 XML
  3. $xml->depart->name[0] = “Human Resource”; //修改节点
  4. ?>

修改后，并不会对 XML文件有任何影响。但是，在程序中，对于 SimpleXML对象的读取将使用修改过的值。

2.4 标准化 XML数据
SimpleXML还提供了一种标准化 XML数据的方法 asXML。asXML方法可以有效的将 SimpleXML对象中的内容按照 XML 1.0标准进行重新编排并以字符串的数据类型返回。以下代码实现了对上面 XML数据的标准化。

  1. <?php
  2. $xml = simplexml_load_file(’example.xml’); //读取 XML数据
  3. echo $xml->asXML(); //标准化 XML数据
  4. ?>

2.5 XML数据的存储
将 SimpleXML对象中的 XML数据存储到一个 XML文件的方法非常简单，即将 asXML方法的返回结果输出到一个文件中即可。以下代码首先将 XML文件中的 depart name进行了修改，然后将修改过的 XML数据输出到另一个 XML文件。

  1. <?php
  2. $xml = simplexml_load_file(’example.xml’); //读取 XML数据
  3. $newxml = $xml->asXML(); //标准化 XML数据
  4. $fp = fopen(”newxml.xml”, “w”); //打开要写入 XML数据的文件
  5. fwrite($fp, $newxml); //写入 XML数据
  6. fclose($fp);         //关闭文件
  7. ?>

代码运行后，可以看到在 newxml.xml文件中的 XML数据如下所示。

  1. <?xml version=”1.0″?>
  2. <departs>
  3. <depart>
  4. <name>Human Resource</name>
  5. <employees>
  6.   <employee>
  7.    <serial_no>100001</serial_no>
  8.    <name>Simon</name>
  9.    <age>24</age>
  10.    <birthday>1982-11-06</birthday>
  11.    <salary>5000.00</salary>
  12.    <bonus>1000.00</bonus>
  13.   </employee>
  14.   <employee>
  15.    <serial_no>100002</serial_no>
  16.    <name>Elaine</name>
  17.    <age>24</age>
  18.    <birthday>1982-01-01</birthday>
  19.    <salary>6000.00</salary>
  20.    <bonus>2000.00</bonus>
  21.   </employee>
  22. </employees>
  23. </depart>
  24. <depart>
  25. <name>testing center</name>
  26. <employees>
  27.   <employee>
  28.    <serial_no>110001</serial_no>
  29.    <name>Helen</name>
  30.    <age>23</age>
  31.    <birthday>1983-07-21</birthday>
  32.    <salary>5000.00</salary>
  33.    <bonus>1000.00</bonus>
  34.   </employee>
  35. </employees>
  36. </depart>
  37. </departs>

可以看出，对于 XML文件的修改已经保存到输出文件中了。
3 XML文档的动态创建
在实际应用中，时而会需要动态生成 XML文档的操作。前面介绍的 SimpleXML组件并不提供创建 XML文档的方法。因此，如果需要动态创建 XML文档，往往使用 DOM组件进行创建。 DOM是文档对象模型 Document Object Model的缩写， DOM组件提供了对 XML文档的树型解析模式。以下代码使用 DOM组件创建了一个 XML文档。

  1. <?php
  2. //创建一个新的 DOM文档
  3. $dom = new DomDocument();
  4. //在根节点创建 departs标签
  5. $departs = $dom->createElement(’departs’);
  6. $dom->appendChild($departs);
  7. //在 departs标签下创建 depart子标签
  8. $depart = $dom->createElement(’depart’);
  9. $departs->appendChild($depart);
  10. //在 depart标签下创建 employees子标签
  11. $employees = $dom->createElement(’employees’);
  12. $depart->appendChild($employees);
  13. //在 employees标签下创建 employee子标签
  14. $employee = $dom->createElement(’employee’);
  15. $employees->appendChild($employee);
  16. //在 employee标签下创建 serial_no子标签
  17. $serial_no = $dom->createElement(’serial_no’);
  18. $employee->appendChild($serial_no);
  19. //为 serial_no标签添加值节点 100001
  20. $serial_no_value = $dom->createTextNode(’100001′);
  21. $serial_no->appendChild($serial_no_value);
  22. //输出 XML数据
  23. echo $dom->saveXML();
  24. ?>
  25. 输出结果如下所示。
  26. <?xml version=”1.0″?>
  27. <departs>
  28. <depart>
  29. <employees>
  30. <employee>
  31. <serial_no>100001</serial_no>
  32. </employee>
  33. </employees>
  34. </depart>
  35. </departs>

DOM组件除了可以用来动态创建 XML文档外，还可以用来读取 XML文件。以下代码实现了对前
面 XML文件的读取。

  1. <?php
  2. $dom = new DomDocument();  //创建 DOM对象
  3. $dom->load(’example.xml’);  //读取 XML文件
  4. $root = $dom->documentElement;  //获取 XML数据的根
  5. read_child($root);  //调用 read_child函数读取根对象
  6.   function read_child($node)
  7. {
  8.         $children = $node->childNodes;  //获得$node的所有子节点
  9.         foreach($children as $e)  //循环读取每一个子节点
  10. {
  11.               if($e->nodeType == XML_TEXT_NODE)   //如果子节点为文本型则输出
  12. {
  13.                     echo $e->nodeValue.”<BR>”;
  14. }
  15.               else if($e->nodeType == XML_ELEMENT_NODE)   //如果子节点为节点对象，则调用函数处理
  16. {
  17. read_child($e);
  18. }
  19. }
  20. }
  21. ?>

运行结果如下所示。

引用
production support
100001
Simon
24
1982-11-06
5000.00
1000.00
100002
Elaine
24
1982-01-01
6000.00
2000.00
testing center
110001
Helen
23
1983-07-21
5000.00
1000.00

上面的例子使用了递归的方式对 XML数据进行了处理，实现了输出 XML数据中的所有文本型标签的功能。
4 XML应用实例——留言本
前面介绍了 XML的基本操作，本节将以设计一个 XML留言本为例来详细说明在实际应用中如何实现 PHP与 XML数据的交互操作。
4.1 XML文件结构设计
XML文件用于存储 XML数据，也就是留言本中的留言。这里，对于每条留言，在 XML数据中主要包括三项内容：留言标题、留言者姓名、留言内容。因此，将 XML文件的格式设计如下。

  1. <?xml version=”1.0″?>
  2. <threads>
  3. <thread>
  4. <title>这里是留言的标题</title>
  5. <author>这里是留言者</author>
  6. <content>这里是留言内容</content>
  7. </thread>
  8. </threads>

4.2 提交页面的编写
提交留言页面由两个页面组成。一个是让访问者用来书写留言的表单的 HTML文件，一个是用来处理访问者输入的 PHP脚本。表单的 HTML代码如下所示。

  1. <html>
  2. <head>
  3. <title>发表新的留言</title>
  4. <meta http-equiv=”Content-Type” content=”text/html; charset=gb2312″>
  5. </head>
  6. <body>
  7. <H1><p align=”center”>发表新的留言</p></H1>
  8. <form name=”form1″ method=”post” action=”Post.php”>
  9. <table width=”500″ border=”0″ align=”center” cellpadding=”0″ cellspacing=”0″>
  10.     <tr>
  11.       <td>标题</td>
  12.       <td><input name=”title” type=”text” id=”title” size=”50″></td>
  13.     </tr>
  14.     <tr>
  15.       <td>作者</td>
  16.       <td><input name=”author” type=”text” id=”author” size=”20″></td>
  17.     </tr>
  18.     <tr>
  19.       <td>内容</td>
  20.       <td><textarea name=”content” cols=”50″ rows=”10″ id=”content”></textarea></td>
  21.     </tr>
  22.   </table>
  23.   <p align=”center”>
  24.     <input type=”submit” value=”Submit”>
  25.     <input type=”reset” value=”Reset”>
  26. </p>
  27. </form>
  28. </body>
  29. </html>

对于用来处理用户输入的 PHP脚本，其基本逻辑是首先创建一个 DOM对象，然后读取 XML文件中的 XML数据，接下来在 XML对象上创建新的节点并将用户的输入储存起来，最后将 XML数据输出到原来的 XML文件中。具体实现代码如下所示。

  1. <?php
  2. $guestbook = new DomDocument(); //创建一个新的 DOM对象
  3. $guestbook->load(’DB/guestbook.xml’); //读取 XML数据
  4. $threads = $guestbook->documentElement; //获得 XML结构的根
  5. //创建一个新 thread节点
  6. $thread = $guestbook->createElement(’thread’);
  7. $threads->appendChild($thread);
  8. //在新的 thread节点上创建 title标签
  9. $title = $guestbook->createElement(’title’);
  10. $title->appendChild($guestbook->createTextNode($_POST[‘title’]));
  11. $thread->appendChild($title);
  12. //在新的 thread节点上创建 author标签
  13. $author = $guestbook->createElement(’author’);
  14. $author->appendChild($guestbook->createTextNode($_POST[‘author’]));
  15. $thread->appendChild($author);
  16. //在新的 thread节点上创建 content标签
  17. $content = $guestbook->createElement(’content’);
  18. $content->appendChild($guestbook->createTextNode($_POST[‘content’]));
  19. $thread->appendChild($content);
  20. //将 XML数据写入文件
  21. $fp = fopen(”DB/guestbook.xml”, “w”);
  22. if(fwrite($fp, $guestbook->saveXML()))
  23. echo “留言提交成功”;
  24. else
  25. echo “留言提交失败”;
  26. fclose($fp);
  27. ?>

在浏览器中运行上述 HTML文件并填写适当的留言内容，如图 2所示。

图 2 发表新留言界面
单击【Submit】按钮后，XML文件中的内容如下所示。

  1. <?xml version=”1.0″?>
  2. <threads>
  3. <thread>
  4. <title>Welcome</title>
  5. <author>Simon</author>
  6. <content>Welcome to XML guestbook!!</content>
  7. </thread>
  8. </threads>

可以看到 XML文件中已经将留言存储起来了。
4.3 显示页面的编写
显示页面可以使用前面介绍的 SimpleXML组件很容易的实现，具体实现代码如下所示。

  1. <?php
  2. //打开用于存储留言的 XML文件
  3. $guestbook = simplexml_load_file(’DB/guestbook.xml’);
  4. foreach($guestbook->thread as $th) //循环读取 XML数据中的每一个 thread标签
  5. {
  6.   echo “<B>标题：</B>”.$th->title.”<BR>”;
  7.   echo “<B>作者：</B>”.$th->author.”<BR>”;
  8.   echo “<B>内容：</B><PRE>”.$th->content.”</PRE>”;
  9.   echo “<HR>”;
  10. }
  11. ?>

在浏览器中查看运行结果如图 3所示。

您可能还喜欢...