PHP OO Mejor forma de crear campos de un formulario

[Ronin46]

Hola,

Suponiendo que tengo una clase Formulario y luego tantas clases como tipos de campo que soporta el Formulario...

¿Qué es mejor, crear los campos a través del formulario o crear los campos por fuera y luego enlazarlos con el formulario?

Para que quede más claro pongo un poco de pseudocódigo

Creando campos a través del formulario:

Código PHP:

  $Form = new cForm ("MiFormulario"); 
$Form->CrearTextarea ("MiTextarea"); 
$Form->DarValorCampo ("MiTextarea", "BlaBlaBla")  
   

Creando campos por fuera y enlazándolos:

Código PHP:

  $Form = new cForm ("MiFormulario"); 
$Textarea = new cTextarea ("MiTextarea"); 
$Textarea->SetValor = "BlaBlaBla"; 
$Form->EnlazarCampo ($Textarea);  
   

Gracias!

[GatorV]

Es más limpio a mi parecer la segunda opción ya que así no tienes que contaminar la clase cForm con tareas que no son de la clase (recuerda principio de polimorfismo).

También puedes tener un método init() y heredar la clase y así en el método init de las subclases crear y atar los elementos que necesites.

Saludos.

[Ronin46]

Es más limpio a mi parecer la segunda opción ya que así no tienes que contaminar la clase cForm con tareas que no son de la clase (recuerda principio de polimorfismo).

Si veo lo que me dices de contaminar la clase cForm pero me dejas un poco contrariado con la coletilla del polimorfismo ya que es en la primera opción donde precisamente estoy haciendo polimorfismo (o eso creo), mientras que en la segunda simplemente estoy enlazando los campos y la "configuración" del campo la hago por fuera del formulario.

Vuelvo a poner el código de la primera opción con unos pequeños cambios.

Código PHP:

  Class cForm 
{ 
    private $Campos = array(); 
 
    public function CrearCampo ($Tipo, $Nombre) 
    { 
        $this->Campos[$Nombre] = new $Tipo ($Nombre); 
    } 
 
    public function DarValorCampo ($Nombre, $Valor) 
    { 
        $this->Campos[$Nombre]->SetValor = $Valor; 
    } 
} 
 
$Form = new cForm ("MiFormulario"); 
$Form->CrearCampo ("Textarea", "MiTextarea"); 
$Form->DarValorCampo ("MiTextarea", "BlaBlaBla")  
   

También puedes tener un método init() y heredar la clase y así en el método init de las subclases crear y atar los elementos que necesites.

Esto se escapa a mis conocimientos actuales , ¿me puedes pasar alguna referencia o poner algún ejemplo?

Gracias!

[GatorV]

Respecto a lo primero te digo, al contaminar la clase con cosas que no deberían de pertenecer a esa clase rompes con un diseño más puro de tu clase, es por eso que te decía que lo que debes de hacer es solo "adjuntar" los métodos al formulario.

Respecto a tu segunda duda es algo sencillo:

Código PHP:

class CForm {
         public function __construct()
         {
                  // cosas para la construccion
                  $this->init();
         }
 
         public function init()
         {
                 // aqui es donde puedes heredar e iniciar tu forma
         }
}
 
class MiFormulario extends cForm
{
         public function init()
         {
                   $this->addElement(new cText('blah'));
                   $this->addElement(new cTextarea('blah2'));
         }
}
 
$form = new MiFormulario();
 

Saludos.

[Ronin46]

Vale, perfecto, precisamente el trozo de código que pusiste es justo lo que tenía en mente.
Tener una clase base Formulario (que sería abstracta) y luego cada formulario tener su propia clase que hereda de la clase base Formulario. y es en esa clase que hereda donde personalizar el formulario con sus campos y demás historias.

Lo que no entiendo es por qué tener el método Init y no hacerlo en el construct, tal que:

Código PHP:

  class cForm { 
         public function __construct() 
         { 
         } 
} 
  
class MiFormulario extends cForm 
{ 
         public function __construct() 
         { 
                   $this->addElement(new cText('blah')); 
                   $this->addElement(new cTextarea('blah2')); 
 
                   parent::__construct(); 
         } 
} 
  
$form = new MiFormulario();  
   

Total, que si he entendido bien la clase quedaría así:

Código PHP:

  class cForm 
{ 
    private $Campos = array(); 
 
    public function addCampo ($Campo) 
    { 
        $this->Campos[$Campo->GetNombre()] = $Campo; 
    } 
 
    public function DarValorCampo ($Campo, $Valor) 
    { 
        $this->Campos[$Campo]->SetValor = $Valor; 
    } 
} 
 
class cMiForm extends cForm 
{ 
    public function __construct () 
    { 
        $this->addCampo(new cTextarea('MiTextarea')); 
    } 
} 
 
$MiForm = new cMiForm(); 
$MiForm->DarValorCampo('MiTextarea', 'Blablabla');  
   

[GatorV]

Pues todo depende, si haces tareas de construcción específicas, sería bueno tener un método init para que si se olvidan hacer el parent::__construct() no quede tu objeto en un estado que no sea funcional.

Saludos.

[Ronin46]

Ok, gracias GatorV

[Ronruby]

Yo utilizaría la 2da opcion como te dice GatorV. Para asi desacoplar los componentes del formulario del formulario como tal. Así puedo agregar nuevos componentes sin tener que editar el código de mi clase formulario (y así mantengo el principio OCP, también el SRP).

Lo que si te recomiendo es la parte de:

Código PHP:

class cForm 
{ 
    private $Campos = array(); 
 
    public function addCampo (Campo $Campo) //Mejor uso del POLIMORFISMO 
    { 
        $this->Campos[$Campo->GetNombre()] = $Campo; 
    } 
}
 

La clase formulario no debe estar encargada de darle los valores a los input que contiene. Talvez si deba mantener el estado y llamar alguna funcion del mismo campo para setear el valor, pero no encargarse el mismo de darselo.

[Ronin46]

La clase formulario no debe estar encargada de darle los valores a los input que contiene. Talvez si deba mantener el estado y llamar alguna funcion del mismo campo para setear el valor, pero no encargarse el mismo de darselo.

Creo que me he perdido.

¿Según tu comentario esto estaría mal?:

Código PHP:

  class cForm 
{ 
    private $Campos = array(); 
 
    public function addCampo (cCampo $Campo) 
    { 
        $this->Campos[$Campo->GetNombre()] = $Campo; 
    } 
 
    public function SetTitleCampo ($NombreCampo, $Title) 
    { 
        $this->Campos[$NombreCampo]->SetTitle = $Title; 
    } 
} 
 
class cMiForm extends cForm 
{ 
    public function __construct () 
    { 
        $this->addCampo(new cTextarea('MiTextarea')); 
        $this->SetTitleCampo ('MiTextarea', 'Tooltip explicativo de MiTextarea'); 
    } 
} 
 
$MiForm = new cMiForm();  
   

¿Según tu comentario esto estaría bien?:

Código PHP:

  class cForm 
{ 
    private $Campos = array(); 
 
    public function addCampo (cCampo $Campo) 
    { 
        $this->Campos[$Campo->GetNombre()] = $Campo; 
    } 
} 
 
class cMiForm extends cForm 
{ 
    public function __construct () 
    { 
        $Textarea = new cTextarea('MiTextarea'); 
        $Textarea->SetTitle('Tooltip explicativo de MiTextarea'); 
        $this->addCampo($Textarea); 
    } 
} 
 
$MiForm = new cMiForm();  
   

En caso de que el segundo código sea el correcto, ¿cómo podría cambiar el title del campo una vez que he hecho el $MiForm = new cMiForm();? Tendría que tener un método para recoger el campo, cambiarle el title y volver a hacer un addCampo?

Gracias!

[GatorV]

Claro recuerda que en PHP todos los objetos se devuelven por referencia:

Código PHP:

$campo = $form->getField('foo');
$campo->setTitle('el titulo');
$campo->setValue('valor');
$campo->foo('bar');
 

Saludos.