En PHP, ¿cómo se crean objetos reutilizables ?, ¿existe una mejor práctica para esto? ¿Qué prefieres?

Question

Estoy creando algunos objetos reutilizables en php, y quería saber cuál es la mejor manera de construirlos. A continuación tengo 2 ejemplos de diferentes formas de hacer esto.

Class Uploader{ 
    public $Filename; 
    public $Directory; 

    function upload(){ 
     upload_file($this->Filename, $this->Directory) 
    } 
} 

// Then use the class above like this. 
$u = new Uploader; 
$u->Filename = 'foo.png'; // Set all the props 
$u->Directory = 'bar/' //^^^^
$u->upload();    // Then Execute 

O sería mejor hacer esto ...

Class Uploader { 
    function uploader($filename, $directory){ 
     upload_file($filename, $directory) 
    } 
} 

// Then use the class above like this. 
$u = new Uploader; 
$u->uploader('foo.png', 'bar/') // Obviously much less code, All in One. 

Fuera de estos dos métodos, que uno se prefiere, es su diferencia de velocidad o cualquier tipo de aumento de la utilización de una sobre el otro?
Favorezco el ejemplo n. ° 1, pero ¿es una buena práctica para esto?

Answer 1

¿Por qué no puedes hacer las dos cosas?

class Uploader 
{ 
    public 
    $filename, 
    $directory; 

    public function __construct($name = '', $dir = '', $autoUpload = false) 
    { 
    $this->filename = $name; 
    $this->directory = $dir; 
    if ($autoUpload) 
    { 
     $this->upload() 
    } 
    } 

    public function upload() 
    { 
    //check your values 
    ...code... 
    upload_file($this->filename, $this->directory); 
    } 
} 

Con esta técnica, se puede cargar automáticamente un archivo simplemente con:

$uploader = new Uploader($name, $dir, true); 

o se puede construir manualmente el objeto con:

$uploader = new Uploader(); 
$uploader->filename = $name; 
$uploader->directory = $dir; 
$uploader->upload(); 

Answer 2

El método uno es un enfoque OO clásico donde el objeto que crea alberga los datos y los métodos para actuar sobre esos datos. El segundo método simplemente crea una biblioteca de funciones de utilidad dentro de una clase. El método dos es, sin duda, más rápido, pero menos OO en su enfoque. Si está disparando para su reutilización, en realidad iría con el método uno. Si es el rendimiento que desea, omita el uso de clases por completo y escriba una biblioteca funcional.

Answer 3

Daniel Pereira tiene razón sobre el rendimiento.

para mezclar los dos ejemplos (del perfomance & reutilización), puede intentar:

Class Uploader{ 
    public $Filename; 
    public $Directory; 

    function Uploader($this->Filename, $this->Directory){ 
     upload_file($this->Filename, $this->Directory); 
    } 
} 
$a = new Uploader('foo.png','bar'); 
echo $a->Filename; //foo.png 
echo $a->Directory; //bar 

Cabe realidad (a causa de un error):

Class Uploader{ 
     public $Filename; 
     public $Directory; 

     function Uploader($Filename, $Directory){ 
      $this->Filename = $Filename; 
      $this->Directory = $Directory; 
      upload_file($this->Filename, $this->Directory); 
     } 
    } 

Answer 4

Si usted quiere hacer verdadera OO, el primer ejemplo es bastante bueno. Otra sugerencia sería la siguiente:

Class Uploader{ 
    private $Filename; 
    private $Directory; 

    function upload(){ 
     upload_file($this->Filename, $this->Directory) 
    } 

} 

continuación, puede crear setFileName y métodos SetDirectory por lo que abstraer la configuración de esos campos para más adelante.

También puede crear un constructor con esos campos en él. Muchas formas de resolver este problema.