Срач из темы про шаблонизаторы(отделено akrinel).

Правда, getcc лишний. Но я его ввел только потому, что подумал, что после extrcat в методе getc и выполнения объекты в _vars так и останутся ссылками. Еще вместо второго вызова vars_dump в методе flush можно исползовать ранее созданую переменную $vardump.
В конце метода flsuh echo $this; обязательно, чтобы метод flush во всем (кроме кэширования) был аналогичен __toString.

 

А чем принципиально отличается от хэширования переменных? На хэширование уходит больше времени, чем на сравнение длиных строк.

 

Хм, нет, с объектом ничего не происходит, можно делать echo $this -> _content;

 

Сериализация объекта в 2 раза быстрее создания и сериализации дампа переменных. Зато десериализация этого объекта в 3 раза медленнее десериализации массива, + каждый раз время потребуется на выполнение (если выполнять перед сериализацией, то объекты потом при сравнении не совпадут, в исходном _content = null), а в массиве он уже готовый. Десериализация нужна будет чаще сериализации, поэтому метод вовсе не лишний.

PHP:

1.  
2. <?php
3. class ts
4. {
5.     private $_vars = array();
6.     function __set($k, $v)
7.     {
8.         $this -> _vars[$k] = $v;
9.     }
10.     function vars_dump()
11.     {
12.         $vdump = array();
13.         foreach ($this -> _vars as $k => $v)
14.         {
15.             if (is_object($v))
16.             {
17.                 $vdump[$k] = $v -> vars_dump();
18.             }
19.             else
20.             {
21.                 $vdump[$k] = $v;
22.             }
23.         }
24.         return $vdump;
25.     }
26. }
27. $obj = new ts;
28. $obj -> text = 'Preved!';
29. for ($i = 0; $i < 100; $i++)
30. {
31.     $otemp = new ts;
32.     $otemp -> n = $i;
33.     $obj -> $i = $otemp;
34. }
35. echo 'Object:<br>';
36. $start = microtime(1);
37. for ($i = 0; $i < 10000; $i++)
38. {
39.     $ser = serialize($obj);
40. }
41. echo microtime(1) - $start,'<br>';
42. $start = microtime(1);
43. for ($i = 0; $i < 10000; $i++)
44. {
45.     $user = unserialize($ser);
46. }
47. echo microtime(1) - $start,'<br>';
48. echo 'Array:<br>';
49. $start = microtime(1);
50. for ($i = 0; $i < 10000; $i++)
51. {
52.     $ser = serialize($obj -> vars_dump());
53. }
54. echo microtime(1) - $start,'<br>';
55. $start = microtime(1);
56. for ($i = 0; $i < 10000; $i++)
57. {
58.     $user = unserialize($ser);
59. }
60. echo microtime(1) - $start,'<br>';

Код (Text):

1. Object:
2. 2.29684710503
3. 3.93136286736
4. Array:
5. 5.78200387955
6. 1.15568709373

 

Просто принципиально хочешь последнее слово за собой оставить

 

http://www.php.ru/forum/viewtopic.php?t=22210#186954
сам писал

 

topas
http://www.php.ru/forum/viewtopic.php?t ... =30#211313
Там главное - скорость, тут почему-то "при чем тут скорость?". На первый взгляд кажется, что vars_dump торомзит работу. Или имелось ввиду другое? Но я же не телепат ))
И к тому же, где это я "гоню"? Для меня "гнать" означает "врать", вот я привел тестовый скрипт, че там таймер врет? Или имелось ввиду другое? Короче, непонимание слушателя - это фэйл оратора ((

 

Лучше расскажи, какого быть пустословом

каких?

почему?

 

похоже ты просто не смог разобраться в коде и запутался o_0

 

Я уже писал, что можно выкинуть getcc и повторно использовать $vardump

PHP:

1.  
2. <?php
3. class view
4. {  
5.     const CACHE_SWITCH  = 1;
6.     const CACHE_DIR     = './cache';
7.     private $cfname     = null;
8.     private $_vars      = array();
9.     private $_path      = null;
10.     protected $_content = null;
11.    
12.     public function __construct($_path)
13.     {
14.         $this -> _path = $_path;
15.         $this -> cfname = self::CACHE_DIR.'/'.md5($this -> _path);
16.     }
17.    
18.     public function cName($name)
19.     {
20.         $this -> cfname = self::CACHE_DIR.'/'.md5($name);
21.     }
22.    
23.     public function __set($var, $val)
24.     {
25.         $this -> _vars[$var] = $val;
26.     }
27.    
28.     public function __get($var)
29.     {
30.         if (isset($this -> $var))
31.         {
32.             return $this -> $var;
33.         }
34.         return $this -> _vars[$var];
35.     }
36.    
37.     public function flush()
38.     {
39.         if (self::CACHE_SWITCH == 1)
40.         {
41.             $cfname = $this -> cfname.'.cache';
42.             $cached = null;
43.             $vardump = $this -> vars_dump();
44.             if (file_exists($cfname))
45.             {
46.                 $cached = unserialize(file_get_contents($cfname));
47.             }
48.             if ($vardump == $cached[0])
49.             {
50.                 $this -> _content = $cached[1];
51.             }
52.             else
53.             {
54.                 $cache = array($vardump, $this -> getc());
55.                 file_put_contents($cfname, serialize(&$cache));
56.             }
57.         }
58.         echo $this -> getc();
59.     }
60.    
61.     private function getc()
62.     {
63.         if ($this -> _content == null)
64.         {
65.             extract($this -> _vars);
66.             ob_start();
67.             include($this -> _path);
68.             $this -> _content = ob_get_clean();
69.         }
70.         return $this -> _content;
71.     }
72.    
73.     private function vars_dump()
74.     {
75.         $vdump = array(0 => $this -> _path, 1 => array());
76.         foreach ($this -> _vars as $name => $val)
77.         {
78.             if (is_object($val))
79.             {
80.                 $vdump[1][$name] = $val -> vars_dump();
81.             }
82.             else
83.             {
84.                 $vdump[1][$name] = $val;
85.             }
86.         }
87.         return $vdump;
88.     }
89.    
90.     public function __toString()
91.     {
92.         return $this -> getc();
93.     }
94. }

 

Да, я вижу, что __toString состоит только из вызова одного метода, но если ты еще к этому придерешься то это будет ппц.

 

Simpliest
ты начал в таком тоне, что я решил что ты стебешься

PHP:

1. <?php
2. class view
3. {  
4.     const CACHE_SWITCH  = 1;
5.     const CACHE_DIR     = './cache';
6.     private $cacheFilename  = null;
7.     private $_vars      = array();
8.     private $_path      = null;
9.     protected $_content = null;
10.    
11.     public function __construct($_path)
12.     {
13.         $this -> _path = $_path;
14.         $this -> cacheFilename = self::CACHE_DIR.'/'.md5($this -> _path);
15.     }
16.    
17.     public function setCacheFilename($name)
18.     {
19.         $this -> cacheFilename = self::CACHE_DIR.'/'.md5($name);
20.     }
21.    
22.     public function __set($var, $val)
23.     {
24.         $this -> _vars[$var] = $val;
25.     }
26.    
27.     public function __get($var)
28.     {
29.         if (isset($this -> $var))
30.         {
31.             return $this -> $var;
32.         }
33.         return $this -> _vars[$var];
34.     }
35.    
36.     public function flush()
37.     {
38.         if (self::CACHE_SWITCH == 1)
39.         {
40.             $cacheFilename = $this -> cacheFilename.'.cache';
41.             $cachedContent = null;
42.             $templateVars = $this -> getTemplateVars();
43.             if (file_exists($cacheFilename))
44.             {
45.                 $cachedContent = unserialize(file_get_contents($cacheFilename));
46.             }
47.             if ($templateVars == $cachedContent[0])
48.             {
49.                 $this -> _content = $cachedContent[1];
50.             }
51.             else
52.             {
53.                 $cachedContent = array($templateVars, $this -> getContent());
54.                 file_put_contents($cacheFilename, serialize(&$cachedContent));
55.             }
56.         }
57.         echo $this -> getContent();
58.     }
59.    
60.     private function getContent()
61.     {
62.         if ($this -> _content == null)
63.         {
64.             extract($this -> _vars);
65.             ob_start();
66.             include($this -> _path);
67.             $this -> _content = ob_get_clean();
68.         }
69.         return $this -> _content;
70.     }
71.    
72.     private function getTemplateVars()
73.     {
74.         $templateVars = array(0 => $this -> _path, 1 => array());
75.         foreach ($this -> _vars as $name => $val)
76.         {
77.             if (is_object($val))
78.             {
79.                 $templateVars[1][$name] = $val -> getTemplateVars();
80.             }
81.             else
82.             {
83.                 $templateVars[1][$name] = $val;
84.             }
85.         }
86.         return $templateVars;
87.     }
88.    
89.     public function __toString()
90.     {
91.         return $this -> getContent();
92.     }
93. }

 

PHP:

1.  <?php
2.  $tpl = new view('my.phtml');
3.  
4.  $tpl->a = 'aaaa';
5.  
6.  var_dump($tpl);
7.  echo '<hr>';
8.  $tpl->flush();
9.  
10.  echo '<hr>';
11.  echo '<hr>';
12.  $tpl->a = 'bbbb';
13.  
14.  var_dump($tpl);
15.  echo '<hr>';
16.  $tpl->flush();

все правильно, надо просто так

PHP:

1.  
2.  <?php
3.  $tpl = new view('./srv/my.phtml');
4.  
5.  $tpl->a = 'aaaa';
6.  
7.  var_dump($tpl);
8.  echo '<hr>';
9.  echo $tpl;
10.  
11.  echo '<hr>';
12.  echo '<hr>';
13.  
14.  $tpl = new view('./srv/my.phtml');
15.  $tpl->a = 'bbbb';
16.  
17.  var_dump($tpl);
18.  echo '<hr>';
19.  echo $tpl;

echo $tpl; - чтобы шаблон не кэшировался, пересоздавать объект - быстродействие не затормозит, все равно include будет каждый раз что намного медленнее, + поощряет разбивать большие шаблоны на мелкие =)

 

опоздал я немного с правкой мессаги

знаешь, я уважаю вежливость. Невежлевые замечания я обычно игнорирую.

интуитивно понятно чего - шаблона, какое еще содержимое может быть в этом объекте?

шаблона конечно, чего же еще?

при вызове flsuh кэшируется и извлекается из кэша, при __toString - просто выводится. Потому что в первом случае с объектом работаешь как с объектом, а во втором - как с строкой, и неочевидно, что при этом могут произойти какие-то еще действия кроме вывода.