Design Patterns

[ro.fonseca 1]

hummm....

Acha mesmo?!

 

Isso sim, eu acho o cúmulo!

 

De fato, e lamento dizer, mas é um ponto de vista totalmente equivocado. Se for necessário, posto um exemplo para mostrar o tanto que você está errado.

 

 

Ok, eu não duvido nada que tu me prove o contrário, mas é que eu já tive experiencia de código que eu peguei com o html gerado pelo php, e te digo que foi um desastre total, um verdadeiro "spaguetti", enfim, acho que tive entao apenas uma má experiencia que me levou a ter um conceito nada bom de html gerado pelo php. Embora eu ainda continue achando que o html deve ser feito na mão, na maioria das vezes, pode ser que em algumas ocasiões eu possa estar incorreto. E se quiser mostrar algum código ou quiser me provar o contrário, seria mt bom!

 

edit: A não ser que estejas se referindo a algum tipo de html dinâmico, gerado a partir de alguma situação em especial.

 

abraço

[Bruno Augusto 417]

A menos que provem o contrário, NÃO EXISTE uma forma de não misturar PHP com HTML e MANTER a performance.

 

Você misturar HTML no que seria o seu Controller ao invés de misturar na View, é a mesma coisa que jogar molho de tomate em cima do sorvete.

 

Quando você separa sua aplicação, no mínimo nas três camadas do MVC, você ainda vai ter aquele espaguete com PHP e HTML se alternando. Mas isso vai ficar na View, separado, num único lugar.

 

Você até poderia criar um conjunto super complexo de classes e mais classes, todas respeitando tudo quanto é princípio da OOP e, no Controller montar o layout inteiro através de métodos aninhados em cadeia e na View dar um simples echo.

 

Mas você perde tanta performance que não compensa.

[Guilherme_90 33]

Concordo com o Bruno. Se alguém conseguir mostrar como não misturar PHP com HTML, por favor, afinal, estamos aqui para aprender.

[João Batista Neto 448]

Eu sinceramente não sei onde, quem e porque raios alguém, algum dia, achou que misturar HTML com PHP não é uma boa prática.

 

Agora, se me permitem, ainda sinceramente falando, eu acho que esse alguém estava estudando MVC, não entendeu o que leu, e saiu falando besteira, baseando-se exclusivamente na sua não compreensão de um assunto que, muito provavelmente, estudou pela metade.

 

:seta: PHP foi construída para ser embutida no HTML.

[Andrey Knupp Vital 136]

:seta: PHP foi construída para ser embutida no HTML.

 

Exato , mas ainda tem o oposto disso aí 'HTML ser embutido em PHP' .. não nego que tenho minhas views que emitam html .. claro .. mas as vezes isso torna o código meio 'repetido' não ?

[João Batista Neto 448]

Exato , mas ainda tem o oposto disso aí 'HTML ser embutido em PHP' ..

 

Não importa se o PHP está embutido no HTML ou se é o contrário. O fato é que a mistura faz parte.

 

Agora, minha marcação também é montada pelo meu PHP e garanto, não existe repetição.

[Andrey Knupp Vital 136]

Agora, minha marcação também é montada pelo meu PHP e garanto, não existe repetição.

 

Hmmmmmmmmmmm, e quando a estrutura de elementos é grande .. nesse caso você não faz a marcação na mão apenas no echo , você com certeza tem um objeto para desenhar o HTML com seus nodes , childNodes .. ?

 

Algo tipo :

<?php

class View {


	public function showProductList ( ) {
		$prdt = new Panel ( ) ;
		$prdt->addChild ( new Panel ( ) ) 
		// ... 
	}

}

[ro.fonseca 1]

Misturar PHP com HTML é absolumante normal, php gerar html tb é normal, agora o problema e que eu tb nao gosto é de você gerar todo o seu html por php, já vi sistemas que usavam classe para gerar o html e era pessimo para mexer e inviabilizava o trabalho de um designer, eu acho que a crítica é essa(pelo menos a minha).

[Andrey Knupp Vital 136]

Misturar PHP com HTML é absolumante normal, php gerar html tb é normal, agora o problema e que eu tb nao gosto é de você gerar todo o seu html por php, já vi sistemas que usavam classe para gerar o html e era pessimo para mexer e inviabilizava o trabalho de um designer, eu acho que a crítica é essa.

 

Bem, eu acho que nesse caso, depois do design pronto, o que será alterado como ( lista de produtos ) que será trazida do banco, entre outras coisas .. nos observamos a marcação, e passamos para o PHP , afinal, as informações que o designer coloca, são fixas, apenas para testar o posicionamento, e visualização de como vai ficar ..

 

Assumimos parte da marcação depois do site pronto, pois nem sempre o designer vai voltar a alterar a marcação da página ..

[ro.fonseca 1]

Bem, eu acho que nesse caso, depois do design pronto, o que será alterado como ( lista de produtos ) que será trazida do banco, entre outras coisas .. nos observamos a marcação, e passamos para o PHP , afinal, as informações que o designer coloca, são fixas, apenas para testar o posicionamento, e visualização de como vai ficar ..

 

Assumimos parte da marcação depois do site pronto, pois nem sempre o designer vai voltar a alterar a marcação da página ..

É, eu até iria citar um exemplo como esse que é perfeitamente normal o php se aliar ao html, mas o que eu critiquei sobre o html ser gerado pelo php, é que no sistema por exemplo que mexi, existia uma classe que gerava o html, essa classe recebia o "id", recebia "classe", enfim, td que é marcação html a classe recebia pra poder gerar o html(até css em algumas ocasioes), resultado, inviabilizava o trabalho do designer e multiplicava o trabalho do programador.

[Andrey Knupp Vital 136]

CSS com PHP é horrível .. você ter um atributo style no elemento, beleza .. daí você estaria definindo uma regra de ultima hora .. mas fazer à folha de estilos .. é porco !

[Henrique Barcelos 290]

A questão é que a flexibilidade existente num 'PHP gerador de HTML' é difícil de ser conseguida se fizéssemos o contrário, inserindo PHP no HTML.

Exemplo: utilizo objetos SelectBox para criar um select em um formulário que tenha uma estrutura um pouco complexa:

/**
* Abstração para a tag 'select'
* @author Henrique
* @uses HTMLComposite
*/
class SelectBox extends AbstractFormElement {
private $optgroups = array();
private $options = array();
private $optionsInOptgroup = array();
private $selectedOption;

public function __construct() {
	parent::__construct(new CompositeTag('select'));
}

/**
	* Adiciona o atributo 'selected' à tag option que possui o atributo value=$value
	* @param mixed $value
	*/
public function setSelected($value) {
	$value = sprintf('%s', $value);
	$opt = $this->getOption($value);
	if($opt instanceof CompositeTag) {
		$opt->setAttr(new TagAttribute('selected', 'selected'));
		$this->selectedOption = $opt;
	}

	return $this;
}

/**
	* Retorna a opção selecionada inicialmente, se estiver setada
	* @return mixed
	*/
public function getSelected() {
	return $this->selectedOption;
}

/**
	* Adiciona uma tag optgroup ao select
	* @param mixed $id
	* @param string $label
	*/
public function addOptgroup($id, $label) {
	$id = sprintf('%s', $id);
	$label = sprintf('%s', $label);
	if(empty($this->optgroups[$id]))
		$this->optgroups[$id] = new CompositeTag('optgroup');

	$this->optgroups[$id]->setAttr(new TagAttribute('id', $id))->setAttr(new TagAttribute('label', $label));
}

/**
* Remove uma tag optgroup do select
* @param mixed $id
* @param string $label
*/
public function removeOptgroup($id) {
	$id = sprintf('%s', $id);
	if(isset($this->optgroups[$id])){
		$this->element->removeChild($this->optgroups[$id]);
		unset($this->optgroups[$id]);
	}
}

/**
	* Adiciona uma tag option ao select
	* @param array $option
	* @example array('value1'=>'text1','value2'=>'text2')
	*/
public function addOption($key, $text, $optgroup = null, $attributes = array()) {
	$key = sprintf('%s', $key);
	$text = sprintf('%s', $text);

	$tag = new CompositeTag('option');
	$tag->setAttr(new TagAttribute('value', sprintf('%s', $key)));
	foreach($attributes as $attr)
		if($attr instanceof TagAttribute)
			$tag->setAttr($attr);

	if($optgroup !== null && isset($this->optgroups[$optgroup])){
		$this->optionsInOptgroup[$key] = $tag;
		$this->optgroups[$optgroup]->addChild($tag);
	} else {
		$this->options[$key] = $tag;
		$this->element->addChild($tag);
	}

	$tag->addChild(new TextNode($text));

	return $this;
}

/**
* Remove uma tag option do select
* @param array $option
* @example array('value1'=>'text1','value2'=>'text2')
*/
public function removeOption($key) {
	$key = sprintf('%s', $key);
	if(isset($this->options[$key])){
		$this->element->removeChild($this->options[$key]);
		unset($this->options[$key]);
	} else if(isset($this->optionsInOptgroup[$key])){
		foreach($this->optgroups as $each)
			$each->removeChild($this->optionsInOptgroup[$key]);

		unset($this->optionsInOptgroup[$key]);
	}
	return $this;
}

/**
	* Retorna a tag option cujo atributo value=$key
	* @param mixed $key
	*/
public function getOption($key) {
	$key = sprintf('%s', $key);
	if(isset($this->options[$key]))
		return $this->options[$key];
	if(isset($this->optionsInOptgroup[$key]))
		return $this->optionsInOptgroup[$key];

	return null;
}

public function generateHTML() {
	return $this->element->genHTML();	
}

public function __toString() {
	return $this->generateHTML();
}
}

 

Uso:

$select = new SelectBox();
$select->setID('type')
->setName('type')
->addClass('required')
->addOption('', 'Selecione...');

foreach($data as $each)
$select->addOption($each->getValue('id'), $each->getValue('name');

$select->setSelected($selectedId);
echo $select->generateHTML();

 

Tem gente que fala: 'pobrezinho do desenvolvedor front-end'. Cara... nesse meio, você tem que saber um pouco de tudo. Não adianta nada o cara saber tudo do front-end e não saber o básico de uma linguagem server-side. A questão é projetar uma interface razoavelmente simples, que possa ser usada por (quase) qualquer um.

[Guilherme_90 33]

Henrique Barcelos

 

Me tira uma dúvida por favor: Por que e pra que fazer isso tudo de código pra gerar um select do HTML?

Eu só quero que me explica se realmente há necessidade disso, pois quero muito entender esse raciocínio.

[Henrique Barcelos 290]

Imagine um select com algumas regras mais complexas, como aninhamento de optgroups. Gerar isso com o 'PHP no HTML' pode ser trabalhoso demais.

Dessa forma, é possível você manipular o elemento como no Javascript, adicionando e removendo propriedades quando preciso, antes de renderizar o elemento, ao passo que ao ir gerando diretamente o HTML, não é possível fazer alguma mudança depois.

 

Está vendo isso aqui?

new CompositeTag('optgroup')

Eu uso uma estrutura de árvores simplificada, parecida com o DOM, que eu mesmo implementei para fins de estudo.

 

O exemplo que eu postei não foi muito feliz pois é bem simples. Vou procurar algo melhor para exemplificar.

 

Só fazendo umas observações no post do nosso colega JBN:

 

Esse tipo de literatura é muito diferente de um romance, você não lê 1 vez e gosta da história, você lê N vezes e, depois de já ter lido muito mesmo, passa a utilizar como guia de referência.

Fato. Quando li pela primeira vez, acho que o único que consegui absorver (e de maneira errada ainda :P) foi o Singleton. É meio frustrante.

Mas aí passa um tempo, você olha praquele livro **caro** que você comprou e pensa:

- Não é possível que eu só vá gastar dinheiro nisso!

 

No meu caso, a felicidade foi ter pego emprestado de um amigo, que comprou, mas não gostou e resolveu me emprestar por tempo indeterminado ;).

 

Esse foi o grande motivador quando resolvi criar o tópico índice sobre Padrões GoF aqui no fórum, são exemplos aplicados em problemas reais, de usuários reais aqui do fórum.

Esse índice de padrões GoF do JBN deveria ser tombado como patrimônio nacional pelo governo =].

 

A busca por exemplos mais palpáveis é algo que eu tenho buscado imensamente também: aplicações práticas, para nosso "mundo real". Estou pensando em fazer meu TCC sobre Design Patters para desenvolvimento web e PHP, vamos ver se sai alguma coisa :lol:.

 

A elegância do código nem é importante, justamente pelo fato do código não ser importante. Mas um padrão é isso mesmo, a definição de um problema recorrente e uma solução reutilizável para ele.

Quando me referia à elegância da solução, não quis dizer sobre a implementação do padrão em si, mas sim sobre a elegância do sistema como um todo, no final.

Em quesito de elegância, os padrões Decorator e Observer, por exemplo, são os que se destacam para mim quando se observa o "todo".

[Guilherme_90 33]

Henrique Barcelos

Por mais simples que seja sua explicação e seu exemplo, eu ainda não entendi 100%. Acho que só vai cair a ficha com o tempo, não tem jeito.

[Henrique Barcelos 290]

Você vai entender que MODERAÇÃO é a chave de tudo... Use todas as ferramentas que você tem à disposição, mas use com sabedoria.

No form desse exemplo que eu postei, é só isso que é 'PHP gerado com HTML', o resto é tudo 'PHP dentro do HTML'.

 

Já fui pelo caminho de gerar todo o HTML dentro do PHP e acredite, não é uma experiência agradável. O contrário também não é.

Uma hora ou outra você acha esse ponto de equilíbrio.

[Guilherme_90 33]

Henrique Barcelos

Mais aí que está. Eu não sei e não consigo criar um problema em que eu precise fazer este tipo de coisa, entendeu?

[Henrique Barcelos 290]

Quase todos os problemas podem ser resolvidos de 'n' maneiras diferentes.

Do mesmo jeito que eu utilizei esse tipo de solução, muita gente discorda e acha que NÃO SE DEVE USAR de jeito nenhum.

Cabeças diferentes pensam diferente =]

[Guilherme_90 33]

Eu penso que o mais importante é você consegui resolver o problema, agora como resolveu a história muda. Não existe a melhor solução, nem a pior. Posso estar errado, mas é assim que aprendemos.

 

=)

[Andrey Knupp Vital 136]

Eu penso que o mais importante é você consegui resolver o problema, agora como resolveu a história muda.

Hmmmm , resolver o problema é resolver, não tem importância pro usuário .. afinal, o usuário não vê o código fonte

Saber fazer uma escolha entre o certo e o errado, aí sim a história muda ..

 

Não existe a melhor solução, nem a pior.

 

Por que não ?