Seções iMasters
PHP

Classe genérica para formulários – Parte 01

Hoje iniciaremos uma série de artigos que abordam a criação de uma classe php totalmente orientada a objeto para geração de formulários. Porém, antes vamos observar brevemente as características do form, seus atributos e elementos adicionais.

Os formulários HTML são estruturas que permitem a usuários submeterem dados a uma página. Esses dados podem ser tratados e/ou armazenados dependendo da aplicação. Possuem uma tag de abertura e outra de fechamento, inserindo os elementos adicionais entre essas duas.

Estrutura:
<form (atributos/valores)> (elementos) </form>

Atributos:

  • accept
  • accept_charset
  • action
  • method
  • enctype
Elementos Adicionais:
- input - <input (atributos/valores) />
- option - <option (atributos/valores)> (nome) </option>
- select - <select (atributos/valores)> (elemento option) ou (elemento optgroup) </select>
- textarea - <textarea (atributos/valores)> (texto) </textarea>
- button - <button (atributos/valores)> (nome) </button>
- label - <label (atributos/valores)> (rótulo) </label>
- fieldset - <fieldset (atributos/valores)> (elemento legend [opcional] ) (elementos) </fieldset>
- optgroup - <optgroup (atributos/valores)> (elemento option) </optgroup>

Com base nessas informações, iniciaremos a construção de nossa classe genérica.

Criação da classe commons (comum), attribute (atributo) e element (elemento)

O primeiro passo será a criação das classes genéricas, ou seja, as classes que serão utilizadas como extensões para as demais classes. A classe commons será responsável pelos métodos __set() e __get(). A classe attribute será a instância de nossos atributos e, por fim, a classe element manipulará essas instâncias de attribute.

Class commons

Definiremos a classe commons como abstrata (abstract), pois ela não deve ser instanciada, servirá apenas de apoio para as demais. Adicionamos então dois métodos de interceptação (intercepções – conceito introduzido no PHP5), o método __set() e __get().

O método __set() interceptará a atribuição de valores a propriedades do objeto. Assim, sempre que for atribuído um valor a uma propriedade do objeto, automaticamente essa atribuição passará pelo método __set().

O método __get() interceptará requisições de propriedades do objeto. Assim, sempre que for requisitada uma propriedade, automaticamente essa requisição passará pelo método __get().

abstract class commons {
 function __set( $property,$val ) {
  $this->$property = $val;
 }
 
 function __get( $property ) {
  return $this->$property;
 }
}

Class attribute

A classe attribute será uma extensão da classe commons, herdando os métodos __set() e __get(). Definimos também a mesma como final. Adicionamos duas variáveis, attribute e value, responsáveis por guardar o nome do atributo e seu valor. Então incluímos o método construtor __construct() que atribuirá o valor de attribute e value na criação do objeto, caso seja passado algum valor.

final class attribute extends commons {
 protected $attribute;
 protected $value;
 
 function __construct( $attribute,$value ) {
  $this->attribute = $attribute;
  $this->value = $value;
 }
}

Class element

A classe element será uma extensão da classe commons e abstrata (abstract). A função desta classe será manipular os objetos attribute, para isso adicionaremos três métodos: addAttribute, hasAttributes e getAttributes.

Como o próprio nome já descreve, o método addAttribute adicionará na array attributes uma instância do objeto attribute. A palavra attribute antes de $attribute descreve que a variável recebida deverá ser um objeto attribute. hasAttributes tem a finalidade de verificar se a array attributes possui filhos, retornando um booleano.

Por fim, o método getAttributes percorre os atributos contidos na array attribute e os transformam em uma string plana para serem adicionados mais tarde aos elementos. Definimos também o método draw como abstrato (abstract), obrigando as subclasses que herdarem element a implementar draw().

abstract class element extends commons {
 protected $attributes;
 
 final public function addAttribute( attribute $attribute ) {
  $this->attributes[] = $attribute;
 }
 
 final public function hasAttributes() {
  return count( $this->attributes ) > 0;
 }
 
 final public function getAttributes() {  
  $elementAttributes = '';   
  foreach( $this->attributes as $attribute ) {
   $elementAttributes .= "{$attribute->attribute}=\"{$attribute->value}\" ";
  }
  return $elementAttributes;  
 }
 
 abstract function draw();  
}

Na segunda parte da série de artigos, vamos iniciar a construção dos elementos. Espero vocês. Até a próxima!

Mensagem do anunciante:

Em apoio à evangelização do WordPress, os cursos da Apiki são gratuitos para que você possa se especializar na plataforma que mais cresce no mundo. Vagas limitadas, Inscreva-se agora.

Comente também

2 Comentários

Henrique José Pires Barcelos

Desculpe se posso parecer um pouco “duro”, mas já começou errado ali na classe Commons utilizando métodos mágicos.

Segundo, ali nos mesmos métodos mágicos, vc seta propriedades que nem se quer existem na classe. No PHP, que infelizmente permite esse tipo de coisa, as propriedades criadas dinamicamente são todas PUBLIC. Cadê o princípio de ocultação dos dados?

O que estou vendo aí é um código procedural com uma ‘papel de presentes’ bonitinho.
Desculpe a franqueza.

William Bruno

Não curto ‘server-side’ gerador de HTML… considero isso muita mistura de camadas.

Qual a sua opinião?