PHP - ¿Quieres decir evitar los métodos mágicos?

Question

estaba leyendo esta página - http://deaduseful.com/blog/posts/50-php-optimisation-tips-revisited

Y una de las recomendaciones era evitar el uso de Métodos mágicos, citó de un PDF Rendimiento Zend que da ninguna razón para que su recomendación para evitarlos.

Después de algunas búsquedas en Google (y terminando aquí con una pregunta no relacionada) me pregunté si alguien tenía alguna recomendación en ese frente.

Uso __get() mucho en mi código, generalmente para guardar variables que no siempre uso, p.

que puede tener una tabla con el nombre, la descripción, category_id, time_added

Mi get sería algo como esto:

 
public function __get($name) { 
    switch($name) { 
     case 'name': 
     case 'desc': 
     case 'category': 
     case 'time_added': 
      $result = do_mysql_query(); 
      $this->name = $result['name']; 
      $this->desc = $result['desc']; 
      $this->category = $result['category']; 
      $this->time_added = $result['time_added']; 
      return $this->{$name}; 
     break; 
     default: 
      throw Exception("Attempted to access non existant or private property - ".$name); 
    } 
} 

Esto parece una gran manera de hacer las cosas, ya que sólo alguna vez algo de la base de datos si es necesario y puedo ver cosas como $ article-> time_added en lugar de jugar con matrices.

¿Esto se consideraría una mala práctica y una carga adicional en el servidor?

A menudo ampliaré las clases con métodos mágicos y haré algo como esto si la clase hija no coincide con algo en un get.

 
public function __get($name) { 
    switch($name) { 
     case 'name': 
     case 'desc': 
     case 'category': 
     case 'time_added': 
      $result = do_mysql_query(); 
      $this->name = $result['name']; 
      $this->desc = $result['desc']; 
      $this->category = $result['category']; 
      $this->time_added = $result['time_added']; 
      return $this->{$name}; 
     break; 
     default: 
      return parent::__get($name); 
    } 
} 

¿Sería esto una mala práctica y perjudicial para el rendimiento? La cantidad máxima de niveles que tengo cuando extiendo métodos mágicos es tres.

Answer 1

Es cierto, son más lentos ... pero la diferencia es tan pequeña que la velocidad contra el código es un factor. ¿Vale la pena preocuparse por la diferencia para un desarrollo y mantenimiento más rápidos?

Ver magic benchmarks para las estadísticas

Answer 2

considerar el uso de array accessors.

class Record implements ArrayAccess { 

    /** 
    * @see ArrayAccess::offsetExists() 
    * 
    * @param offset $offset 
    */ 
    public function offsetExists($offset) { 

    } 

    /** 
    * @see ArrayAccess::offsetGet() 
    * 
    * @param offset $offset 
    */ 
    public function offsetGet($offset) { 
     //fetch and cache $result 

     return $result[$offset]; 
    } 

    /** 
    * @see ArrayAccess::offsetSet() 
    * 
    * @param offset $offset 
    * @param value $value 
    */ 
    public function offsetSet($offset, $value) { 

    } 

    /** 
    * @see ArrayAccess::offsetUnset() 
    * 
    * @param offset $offset 
    */ 
    public function offsetUnset($offset) { 

    } 

Answer 3

hice algunas pruebas con métodos mágicos PHP y operaciones nativa get/set (en una propiedad pública)

Los resultados:

métodos mágicos son mucho más lento que el acceso nativo. PERO el tiempo de acceso sigue siendo tan pequeño, que no hará una diferencia en el 99.9% de todos los casos.

Incluso si lo hace de 1 millón de accesos método mágico dentro de una petición, todavía sólo toma aproximadamente 0,1 segundos ...

---

"sólo lectura" significa acceso a través de métodos mágicos. La imagen muestra los resultados de PHP 5.5.9 y PHP 7.0.

Aquí es el guión de referencia: https://github.com/stracker-phil/php-benchmark/blob/master/benchmark.php