Como estruturar o sistema de modelos usando PHP simples?

15

Eu estava lendo esta pergunta no stackoverflow:

/programming/104516/calling-php-functions-within-heredoc-strings

e a resposta aceita diz para criar modelos PHP simples como este:

template.php:

<html>
    <head>
        <title><?=$title?> </title>
    </head>
    <body>
        <? = getContent ()?>
    </body>
</html>

index.php:

<? php

$ title = 'Título da demonstração';

função getContent () {
    retornar '<p> Olá mundo! </p>';
}

include ('template.php');

?>

Para mim, o exposto acima não está bem estruturado no sentido de que o template.php depende de variáveis definidas em outros scripts. E você está usando um include () para executar o código quando o faz include('template.php')(ao contrário de include () para incluir uma classe ou uma função que não é executada imediatamente).

Eu sinto que uma abordagem melhor é envolver seu modelo dentro de uma função:

template.php:

<? php

modelo de função ($ title, $ content) {
    ob_start (); ?>

<html>
    <head>
        <title><?=$title?> </title>
    </head>
    <body>
        <? = $ content?>
    </body>
</html>

    <? php return ob_get_clean ();
}

?>

index.php:

<? php

require_once ('template.php');

print template ('Demo Title', '<p> Olá, mundo! </p>');

?>

A segunda abordagem é melhor? Existe uma maneira ainda melhor de fazer isso?

php templates Ryan
fonte

12

Eu não faria a segunda abordagem, pois os parâmetros não são nomeados.

Um artigo bem escrito sobre a descrição de como um sistema de gabaritos deve funcionar vem do Parr; é frequentemente citado por pessoas que escrevem sistemas de gabaritos e / ou estruturas de web-mvc.

Pessoalmente, o que eu normalmente prefiro é implementar uma classe ArrayObject com uma matriz de propriedades, e o modelo se referiria $this->propertyName, o que de fato seria o objeto do modelo $this->property['name']. Isso também pode ser alcançado simplesmente usando __sete __get, portanto:

class Template {
  private $_scriptPath=TEMPLATE_PATH;//comes from config.php
  public $properties;
  public function setScriptPath($scriptPath){
    $this->_scriptPath=$scriptPath;
  }
  public function __construct(){
      $this->properties = array();
  }
  public function render($filename){

   ob_start();
   if(file_exists($this->_scriptPath.$filename)){
     include($this->_scriptPath.$filename);
    } else throw new TemplateNotFoundException();
    return ob_get_clean();
  }
  public function __set($k, $v){
      $this->properties[$k] = $v;
  }
  public function __get($k){
      return $this->properties[$k];
  }
}

e um modelo ficaria assim:

<html>
      <head>
         <title><?=$this->title?></title>
      </head>
      <body>Hey <?=$this->name?></body>
</html>

e invocá-lo ficaria assim:

$view = new Template();
$view->title="Hello World app";
$view->properties['name'] = "Jude";
echo $view->render('hello.inc');

Tanto quanto me lembro, é assim que os antigos mecanismos do Symfony 1.x e do modelo Zend_View se parecem, e para mim tudo bem.

Aadaam
fonte

Tinybutstrong faz algo semelhante, bem

Izkata

como você lida com looping sobre algumas pontuações dizer? você usa um modelo "sub" separado?

Ryan

Gostaria de saber se existe alguma maneira de se livrar de usar $ this no modelo, por exemplo, apenas $ title ou $ name.

Ryan

1

@ Ryan Você pode usar extract($this->properties);para extrair as propriedades em variáveis, imediatamente antes da instrução include.

precisa saber é o seguinte

1

Um modelo sempre dependerá de variáveis externas e, com o PHP sendo uma linguagem dinâmica, não há como impor em tempo de compilação que eles estarão lá. Portanto, a primeira abordagem provavelmente está correta; ainda existem alguns problemas:

O exemplo não cuida da codificação HTML da saída, o que significa que você tem possíveis vulnerabilidades XSS.
Se uma dessas variáveis não estiver definida, o código emitirá um aviso; você não verá se o aviso faz sentido ou não (talvez a variável seja opcional).

Uma abordagem muito direta é escrever uma função, de preferência com um nome muito curto, que cuide de ambas; chamando isso _()parece ser uma convenção comum. Uma versão simples pode ser assim:

function _($raw) {
    if (isset($raw)) {
        return htmlspecialchars($raw);
    }
}

E então no seu modelo, você faria:

<title><?= _($title) ?></title>

Mais coisas a fazer com a _()função:

Dê a ele um segundo argumento para permitir a substituição da htmlspecialcharschamada, nos casos em que você deseja passar HTML para ela em vez de cadeias brutas.
Adicione verificação de tipo para que matrizes e objetos não produzam Arraye Object, em vez disso, algo significativo (ou string vazia).
Adicione suporte à internacionalização (outro argumento).
Quando estiver no modo de depuração, imprima o nome da variável com alguma formatação especial, se não estiver definida. Dessa forma, você pode ver rapidamente se há algo errado com o modelo.

tdammers
fonte

1

O primeiro template.phpé mais fácil de carregar como está no dreamweaver / bluegriffon / o que for e editado por um web designer não experiente do lado do servidor, o segundo ... bem, ainda meio que poderia, mas é muito mais provável que ele se quebre durante o processo de edição .

Eu iria com o primeiro para manter o aspecto de HTML com benefícios , da maneira que os designers de terceiros geralmente preferem.

ZJR
fonte

em que sentido? você quer dizer que não pode ser alterado usando arrastar e soltar? textualmente, o segundo é o mesmo que o primeiro, mas com algumas linhas de PHP em volta. Supondo que sempre tenha essa estrutura, não é mais difícil para eles editarem manualmente.

Ryan

1

Um bom modelo faz sentido para os desenvolvedores, um ótimo modelo faz sentido para os designers.

precisa saber é

1

Como o Codeigniter é minha estrutura favorita, proponho uma solução isenta de Codeigniter:

class Template {
    protected $path, $data;

    public function __construct($path, $data = array()) {
        $this->path = $path;
        $this->data = $data;
    }

    public function render() {
        if(file_exists($this->path)){
            //Extracts vars to current view scope
            extract($this->data);

            //Starts output buffering
            ob_start();

            //Includes contents
            include $this->path;
            $buffer = ob_get_contents();
            @ob_end_clean();

            //Returns output buffer
            return $buffer;
        } else {
            //Throws exception
        }
    }       
}

Seu modelo seria semelhante a:

<html>
    <head>
        <title><?=$title?></title>
    </head>
    <body>
        <?=$content?>
    </body>
</html>

E você a renderizaria instanciando a classe, passando dados em uma matriz como um parâmetro construtor e chamando o método 'render':

$data = array('title' => 'My title', 'content' => 'My content');
$tmpl = new Template('template.php', $data);
echo $tmpl->render();

Dessa forma, você não está executando diretamente o código incluído e também mantendo seu modelo legível, para que os designers fiquem felizes.

Lortabac
fonte

-3

Php não é uma linguagem de programação. Portanto, escrever com forte digitação não será possível se o seu idioma não tiver um sistema de tipos real. Mas você pode ajudar seu IDE, como PHP-Storm, a fazer o truque que deseja ...

Sua definição de visualização:

interface mySimpleView { 
  public function getTitle(); 
}

Seu arquivo de modelo:

<?php
/**
* @var $this mySimpleView  <== Your IDE will try to use this type.
*/
?>

<h1><?= $this->getTitle() ?></h1>
<p><?= $this->getContent() ?></p> <!-- <= IDE will warn you !  -->

Roger Keulen
fonte

Eu gosto desta resposta (embora claramente "Php não seja uma linguagem de programação" sempre seja controverso.

Ronnie

Como estruturar o sistema de modelos usando PHP simples?

Respostas: