Usando la estática para las propiedades predeterminadas de la clase -- bject-oriented campo con php5 campo con static camp codereview Relacionados El problema

Using static for class default properties


1
vote

problema

Español

He hecho una clase para generar elementos de formulario HTML:

  class input {   public $tag = 'input', $type = 'text', $customClass, $name;    public function __construct(array $cfg){     if ( isset($cfg['name']) ){       if ( isset($cfg['tag']){         $this->tag = strtolower($cfg['tag']);       }       if ( $this->tag === 'input' && isset($cfg['type']){         $this->type = $cfg['type'];       }       if ( isset($cfg['customClass']){         $this->customClass= $cfg['customClass'];       }       //etc...     }   } }   

Me gustaría poder establecer una configuración predeterminada personalizada para todos mis campos, sin cambiar la clase. Por ejemplo, quiero todos los campos en un script dado para tener 'MyClass' como CustomClass. Para mí, la solución sería hacer estadísticas de estos valores predeterminados y hacer una función para cambiarlos así:

  class input {   static $tag = 'input', $type = 'text', $customClass, $name;    public static function setDefault(array $cfg){     if ( isset($cfg['tag']) ){       self::tag = strtolower($cfg['tag']);     }     if ( isset($cfg['type']) ){       self::type = $cfg['type'];     }     if ( isset($cfg['customClass']) ){       self::customClass= $cfg['customClass'];     }     //etc...   }    public function __construct(array $cfg){     if ( isset($cfg['name']) ){       $this->tag = isset($cfg['tag']) ? strtolower($cfg['tag']) : self::tag;       $this->type = isset($cfg['type']) ? strtolower($cfg['type']) : self::type;       $this->customClass = isset($cfg['customClass']) ? $cfg['customClass'] : self::customClass;       //etc...     }   } }   

El problema es que leí en todas partes, y particularmente aquí, que estática es malo. ¿Qué otra solución sería adecuada en el presente caso? O puede alguien decirme "¡Sí, ese es el caso perfecto para usar estática!"? :)

Original en ingles

I have made a class for generating html form elements:

class input {   public $tag = 'input', $type = 'text', $customClass, $name;    public function __construct(array $cfg){     if ( isset($cfg['name']) ){       if ( isset($cfg['tag']){         $this->tag = strtolower($cfg['tag']);       }       if ( $this->tag === 'input' && isset($cfg['type']){         $this->type = $cfg['type'];       }       if ( isset($cfg['customClass']){         $this->customClass= $cfg['customClass'];       }       //etc...     }   } } 

I would like to be able to set a custom default config for all my fields - without changing the class. For example I want all the fields in a given script to have 'myClass' as customClass. For me, the solution would be to make these default values static, and make a function to change them like this:

class input {   static $tag = 'input', $type = 'text', $customClass, $name;    public static function setDefault(array $cfg){     if ( isset($cfg['tag']) ){       self::tag = strtolower($cfg['tag']);     }     if ( isset($cfg['type']) ){       self::type = $cfg['type'];     }     if ( isset($cfg['customClass']) ){       self::customClass= $cfg['customClass'];     }     //etc...   }    public function __construct(array $cfg){     if ( isset($cfg['name']) ){       $this->tag = isset($cfg['tag']) ? strtolower($cfg['tag']) : self::tag;       $this->type = isset($cfg['type']) ? strtolower($cfg['type']) : self::type;       $this->customClass = isset($cfg['customClass']) ? $cfg['customClass'] : self::customClass;       //etc...     }   } } 

The problem is that I read everywhere - and particulary here - that static are evil. What other solution would be suitable in the present case? Or can someone tell me "yeah, that's the perfect case to use statics!"? :)

        
   
   

Lista de respuestas

1
 
vote
vote
La mejor respuesta
 

Podría una objeto de configuración o un constructor para esto. Como probablemente puedas verte, usando estática se complica bastante rápido.

usando un constructor :

  class InputBuilder {     private $_defaults = array(         'tag' => null,         'type' => null,     );      private $_current;      public function __construct(array $defaults = null)     {         foreach ($defaults as $key => $value) {             if (array_key_exists($this->_defaults[$key])) {                 $this->_defaults[$key] = $value;             }         }          $this->reset();     }      public function reset()     {         $this->_current = array();         foreach ($this->_defaults as $key => $value) {             $this->_current[$key] = $value;         }            }      public function setTag($tag)     {         if (!is_string($tag)) {             throw new InvalidArgumentException('...');         }         $this->_current['tag'] = $tag;     }      public function setType($type)     {         if (!is_string($type)) {             throw new InvalidArgumentException('...');         }         $this->_current['type'] = $type;         }      public function getInput()     {         return new Input($this->_current);     } }   

El uso sería:

  $builder->setType('text')         ->build();  // tag: input, type: text $builder->setType('password')         ->build(); // tag: input, type: password $builder->reset(); // reset everything to defaults $builder->setTag('textarea') // tag: textarea: type: text         ->build();   

El patrón del constructor es extremadamente fuerte si desea construir el objeto programáticamente. (SQL) Constructor de consulta es un caso de uso muy común para esto.

usando un objeto de configuración :

  class InputConfiguration {         private $_init = array(             'tag' => null,             'type' => null,         );          private $_current;          public function __construct(array $defaults = null)         {             foreach ($defaults as $key => $value) {                 if (array_key_exists($this->_defaults[$key])) {                     $this->_defaults[$key] = $value;                 }             }         }          public function configure(Input $element)         {             $config = $this->_init['tag'];              if (null !== $config['tag'] && null !== $element->getTag()) {                 $element->setTag($config['tag']);             }              if (null !== $config['type'] && null !== $element->getType()) {                 $element->setType($config['type']);             }         } }  class Input  {      public function construct(InputConfiguration $config = null)      {            if (null !== $config) {                $config->configure($this);            }      }       // ... }   

El uso sería:

  $configuration = new InputConfiguration(     'tag' => 'input',      'type' => 'text', );  $newObject = new Input($configuration); // has defaults applied  $newObject2 = new Input(); // we don't want to use defaults $configuration->configure($newObject2); // or decide to apply them later on   

El objeto de configuración desacopla la configuración de su objeto. Además, hace una configuración reutilizable y opcional.

 

You could either a configuration object or a builder for this. As you probably can see yourself, using static gets complicated quite fast.

Using a builder:

class InputBuilder {     private $_defaults = array(         'tag' => null,         'type' => null,     );      private $_current;      public function __construct(array $defaults = null)     {         foreach ($defaults as $key => $value) {             if (array_key_exists($this->_defaults[$key])) {                 $this->_defaults[$key] = $value;             }         }          $this->reset();     }      public function reset()     {         $this->_current = array();         foreach ($this->_defaults as $key => $value) {             $this->_current[$key] = $value;         }            }      public function setTag($tag)     {         if (!is_string($tag)) {             throw new InvalidArgumentException('...');         }         $this->_current['tag'] = $tag;     }      public function setType($type)     {         if (!is_string($type)) {             throw new InvalidArgumentException('...');         }         $this->_current['type'] = $type;         }      public function getInput()     {         return new Input($this->_current);     } } 

Usage would be:

$builder->setType('text')         ->build();  // tag: input, type: text $builder->setType('password')         ->build(); // tag: input, type: password $builder->reset(); // reset everything to defaults $builder->setTag('textarea') // tag: textarea: type: text         ->build(); 

The builder pattern is extremely strong if you want to build the object programmatically. (SQL) Query-builder are a very common use case for this.

Using a configuration object:

class InputConfiguration {         private $_init = array(             'tag' => null,             'type' => null,         );          private $_current;          public function __construct(array $defaults = null)         {             foreach ($defaults as $key => $value) {                 if (array_key_exists($this->_defaults[$key])) {                     $this->_defaults[$key] = $value;                 }             }         }          public function configure(Input $element)         {             $config = $this->_init['tag'];              if (null !== $config['tag'] && null !== $element->getTag()) {                 $element->setTag($config['tag']);             }              if (null !== $config['type'] && null !== $element->getType()) {                 $element->setType($config['type']);             }         } }  class Input  {      public function construct(InputConfiguration $config = null)      {            if (null !== $config) {                $config->configure($this);            }      }       // ... } 

Usage would be:

$configuration = new InputConfiguration(     'tag' => 'input',      'type' => 'text', );  $newObject = new Input($configuration); // has defaults applied  $newObject2 = new Input(); // we don't want to use defaults $configuration->configure($newObject2); // or decide to apply them later on 

The configuration object decouples the configuration from your object. Furthermore it makes one configuration reusable and optional.

 
 
   
   

Relacionados problema

10  Imitación básica de C # enumerable en VBA - o cualquier otra clase estática  ( Basic imitation of c enumerable in vba or any other static class ) 
Desde la implementación de clases estáticas en VBA en realidad parece posible Se me ocurrió una idea para tratar de imitar C # ' 9988776655544330 clase ...

5  Reflexión y proyecto EULER  ( Reflection and project euler ) 
He hecho un corredor de Project Euler para facilitar el funcionamiento de los diversos problemas. Nunca antes había usado la reflexión, y creo que he encontra...

4  Extensiones primitivas: reemplaza los métodos primitivos estáticos  ( Primitive extensions replaces static primitive methods ) 
Me molestó tener que hacer cosas como string.IsNullOrEmpty(myString) Cuando parecía que 9988776665544337 es suficiente. Por lo tanto, escribí una pequeña ...

4  Aplicación de Android para enviar solicitudes de nombre de usuario y contraseña  ( Android app for sending username and password requests ) 
Estoy desarrollando una aplicación de Android que realiza varias solicitudes a un servidor utilizando la androidasynchronoushttpclient . Una de estas solici...

3  Navegador web en swing con MVC  ( Web browser in swing with mvc ) 
Pregunta de seguimiento a: Utilizando OOP al crear un navegador web Después de recibir la ayuda en la pregunta anterior, he creado 3 clases para mi Brows...

2  ¿Cómo puedo mejorar este código sin usar estática o singleton? [cerrado]  ( How can i improve this code without using static or singleton ) 
cerrado. Esta pregunta es off-topic . Actualmente no está aceptando respuestas. ¿Quieres ...

2  Reflexión de Java y Clases estáticas  ( Java reflection and static classes ) 
Intento interceptar algunas llamadas OpenGL para probar mis clases de representación. La reflexión se utiliza para reemplazar el backend de OpenGL. Siento q...

7  Uso de una clase estática para un motor de juego  ( Use of a static class for a game engine ) 
He estado diseñando un motor de juego durante los últimos meses con pequeños problemas. Sin embargo, un objetivo principal con este proyecto es ponerlo en mi ...

3  Valores de búsqueda en caché en un sitio web de comercio electrónico  ( Caching lookup values in an e commerce website ) 
Estoy trabajando en un sitio web de comercio electrónico. Tengo un desplegamiento 99887766555443344 que contiene nombres de automóviles y su ID correspondie...

5  Configuración de Tostring a través de una variable estática pública  ( Configuring tostring via a public static variable ) 
A veces necesito toString() para ser bastante verboso, normalmente no lo hago. No se puede resolver muy bien mediante el uso de otros métodos como toString...




© 2022 respuesta.top Reservados todos los derechos. Centro de preguntas y respuestas reservados todos los derechos