nauka - własny system szablonów Opcje

[mgebala8]

Korzystając z chwili wolnego czasu robię sobię odwozorwanie różnych funkcjonalności frameworków - obiektowo i w php, np. routing, połączenia bazodanowe singleton vs proxy itp.
Wszystko głównie w celach edukacyjnych ale kto wie może z tego wyjdzie mi kiedyś jakaś namiastka frameworka lub microframework.

Wśród wielu różnych modułów stanąłem jednak przed problemem odwzorowania systemu szablonów i tu pojawia się problem jak coś takiego napisać ? ogólnie wpadłem na pomysł że za pomocą wyrażeń regularnych zamienie sobię kod np.

[PHP] pobierz, plaintext 
 
treść strony
 
@include('menu')
 
@for($i=0;$i<10;$i++)
bla bla bla
@endforeach
 
tutaj moja zmienna przekazana do widoku: {$zmienna}
 
[PHP] pobierz, plaintext 

domyślnie maszynka ma mi zamienić coś takiego na poniższy ciąg i przypisać to do zmiennej $widok;

[PHP] pobierz, plaintext 
<?php include('menu') ?>
 
<?php for($i=0;$i<10;$i++):?>
bla bla bla
<?php endforeach; ?>
 
tutaj moja zmienna przekazana do widoku: <?php echo $zmienna ?>
 
[PHP] pobierz, plaintext 

i tu pojawia się mały problem a w zasadzie 2, czy na podobnej zasadzie działają silniki twig czy blade ? oraz jak mogę sparsować i wyświetlić treść strony trzymaną w zmiennej $widok ?

Ten post edytował mgebala8 11.07.2014, 09:13:27

[Pyton_000]

by_ikar systemy Template powstały po to aby kod szablonu był czytelniejszy.

Ja wiem że PHP to najlepszy system szablonów bo nie trzeba parsować ale czasami wolę mieć

[HTML] pobierz, plaintext 
<p>{{zmienna}}</p>
[HTML] pobierz, plaintext 

niż

[HTML] pobierz, plaintext 
<p><?=$zmienna?></p>
[HTML] pobierz, plaintext 

albo jeszcze gorzej (masakra)

[HTML] pobierz, plaintext 
<p><?php echo $zmienna; ?></p>
[HTML] pobierz, plaintext 

[by_ikar]

by_ikar systemy Template powstały po to aby kod szablonu był czytelniejszy.

Ja wiem że PHP to najlepszy system szablonów bo nie trzeba parsować ale czasami wolę mieć

[HTML] pobierz, plaintext 
<p>{{zmienna}}</p>
[HTML] pobierz, plaintext 

niż

[HTML] pobierz, plaintext 
<p><?=$zmienna?></p>
[HTML] pobierz, plaintext 

albo jeszcze gorzej (masakra)

[HTML] pobierz, plaintext 
<p><?php echo $zmienna; ?></p>
[HTML] pobierz, plaintext 

Też tak kiedyś myślałem, kiedy tworzyłem swój ambitny system szablonów, wydawało mi się że jest mi to potrzebne, że tak jest czytelniej! A prawda jest taka, że jest to zbędna logika do czegoś co mamy out of box. Rozumiem system szablonów w stylu tego co jest w symfony2 - tzn możliwość dziedziczenia, sloty etc. To akurat jest fajny pomysł. Ale same templatki powinny być IMO zawsze jako html + php. Też kiedyś stworzyłem swojego "potworka":

[PHP] pobierz, plaintext 
<?php
 
class TemplateParser
{
    protected $options;
    protected $parameters;
 
    public function __construct(array $options = array())
    {
        $this->options = array_merge_recursive(array(
            'pattern'               => array('/(?<!@)@(?!@)/is', '/@@/is'),
            'replecament'           => array('echo ', '@'),
            'pattern_variable'      => '/(\$([\w\.\$]+))/is',
            'replecament_variable'  => array($this, 'replaceVariable'),
            'replecament_ignore'    => array($this, 'preReplace'),
            'pattern_ignore'        => '#(?:{ignore}.*?{/ignore}|({.*?}))#is',
            'extension'             => '.tpl',
            'template_dir'          => './',
        ), $options);
    }
 
    /**
    * @param    array $parameters
    * @return   void
    */
    public function add(array $parameters)
    {
        foreach($parameters as $key => $val)
        {
            if(!isset($this->parameters[$key]))
        	{
                $this->parameters[$key] = $val;
            }
        }
    }
 
    /**
    * @param   string $name
    * @param   string $value
    * @return  void
    */
    public function set($name, $value)
    {
        $this->parameters[$name] = $value;
    }
 
    /**
    * @return  array
    */
    public function getAll()
    {
        return $this->parameters;
    }
 
    /**
    * @param   string $name
    * @return  string
    */
    public function exists($name)
    {
        $file = $name.$this->options['extension'];
 
        foreach((array)$this->options['template_dir'] as $dir)
        {
            if(is_readable($dir.$file))
            {
                return $dir.$file;
            }
        }
 
        return false;
    }
 
    /**
    * @param   string $template
    * @param   array $parameters
    * @param   string $mode:
    * string    - eval
    * file      - include
    * @return  string|false
    */
    protected function evaluate($template, array $parameters = array(), $mode = 'string')
    {
        if('file' === $mode)
        {
            extract($parameters);
            ob_start();
            require $template;
 
            return ob_get_clean();
        } else
        {
            extract($parameters);
            ob_start();
            eval('; ?>'.$template.'<?php ;');
 
            return ob_get_clean();
        }
 
        return false;
    }
 
    /**
    * @param   mixed $name
    * @return  string
    * @throws InvalidArgumentException
    */
    protected function load($name)
    {
        $file = $this->exists($name);
 
        if(false === $file)
        {
            throw new InvalidArgumentException(sprintf('Template "%s" does not exist.', $name));
        }
 
        $fileTemplate = file_get_contents($file);
 
        return $this->parse($fileTemplate);
    }
 
	/**
	* @param    string $name
	* @return   string
	* @throws   InvalidArgumentException
	* @throws   RuntimeException
	*/
	public function render($name)
	{
		$storage = $this->load($name);
 
		if (false === $content = $this->evaluate($storage, $this->parameters))
		{
			throw new RuntimeException(sprintf('Template "%s" can not be rendered.', $this->exists($name)));
		}
 
		return $content;
	}
 
    protected function parse($fileTemplate)
    {
        return preg_replace_callback($this->options['pattern_ignore'], $this->options['replecament_ignore'], $fileTemplate);
    }
 
    protected function replaceVariable($varName)
    {
        return preg_replace(array('/\.(\$[\w-]+)/', '/\.([\w-]+)/is'), array('[$1]', '[\'$1\']'), $varName[1]);
    }
 
    protected function preReplace($replace)
    {
        if(!empty($replace[1]))
        {
            $compile = preg_replace($this->options['pattern'], $this->options['replecament'], $replace[1]);
            $compile = preg_replace_callback($this->options['pattern_variable'], $this->options['replecament_variable'], $compile);
            $compile = preg_replace('/{(.*?)}/is', '<?php $1 ?>', $compile);
 
            return $compile;
        } else
        {
            return preg_replace('/{(\/)?ignore}/is', '', $replace[0]);
        }
    }
}
[PHP] pobierz, plaintext 

Gdzie uważałem że { something } jest czytelniejsze niż <?php something ?>. No ale wyrosłem z tego i jestem zdecydowanie za tym żeby nie używać szablonów.