Constructeur php oop

Question

OK. voici ce que je suis en train de faire:

class Image{ 

    public $_image; 
    public $_extension; 
    public $_mime; 
    public $_size; 
    public $_location; 
    public $_description; 

    public function __construct($image, $location){ 
     $this->_image = $image; 
     $this->_location = $location; 
     $this->_extension = getExtension(); 
     $this->_mime = getMime(); 
     $this->_size = getSize(); 
    } 

    private functions fallow..... 

} 

Mais je continue à obtenir une erreur interne du serveur lorsque je tente de l'exécuter. Quand je commente les appels de méthode cela fonctionne. Donc la question est de savoir si je peux appeler des méthodes à l'intérieur du constructeur ou si je fais quelque chose de mal avec les méthodes.

Answer 1

Vos fonctions getExtension, getMime et getSize existent-elles? Sont-ils des méthodes sur cette classe? Si ce sont des méthodes, ils ont besoin d'être appelé avec $ this -> ... comme dans

$this->_extension = $this->getExtension(); 

Si elles ne sont pas des méthodes et des fonctions, vous devez vous assurer que les fichiers qui contiennent/les définir sont chargé avant d'exécuter le constructeur.

Answer 2

Oui, vous pouvez appeler des méthodes depuis le constructeur. Rappelez-vous que la méthode magique __construct() a été implémentée en PHP 5. Avant cela, vous créiez une fonction nommée comme votre classe qui agissait comme votre constructeur, donc cela dépendait de votre version de PHP, cela pouvait poser problème.

En outre, les appels de fonction que vous effectuez sont-ils dans la classe ou externes? Si elles sont à l'intérieur de la classe, vous devez les appeler de cette façon:

$this->_extension = $this->getExtension(); 

Answer 3

Vous n'avez pas spécifié quelle erreur vous expiriencing clairement. Mais essayez de vous appeler des méthodes de classe au sein même du mot-clé en utilisant la classe this, sinon il ne fonctionnerait pas:

public function __construct($image, $location) 
{ 
    $this->_image = $image; 
    $this->_location = $location; 
    $this->_extension = $this->getExtension(); 
    $this->_mime = $this->getMime(); 
    $this->_size = $this->getSize(); 
} 

serait une meilleure idée de poster votre code pour les méthodes que vous avez écrit. Il pourrait y avoir quelque chose de mal en eux aussi. Peut-être oublier de retourner un résultat ou quelque chose ...

Answer 4

fragment ..ce bien du code fonctionne comme prévu:

class Foo 
{ 
    protected $secret = null; 
    public function __construct($data) 
    { 
     $this->secret = $this->makeSecret($data); 
    } 

    public function makeSecret($data) 
    { 
     return md5($data); 
    } 
} 

$bar = new Foo('lorem ipsum'); 

Ce n'est pas un problème.

Mais vous devriez savoir, cela est considéré comme une mauvaise pratique - faire du calcul/travail dans le constructeur. Cela rend cette classe pratiquement impossible à tester. Au lieu de cela, si vous devez effectuer un calcul avant de "libérer" l'objet au reste du code, vous devez utiliser une fabrique. Quelque chose le long des lignes de:

class ImageFactory 
{ 
    public function build($image, $location) 
    { 
     $instance = new Image($image, $location); 
     $instance->prepare(); 
     return $instance; 
    } 
} 

La classe aurait besoin de quelques changements:

class Image 
{ 

    protected $_image; // you were leaking abstraction 
    protected $_extension; 
    protected $_mime; 
    protected $_size; 
    protected $_location; 
    protected $_description; 

    public function __construct($image, $location) 
    { 
     $this->_image = $image; 
     $this->_location = $location; 
    } 

    public function prepare() 
    { 
     $this->_extension = $this->getExtension(); 
     $this->_mime = $this->getMime(); 
     $this->_size = $this->getSize(); 
    } 

    private functions fallow..... 

} 

Maintenant, quand vous devez créer un nouvel objet que vous faites:

$factory = new ImageFactory; 
$image = $factory->build($file, '/uploads/'); 

Bien sûr, l'instance de ImageFactory peut être réutilisable, et si toutes vos images utilisent le même $location, alors vous passeriez cette variable à l'usine lors de l'initialisation. Et l'usine serait en mesure de « souvenir » et passer à toutes les images qu'il crée:

$factory = new ImageFactory('/uploads/'); 
$img1 = $factory->build($file); 
$img2 = $factory->build($something_else); 

Ceci est en fait la façon dont on doit faire face à la création d'objets multiples, qui ont tous besoin d'un accès à une même instance de connexion DB.