Existe-t-il un moyen de réaffecter $this ?

StackOverflow https://stackoverflow.com/questions/2067258

  •  20-09-2019
  •  | 
  •  

Question

Tout d’abord, je ne souhaite pas prolonger un cours.J'aimerais idéalement faire cela.

public function __construct() {
 /* Set Framework Variable */
 global $Five;
 $this =& $Five;
}

J'ai un système où la variable $Five est une classe conteneur qui contient d'autres bibliothèques.Je pourrais attribuer cela à une variable locale de Five...c'est à dire.

public function __construct() {
 /* Set Framework Variable */
 global $Five;
 $this->Five = $Five;
}

Cependant, la raison pour laquelle j'essaie d'éviter cela est que les appels de fonction deviendraient un peu longs.

$this->Five->load->library('library_name');

C'est un peu moche.Ce serait bien mieux.

$this->load->library('library_name');

Quelle est la meilleure solution pour cela ?

Était-ce utile?

La solution

je pense que 

$this->Five->load->library('library_name');

sera votre meilleure option, à moins que vous ne décidiez que la classe étende la classe d'assistance.ALIAS

class Something extends Helper_Class

Cependant, cela signifie que Helper_Class est instancié chaque fois que vous instanciez une classe.

Une autre méthode consisterait à avoir une classe pseudo-statique qui assignerait toutes les classes auxiliaires aux membres de la classe.

public function setGlobals($five)
{
    $this->loader = $five->loader;
}

Alors appelle-le

public function __construct($five)
{
    someClass::setGlobals($five);
}

Si $Five est mondial, vous pourriez simplement global $Five chaque fois que vous souhaitez l'utiliser, mais mettre cela en haut de chaque fonction semble être un mauvais codage.

De plus, j'aimerais simplement faire mon annonce d'intérêt public selon laquelle les variables globales sont généralement une mauvaise idée, et vous souhaiterez peut-être rechercher « Injection de dépendance » ou une alternative aux globales.ALIAS

public function __construct($five);

au lieu de

global $five;

Les globaux reposent sur une variable externe qui doit être présente et déjà définie, tandis que l'injection de dépendances demande une variable qu'elle suppose être une instance de la classe Five.

Si vous utilisez PHP 5.1 (Merci Gordon), vous pouvez vous assurer que la variable est une instance de FiveClass en faisant cela:

public function__construct(FiveClass $five);

Autres conseils

$ Ceci est une référence à l'instance actuelle de la classe que vous définissez. Je ne crois pas que vous pouvez lui assigner. Si cinq est globale, vous devriez être en mesure de faire ceci: 

$Five->load->library('library_name');

Vous voudrez peut-être aller avec une sorte de mise en œuvre du schéma d'injection de dépendance:

  

injection de dépendance (DI) dans l'ordinateur   la programmation fait référence au processus de   fournir une dépendance externe à un   composant logiciel. Il est spécifique   sous forme d'inversion de commande lorsque le   préoccupation étant inversé est le processus   d'obtention de la dépendance nécessaire.

Voir aussi documentation pour le conteneur DI symfony . Je recommande vivement cette mise en œuvre du conteneur DI si vous voulez améliorer la façon dont vous gérez vos « GLOBALS ».

Vous pouvez également avoir une lecture de cette question sur les 'meilleures façons d'accéder à des objets globaux'.

Que diriez-vous faire les membres de données et méthodes de cinq membres statiques de classe? Ce 

$this->Five->load->library('library_name');

deviendrait cette 

Five::load->library('library_name');

et vous ne pas avoir à passer et cinq $ partout.

Vous ne pouvez pas écraser cette $ (comme par exemple en C ++) mais vous pouvez facilement construire une total en utilisant __call () pour les appels de méthode et __get (), __set (), __isset () pour les propriétés.

Exemple de __call (): 

class Five {
  public function bar() {
    echo __METHOD__, " invoked\n";
  }
}

class Foo {
  protected $Five = null;

  public function __construct(Five $five=null) {
     if ( is_object($five) ) {
       $this->Five = $five;
     }
   }

  public function __call($name, $args) {
    // there's no accessible method {$name} in the call context
    // let's see if there is one for the object stored in $five
    // and if there is, call it.
    $ctx = array($this->Five, $name);
    if ( !is_null($this->Five) && is_callable($ctx) ) {
      return call_user_func_array($ctx, $args);
    }
    else {
      // ....
    }
  }
}

$foo = new Foo(new Five);
$foo->bar();

gravures Five::bar invoked.
À mon avis, le plus grand tirage est de retour qu'il est beaucoup plus difficile de voir « de l'extérieur » ce que l'objet est capable.

Je suis sûr que vous ne pouvez pas réassigner $this, car il est une de ces choses spéciales qui ressemble à une variable en PHP, mais il est traité un peu différemment dans les coulisses.

Si vos préoccupations sont la sémantique de votre appel de méthode obtenir trop longtemps, je fais load un appel de méthode au lieu d'une propriété d'objet 

$this->load()->library('library_name');

public function load()
{
    return $this->Five;
}
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top