引言

客户需求, 需要从docx文档读取内容并且做简单格式化, 难点就在于如何读取docx格式并且转换为php可以识别的字符串形式, 惯例先贴代码.

代码

  1. /**
  2.  * Class Docx2Text
  3.  *
  4.  * Docx => String
  5.  */
  6. class Docx2Text
  7. {
  8.     const SEPARATOR_TAB = "\t";
  10.     /**
  11.      * object zipArchive
  12.      *
  13.      * @var string
  14.      * @access private
  15.      */
  16.     private $docx;
  18.     /**
  19.      * object domDocument from document.xml
  20.      *
  21.      * @var string
  22.      * @access private
  23.      */
  24.     private $domDocument;
  26.     /**
  27.      * xml from document.xml
  28.      *
  29.      * @var string
  30.      * @access private
  31.      */
  32.     private $_document;
  34.     /**
  35.      * xml from numbering.xml
  36.      *
  37.      * @var string
  38.      * @access private
  39.      */
  40.     private $_numbering;
  42.     /**
  43.      *  xml from footnote
  44.      *
  45.      * @var string
  46.      * @access private
  47.      */
  48.     private $_footnote;
  50.     /**
  51.      *  xml from endnote
  52.      *
  53.      * @var string
  54.      * @access private
  55.      */
  56.     private $_endnote;
  58.     /**
  59.      * array of all the endnotes of the document
  60.      *
  61.      * @var string
  62.      * @access private
  63.      */
  64.     private $endnotes;
  66.     /**
  67.      * array of all the footnotes of the document
  68.      *
  69.      * @var string
  70.      * @access private
  71.      */
  72.     private $footnotes;
  74.     /**
  75.      * array of all the relations of the document
  76.      *
  77.      * @var string
  78.      * @access private
  79.      */
  80.     private $relations;
  82.     /**
  83.      * array of characters to insert like a list
  84.      *
  85.      * @var string
  86.      * @access private
  87.      */
  88.     private $numberingList;
  90.     /**
  91.      * the text content that will be exported
  92.      *
  93.      * @var string
  94.      * @access private
  95.      */
  96.     private $textOuput;
  99.     /**
  100.      * boolean variable to know if a chart will be transformed to text
  101.      *
  102.      * @var string
  103.      * @access private
  104.      */
  105.     private $chart2text;
  107.     /**
  108.      * boolean variable to know if a table will be transformed to text
  109.      *
  110.      * @var string
  111.      * @access private
  112.      */
  113.     private $table2text;
  115.     /**
  116.      * boolean variable to know if a list will be transformed to text
  117.      *
  118.      * @var string
  119.      * @access private
  120.      */
  121.     private $list2text;
  123.     /**
  124.      * boolean variable to know if a paragraph will be transformed to text
  125.      *
  126.      * @var string
  127.      * @access private
  128.      */
  129.     private $paragraph2text;
  131.     /**
  132.      * boolean variable to know if footnotes will be extracteded
  133.      *
  134.      * @var string
  135.      * @access private
  136.      */
  137.     private $footnote2text;
  139.     /**
  140.      * boolean variable to know if endnotes will be extracted
  141.      *
  142.      * @var string
  143.      * @access private
  144.      */
  145.     private $endnote2text;
  147.     /**
  148.      * Construct
  149.      *
  150.      * @param $boolTransforms array of boolean values of which elements should be transformed or not
  151.      * @access public
  152.      */
  154.     public function __construct($boolTransforms = array())
  155.     {
  156.         //table,list, paragraph, footnote, endnote, chart
  157.         if (isset($boolTransforms['table'])) {
  158.             $this->table2text = $boolTransforms['table'];
  159.         } else {
  160.             $this->table2text = true;
  161.         }
  163.         if (isset($boolTransforms['list'])) {
  164.             $this->list2text = $boolTransforms['list'];
  165.         } else {
  166.             $this->list2text = true;
  167.         }
  169.         if (isset($boolTransforms['paragraph'])) {
  170.             $this->paragraph2text = $boolTransforms['paragraph'];
  171.         } else {
  172.             $this->paragraph2text = true;
  173.         }
  175.         if (isset($boolTransforms['footnote'])) {
  176.             $this->footnote2text = $boolTransforms['footnote'];
  177.         } else {
  178.             $this->footnote2text = true;
  179.         }
  181.         if (isset($boolTransforms['endnote'])) {
  182.             $this->endnote2text = $boolTransforms['endnote'];
  183.         } else {
  184.             $this->endnote2text = true;
  185.         }
  187.         if (isset($boolTransforms['chart'])) {
  188.             $this->chart2text = $boolTransforms['chart'];
  189.         } else {
  190.             $this->chart2text = true;
  191.         }
  193.         $this->textOuput = '';
  194.         $this->docx = null;
  195.         $this->_numbering = '';
  196.         $this->numberingList = array();
  197.         $this->endnotes = array();
  198.         $this->footnotes = array();
  199.         $this->relations = array();
  201.     }
  203.     /**
  204.      *
  205.      * Extract the content of a word document and create a text file if the name is given
  206.      *
  207.      * @access public
  208.      * @param string $filename of the word document.
  209.      *
  210.      * @return string
  211.      */
  213.     public function extract($filename = '')
  214.     {
  215.         if (empty($this->_document)) {
  216.             //xml content from document.xml is not got
  217.             exit('There is no content');
  218.         }
  220.         $this->domDocument = new DomDocument();
  221.         $this->domDocument->loadXML($this->_document);
  222.         //get the body node to check the content from all his children
  223.         $bodyNode = $this->domDocument->getElementsByTagNameNS('http://schemas.openxmlformats.org/wordprocessingml/2006/main', 'body');
  224.         //We get the body node. it is known that there is only one body tag
  225.         $bodyNode = $bodyNode->item(0);
  226.         foreach ($bodyNode->childNodes as $child) {
  227.             //the children can be a table, a paragraph or a section. We only implement the 2 first option said.
  228.             if ($this->table2text && $child->tagName == 'w:tbl') {
  229.                 //this node is a table and  the content is split with tabs if the variable table2text from the class is true
  230.                 $this->textOuput .= $this->table($child) . $this->separator();
  231.             } else {
  232.                 //this node is a paragraph
  233.                 $this->textOuput .= $this->printWP($child) . ($this->paragraph2text ? $this->separator() : '');
  234.             }
  235.         }
  236.         if (!empty($filename)) {
  237.             $this->writeFile($filename, $this->textOuput);
  238.         } else {
  239.             return $this->textOuput;
  240.         }
  241.     }
  243.     /**
  244.      * Setter
  245.      *
  246.      * @access public
  247.      * @param $filename
  248.      */
  249.     public function setDocx($filename)
  250.     {
  251.         $this->docx = new ZipArchive();
  252.         $ret = $this->docx->open($filename);
  253.         if ($ret === true) {
  254.             $this->_document = $this->docx->getFromName('word/document.xml');
  255.         } else {
  256.             exit('failed');
  257.         }
  258.     }
  260.     /**
  261.      * extract the content to an array from endnote.xml
  262.      *
  263.      * @access private
  264.      */
  265.     private function loadEndNote()
  266.     {
  267.         if (empty($this->endnotes)) {
  268.             if (empty($this->_endnote)) {
  269.                 $this->_endnote = $this->docx->getFromName('word/endnotes.xml');
  270.             }
  271.             if (!empty($this->_endnote)) {
  272.                 $domDocument = new DomDocument();
  273.                 $domDocument->loadXML($this->_endnote);
  274.                 $endnotes = $domDocument->getElementsByTagNameNS('http://schemas.openxmlformats.org/wordprocessingml/2006/main', 'endnote');
  275.                 foreach ($endnotes as $endnote) {
  276.                     $xml = $endnote->ownerDocument->saveXML($endnote);
  277.                     $this->endnotes[$endnote->getAttribute('w:id')] = trim(strip_tags($xml));
  278.                 }
  279.             }
  280.         }
  281.     }
  283.     /**
  284.      * Extract the content to an array from footnote.xml
  285.      *
  286.      * @access private
  287.      */
  288.     private function loadFootNote()
  289.     {
  290.         if (empty($this->footnotes)) {
  291.             if (empty($this->_footnote)) {
  292.                 $this->_footnote = $this->docx->getFromName('word/footnotes.xml');
  293.             }
  294.             if (!empty($this->_footnote)) {
  295.                 $domDocument = new DomDocument();
  296.                 $domDocument->loadXML($this->_footnote);
  297.                 $footnotes = $domDocument->getElementsByTagNameNS('http://schemas.openxmlformats.org/wordprocessingml/2006/main', 'footnote');
  298.                 foreach ($footnotes as $footnote) {
  299.                     $xml = $footnote->ownerDocument->saveXML($footnote);
  300.                     $this->footnotes[$footnote->getAttribute('w:id')] = trim(strip_tags($xml));
  301.                 }
  302.             }
  303.         }
  304.     }
  306.     /**
  307.      * Extract the styles of the list to an array
  308.      *
  309.      * @access private
  310.      */
  311.     private function listNumbering()
  312.     {
  313.         $ids = array();
  314.         $nums = array();
  315.         //get the xml code from the zip archive
  316.         $this->_numbering = $this->docx->getFromName('word/numbering.xml');
  317.         if (!empty($this->_numbering)) {
  318.             //we use the domdocument to iterate the children of the numbering tag
  319.             $domDocument = new DomDocument();
  320.             $domDocument->loadXML($this->_numbering);
  321.             $numberings = $domDocument->getElementsByTagNameNS('http://schemas.openxmlformats.org/wordprocessingml/2006/main', 'numbering');
  322.             //there is only one numbering tag in the numbering.xml
  323.             $numberings = $numberings->item(0);
  324.             foreach ($numberings->childNodes as $child) {
  325.                 $flag = true;//boolean variable to know if the node is the first style of the list
  326.                 foreach ($child->childNodes as $son) {
  327.                     if ($child->tagName == 'w:abstractNum' && $son->tagName == 'w:lvl') {
  328.                         foreach ($son->childNodes as $daughter) {
  329.                             if ($daughter->tagName == 'w:numFmt' && $flag) {
  330.                                 $nums[$child->getAttribute('w:abstractNumId')] = $daughter->getAttribute('w:val');//set the key with internal index for the listand the value it is the type of bullet
  331.                                 $flag = false;
  332.                             }
  333.                         }
  334.                     } elseif ($child->tagName == 'w:num' && $son->tagName == 'w:abstractNumId') {
  335.                         $ids[$son->getAttribute('w:val')] = $child->getAttribute('w:numId');//$ids is the index of the list
  336.                     }
  337.                 }
  338.             }
  339.             //once we know what kind of list there is in the documents, is prepared the bullet that the library will use
  340.             foreach ($ids as $ind => $id) {
  341.                 if ($nums[$ind] == 'decimal') {
  342.                     //if the type is decimal it means that the bullet will be numbers
  343.                     $this->numberingList[$id][0] = range(1, 10);
  344.                     $this->numberingList[$id][1] = range(1, 10);
  345.                     $this->numberingList[$id][2] = range(1, 10);
  346.                     $this->numberingList[$id][3] = range(1, 10);
  347.                 } else {
  348.                     //otherwise is *, and other characters
  349.                     $this->numberingList[$id][0] = array('*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*');
  350.                     $this->numberingList[$id][1] = array(chr(175), chr(175), chr(175), chr(175), chr(175), chr(175), chr(175), chr(175), chr(175), chr(175), chr(175), chr(175));
  351.                     $this->numberingList[$id][2] = array(chr(237), chr(237), chr(237), chr(237), chr(237), chr(237), chr(237), chr(237), chr(237), chr(237), chr(237), chr(237));
  352.                     $this->numberingList[$id][3] = array(chr(248), chr(248), chr(248), chr(248), chr(248), chr(248), chr(248), chr(248), chr(248), chr(248), chr(248));
  353.                 }
  354.             }
  355.         }
  356.     }
  358.     /**
  359.      * Extract the content of a w:p tag
  360.      *
  361.      * @access private
  362.      * @param $node object
  363.      * @return string
  364.      */
  365.     private function printWP($node)
  366.     {
  367.         $ilvl = $numId = -1;
  368.         if ($this->list2text) {//transform the list in ooxml to formatted list with tabs and bullets
  369.             if (empty($this->numberingList)) {//check if numbering.xml is extracted from the zip archive
  370.                 $this->listNumbering();
  371.             }
  372.             //use the xpath to get expecific children from a node
  373.             $xpath = new DOMXPath($this->domDocument);
  374.             $query = 'w:pPr/w:numPr';
  375.             $xmlLists = $xpath->query($query, $node);
  376.             $xmlLists = $xmlLists->item(0);
  378.             //if ($xmlLists->tagName == 'w:numPr') {
  379.             //    if ($xmlLists->hasChildNodes()) {
  380.             //        foreach ($xmlLists->childNodes as $child) {
  381.             //            if ($child->tagName == 'w:ilvl') {
  382.             //                $ilvl = $child->getAttribute('w:val');
  383.             //            }elseif ($child->tagName == 'w:numId') {
  384.             //                $numId = $child->getAttribute('w:val');
  385.             //            }
  386.             //        }
  387.             //    }
  388.             //}
  389.             //if (($ilvl != -1) && ($numId != -1)) {
  390.             //    //if is founded the style index of the list in the document and the kind of list
  391.             //    $ret = '';
  392.             //    for($i=-1; $i < $ilvl; $i++) {
  393.             //        if(self::DEBUG) {
  394.             //            $ret .= self::SEPARATOR_TAB_DEBUG;
  395.             //        }
  396.             //        else {
  397.             //            $ret .= self::SEPARATOR_TAB;
  398.             //        }
  399.             //    }
  400.             //    $ret .= array_shift($this->numberingList[$numId][$ilvl]) . ' ' . $this->toText($node);  //print the bullet
  401.             //} else {
  402.             $ret = $this->toText($node);
  403.             //}
  404.         } else {
  405.             //if dont want to formatted lists, we strip from html tags
  406.             $ret = $this->toText($node);
  407.         }
  410.         //get the data from the charts
  411.         if ($this->chart2text) {
  412.             $query = 'w:r/w:drawing/wp:inline';
  413.             $xmlChart = $xpath->query($query, $node);
  414.             //get the relation id from the document, to get the name of the xml chart file from the relations to extract the xml code.
  415.             foreach ($xmlChart as $chart) {
  416.                 foreach ($chart->childNodes as $child) {
  417.                     foreach ($child->childNodes as $child2) {
  418.                         foreach ($child2->childNodes as $child3) {
  419.                             $rid = $child3->getAttribute('r:id');
  420.                         }
  421.                     }
  422.                 }
  423.             }
  424.             //if (!empty($rid)) {
  425.             //    if (empty($this->relations)) {
  426.             //        $this->loadRelations();
  427.             //    }
  428.             //    //get the name of the chart xml file from the relations docuemnt
  429.             //    $dataChart = new getDataFromXmlChart($this->docx->getFromName('word/' . $this->relations[$rid]['file']));
  430.             //    if (in_array($this->chart2text, array(2, 'table'))) {
  431.             //        $ret .= $this->printChartDataTable($dataChart);//formatted print of the chart data
  432.             //    } else {
  433.             //        $ret .= $this->printChartDataArray($dataChart);//formatted print of the chart data
  434.             //    }
  435.             //}
  436.         }
  437.         //extract the expecific endnote to insert with the text content
  438.         if ($this->endnote2text) {
  439.             if (empty($this->endnotes)) {
  440.                 $this->loadEndNote();
  441.             }
  442.             $query = 'w:r/w:endnoteReference';
  443.             $xmlEndNote = $xpath->query($query, $node);
  444.             foreach ($xmlEndNote as $note) {
  445.                 $ret .= '[' . $this->endnotes[$note->getAttribute('w:id')] . '] ';
  446.             }
  447.         }
  448.         //extract the expecific footnote to insert with the text content
  449.         if ($this->footnote2text) {
  450.             if (empty($this->footnotes)) {
  451.                 $this->loadFootNote();
  452.             }
  453.             $query = 'w:r/w:footnoteReference';
  454.             $xmlFootNote = $xpath->query($query, $node);
  455.             foreach ($xmlFootNote as $note) {
  456.                 $ret .= '[' . $this->footnotes[$note->getAttribute('w:id')] . '] ';
  457.             }
  458.         }
  459.         if ((($ilvl != -1) && ($numId != -1)) || (1)) {
  460.             $ret .= $this->separator();
  461.         }
  463.         return $ret;
  464.     }
  466.     /**
  467.      * return a text end of line
  468.      *
  469.      * @access private
  470.      */
  471.     private function separator()
  472.     {
  473.         return "\r\n";
  474.     }
  476.     /**
  477.      *
  478.      * Extract the content of a table node from the document.xml and return a text content
  479.      *
  480.      * @access private
  481.      * @param $node object
  482.      *
  483.      * @return string
  484.      */
  485.     private function table($node)
  486.     {
  487.         $output = '';
  488.         if ($node->hasChildNodes()) {
  489.             foreach ($node->childNodes as $child) {
  490.                 //start a new line of the table
  491.                 if ($child->tagName == 'w:tr') {
  492.                     foreach ($child->childNodes as $cell) {
  493.                         //start a new cell
  494.                         if ($cell->tagName == 'w:tc') {
  495.                             if ($cell->hasChildNodes()) {
  496.                                 //
  497.                                 foreach ($cell->childNodes as $p) {
  498.                                     $output .= $this->printWP($p);
  499.                                 }
  500.                                 $output .= self::SEPARATOR_TAB;
  501.                             }
  502.                         }
  503.                     }
  504.                 }
  505.                 $output .= $this->separator();
  506.             }
  507.         }
  508.         return $output;
  509.     }
  512.     /**
  513.      *
  514.      * Extract the content of a node from the document.xml and return only the text content and. stripping the html tags
  515.      *
  516.      * @access private
  517.      * @param $node object
  518.      *
  519.      * @return string
  520.      */
  521.     private function toText($node)
  522.     {
  523.         $xml = $node->ownerDocument->saveXML($node);
  524.         return trim(strip_tags($xml));
  525.     }
  526. }
  528. // 实例化
  529. $text = new Docx2Text();
  530. // 加载docx文件
  531. $text->setDocx('./1.docx');
  532. // 将内容存入$docx变量中
  533. $docx = $text->extract();
  534. // 调试输出
  535. var_dump($docx);

小结

代码中处理docx的类来自这里
其实docx就是xml的一种扩展类型的文档.

================================================================================
【文章来源】https://blog.csdn.net/hldh214/article/details/51549866