一个PHP Template

1. <?php
4. class Template {
5.   var $classname = "Template";
7.   /* if set, echo assignments */
8.   var $debug     = false;
10.   /* $file[handle] = "filename"; */
11.   var $file  = array();
13.   /* relative filenames are relative to this pathname */
14.   var $root   = "";
16.   /* $varkeys[key] = "key"; $varvals[key] = "value"; */
17.   var $varkeys = array();
18.   var $varvals = array();
20.   /* "remove"  => remove undefined variables
21.    * "comment" => replace undefined variables with comments
22.    * "keep"    => keep undefined variables
23.    */
24.   var $unknowns = "remove";
25.   
26.   /* "yes" => halt, "report" => report error, continue, "no" => ignore error quietly */
27.   var $halt_on_error  = "yes";
28.   
29.   /* last error message is retained here */
30.   var $last_error     = "";
33.   /***************************************************************************/
34.   /* public: Constructor.
35.    * root:     template directory.
36.    * unknowns: how to handle unknown variables.
37.    */
38.   function Template($root = ".", $unknowns = "remove") {
39.     $this->set_root($root);
40.     $this->set_unknowns($unknowns);
41.   }
43.   /* public: setroot(pathname $root)
44.    * root:   new template directory.
45.    */  
46.   function set_root($root) {
47.     if (!is_dir($root)) {
48.       $this->halt("set_root: $root is not a directory.");
49.       return false;
50.     }
51.     
52.     $this->root = $root;
53.     return true;
54.   }
56.   /* public: set_unknowns(enum $unknowns)
57.    * unknowns: "remove", "comment", "keep"
58.    *
59.    */
60.   function set_unknowns($unknowns = "keep") {
61.     $this->unknowns = $unknowns;
62.   }
64.   /* public: set_file(array $filelist)
65.    * filelist: array of handle, filename pairs.
66.    *
67.    * public: set_file(string $handle, string $filename)
68.    * handle: handle for a filename,
69.    * filename: name of template file
70.    */
71.   function set_file($handle, $filename = "") {
72.     if (!is_array($handle)) {
73.       if ($filename == "") {
74.         $this->halt("set_file: For handle $handle filename is empty.");
75.         return false;
76.       }
77.       $this->file[$handle] = $this->filename($filename);
78.     } else {
79.       reset($handle);
80.       while(list($h, $f) = each($handle)) {
81.         $this->file[$h] = $this->filename($f);
82.       }
83.     }
84.   }
86.   /* public: set_block(string $parent, string $handle, string $name = "")
87.    * extract the template $handle from $parent, 
88.    * place variable {$name} instead.
89.    */
90.   function set_block($parent, $handle, $name = "") {
91.     if (!$this->loadfile($parent)) {
92.       $this->halt("subst: unable to load $parent.");
93.       return false;
94.     }
95.     if ($name == "")
96.       $name = $handle;
98.     $str = $this->get_var($parent);
99.     $reg = "/<!--/s+BEGIN $handle/s+-->(.*)/n/s*<!--/s+END $handle/s+-->/sm";
100.     preg_match_all($reg, $str, $m);
101.     $str = preg_replace($reg, "{" . "$name}", $str);
102.     $this->set_var($handle, $m[1][0]);
103.     $this->set_var($parent, $str);
104.   }
105.   
106.   /* public: set_var(array $values)
107.    * values: array of variable name, value pairs.
108.    *
109.    * public: set_var(string $varname, string $value)
110.    * varname: name of a variable that is to be defined
111.    * value:   value of that variable
112.    */
113.   function set_var($varname, $value = "") {
114.     if (!is_array($varname)) {
115.       if (!emptyempty($varname))
116.         if ($this->debug) print "scalar: set *$varname* to *$value*<br>/n";
117.         $this->varkeys[$varname] = "/".$this->varname($varname)."/";
118.         $this->varvals[$varname] = $value;
119.     } else {
120.       reset($varname);
121.       while(list($k, $v) = each($varname)) {
122.         if (!emptyempty($k))
123.           if ($this->debug) print "array: set *$k* to *$v*<br>/n";
124.           $this->varkeys[$k] = "/".$this->varname($k)."/";
125.           $this->varvals[$k] = $v;
126.       }
127.     }
128.   }
130.   /* public: subst(string $handle)
131.    * handle: handle of template where variables are to be substituted.
132.    */
133.   function subst($handle) {
134.     if (!$this->loadfile($handle)) {
135.       $this->halt("subst: unable to load $handle.");
136.       return false;
137.     }
139.     $str = $this->get_var($handle);
140.     $str = @preg_replace($this->varkeys, $this->varvals, $str);
141.     return $str;
142.   }
143.   
144.   /* public: psubst(string $handle)
145.    * handle: handle of template where variables are to be substituted.
146.    */
147.   function psubst($handle) {
148.     print $this->subst($handle);
149.     
150.     return false;
151.   }
153.   /* public: parse(string $target, string $handle, boolean append)
154.    * public: parse(string $target, array  $handle, boolean append)
155.    * target: handle of variable to generate
156.    * handle: handle of template to substitute
157.    * append: append to target handle
158.    */
159.   function parse($target, $handle, $append = false) {
160.     if (!is_array($handle)) {
161.       $str = $this->subst($handle);
162.       if ($append) {
163.         $this->set_var($target, $this->get_var($target) . $str);
164.       } else {
165.         $this->set_var($target, $str);
166.       }
167.     } else {
168.       reset($handle);
169.       while(list($i, $h) = each($handle)) {
170.         $str = $this->subst($h);
171.         $this->set_var($target, $str);
172.       }
173.     }
174.     
175.     return $str;
176.   }
177.   
178.   function pparse($target, $handle, $append = false) {
179.     print $this->parse($target, $handle, $append);
180.     return false;
181.   }
182.   
183.   /* public: get_vars()
184.    */
185.   function get_vars() {
186.     reset($this->varkeys);
187.     while(list($k, $v) = each($this->varkeys)) {
188.       $result[$k] = $this->varvals[$k];
189.     }
190.     
191.     return $result;
192.   }
193.   
194.   /* public: get_var(string varname)
195.    * varname: name of variable.
196.    *
197.    * public: get_var(array varname)
198.    * varname: array of variable names
199.    */
200.   function get_var($varname) {
201.     if (!is_array($varname)) {
202.       return $this->varvals[$varname];
203.     } else {
204.       reset($varname);
205.       while(list($k, $v) = each($varname)) {
206.         $result[$k] = $this->varvals[$k];
207.       }
208.       
209.       return $result;
210.     }
211.   }
212.   
213.   /* public: get_undefined($handle)
214.    * handle: handle of a template.
215.    */
216.   function get_undefined($handle) {
217.     if (!$this->loadfile($handle)) {
218.       $this->halt("get_undefined: unable to load $handle.");
219.       return false;
220.     }
221.     
222.     preg_match_all("//{([^}]+)/}/", $this->get_var($handle), $m);
223.     $m = $m[1];
224.     if (!is_array($m))
225.       return false;
227.     reset($m);
228.     while(list($k, $v) = each($m)) {
229.       if (!isset($this->varkeys[$v]))
230.         $result[$v] = $v;
231.     }
232.     
233.     if (count($result))
234.       return $result;
235.     else
236.       return false;
237.   }
239.   /* public: finish(string $str)
240.    * str: string to finish.
241.    */
242.   function finish($str) {
243.     switch ($this->unknowns) {
244.       case "keep":
245.       break;
246.       
247.       case "remove":
248.         $str = preg_replace('/{[^ /t/r/n}]+}/', "", $str);
249.       break;
251.       case "comment":
252.         $str = preg_replace('/{([^ /t/r/n}]+)}/', "<!-- Template $handle: Variable //1 undefined -->", $str);
253.       break;
254.     }
255.     
256.     return $str;
257.   }
259.   /* public: p(string $varname)
260.    * varname: name of variable to print.
261.    */
262.   function p($varname) {
263.     print $this->finish($this->get_var($varname));
264.   }
266.   function get($varname) {
267.     return $this->finish($this->get_var($varname));
268.   }
269.     
270.   /***************************************************************************/
271.   /* private: filename($filename)
272.    * filename: name to be completed.
273.    */
274.   function filename($filename) {
275.     if (substr($filename, 0, 1) != "/") {
276.       $filename = $this->root."/".$filename;
277.     }
278.     
279.     if (!file_exists($filename))
280.       $this->halt("filename: file $filename does not exist.");
282.     return $filename;
283.   }
284.   
285.   /* private: varname($varname)
286.    * varname: name of a replacement variable to be protected.
287.    */
288.   function varname($varname) {
289.     return preg_quote("{".$varname."}");
290.   }
292.   /* private: loadfile(string $handle)
293.    * handle:  load file defined by handle, if it is not loaded yet.
294.    */
295.   function loadfile($handle) {
296.     if (isset($this->varkeys[$handle]) and !emptyempty($this->varvals[$handle]))
297.       return true;
299.     if (!isset($this->file[$handle])) {
300.       $this->halt("loadfile: $handle is not a valid handle.");
301.       return false;
302.     }
303.     $filename = $this->file[$handle];
305.     $str = implode("", @file($filename));
306.     if (emptyempty($str)) {
307.       $this->halt("loadfile: While loading $handle, $filename does not exist or is empty.");
308.       return false;
309.     }
311.     $this->set_var($handle, $str);
312.     
313.     return true;
314.   }
316.   /***************************************************************************/
317.   /* public: halt(string $msg)
318.    * msg:    error message to show.
319.    */
320.   function halt($msg) {
321.     $this->last_error = $msg;
322.     
323.     if ($this->halt_on_error != "no")
324.       $this->haltmsg($msg);
325.     
326.     if ($this->halt_on_error == "yes")
327.       die("<b>Halted.</b>");
328.     
329.     return false;
330.   }
331.   
332.   /* public, override: haltmsg($msg)
333.    * msg: error message to show.
334.    */
335.   function haltmsg($msg) {
336.     printf("<b>Template Error:</b> %s<br>/n", $msg);
337.   }
338. }
340.   function savetofile ($dir,$varname){
341.    $data=$this->finish($this->get_var($varname));
342.    $fp=fopen($dir,"w+");
343.    fwrite($fp,$data);
344.   }
346.    function renew(){
347.     $this->varkeys=array();
348.     $this->varvals=array();
349.     $this->file=array();
350.     }
352. ?>

 测试页面：

1. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
2. <html>
3. <head>
4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312">
5. <title>无标题文档</title>
6. </head>
8. <body>
9. <?php
10.  require("template.inc");
12.  faction staticinfo ($id){
13.   mysql_connection(localhost, root,);
14.   mysql_select_db (dbname);
15.   global $table,$template,$itpl
16.   $rs=mysql_query("select id from $table where id=$id");
17.   $array=mysql_fetch_query("$rs");
18.   $target=$array[“target”];
19.   $title=$array[“title”];
20.   $itpl=new template;
21.   
22.   //分析模板
23.   $tpl->set_file(“main”,$template);
24.   //把模板中的{title}变量换成$title
25.   $itpl->set_var(“title”,$title”);
26.   //分析整个模板
27.   $itpl->set_var(“mains”,”main”);
28.   //把mains写入文件
29.   $tpl->savetofile($target,"mains");
30.   //置空
31.   $tpl->renew();
35. ?>
36. </body>
37. </html>