En utilisant $ this, self ::, parent :: pour la lisibilité du code

Question

Je voudrais savoir s'il est acceptable/préférable d'utiliser self :: method() et parent :: method() quand on travaille dans les classes php.

Vous pouvez utiliser $ this-> method() mais $ this-> peut également faire référence à une variable de classe, une variable de classe parente ou une méthode de la classe parente. Il n'y a pas d'ambiguïté en soi ::

Est auto :: déprécié et/ou y a-t-il des inconvénients ou des inconvénients à utiliser ce style? Je comprends que self :: et parent :: font référence à une instance statique de la classe, mais dans kohana, à moins que vous ne définissiez spécifiquement une méthode comme statique, il ne semble pas y avoir de différence.

Merci.

Ajouté un exemple: À supposer que ce forum l'application stocke à partir de plusieurs sites ...

class Forum_Controller extends Controller { 

    function __construct() 
    { 
     parent::__construct(); 
    } 

    function index() 
    { 
     echo self::categories(); 
    } 

/* 
* get a list of categories from a specific site. 
*/ 
    private function categories() 
    { 
     $db = new Database; 
     $categories = $db->query(" 
      SELECT * FROM 
      forum_categories 
      WHERE fk_site = '$this->site_id' 
     "); 
     $view = new View('categories_view'); 
     $view->categories = $categories; 
     return $view; 
    } 

} 

Cet exemple travaille dans kohana avec des rapports d'erreur modifiee: error_reporting (E_ALL & ~ E_STRICT); $ This-> id_site est défini dans la classe principale Controller_Core (une bibliothèque de kohana). Autant que je sache, $ ceci n'est pas censé être disponible puisque j'appelle self :: categories() de façon statique, mais c'est seulement quand je définis static() static (statique) que ça lance une erreur . Mais comme je l'ai dit, je préfère plutôt utiliser self :: parce que d'un point de vue lisibilité, je sais exactement où cette fonction devrait être, plutôt que d'utiliser $ this qui cause l'ambiguïté, pour moi.

Answer 1

Les contrôleurs ne sont pas statiques dans Kohana, bien qu'ils puissent contenir des variables/méthodes ou constantes membres statiques.

self:: est un raccourci d'écriture ClassName:: i.e.

class Animal 
{ 
    public static $arms = 0; 
} 

class Dog extends Animal 
{ 
    public static $leg = 0; 
    const NAME = 'dog'; 

    public static function bark() 
    { 
     echo 'Woof'; 
    } 
} 

Pour appeler des fonctions statiques ou obtenir des constantes d'une classe, nous utilisons l'opérateur de résolution de portée ::. Les fonctions statiques sont par classe pas par objet.Dire :: fait référence à des instances statiques d'une classe est faux, c'est juste un moyen d'accéder aux méthodes statiques - il n'y a pas une instance d'objet qui a ces méthodes.

donc:

Dog::bark(), 
Dog::$leg, 
Dog::NAME, 

nous pouvons également utiliser

Animal::$arms 

A l'intérieur du chien de classe, nous pouvons utiliser pour que self:: et parent:: on n'a pas besoin de taper le nom complet de la classe (comme il pourrait être très long!)

En réponse à votre question cependant: Non - self:: n'est pas déprécié et non ce n'est pas une mauvaise pratique de l'utiliser. La raison pour laquelle il n'est pas utilisé dans kohana core est pour une raison très différente .... (extensions de classe transparentes avec eval lire ci-dessous pour plus d'informations ...).

p.s appeler des méthodes non statiques est statiquement mal et ne doit pas être si vous définissez accueillie-error_reporting(E_ALL | E_STRICT) (comme vous devriez au cours du développement), vous verrez une erreur soulevée.

Fondamentalement, ce qui se passe est:

de base a un fichier appelé:

class Controller_Core { 
    public function someMethod(){} 
} 

Vous créez:

// We can use someMethod of Controller_Core 
Index_Controller extends Controller {} 

Cela se prolonge vraiment Controller_CoreSAUF SI vous avez créé MY_Controller .php qui serait class Controller extends Controller_Core

//MY_Controller.php 
class Controller extends Controller_Core 
{ 
     // overloads Controller_Core::someMethod without us having to change the core file 
     public function someMethod(){} 
} 

Answer 2

Je pense que self :: est généralement utilisé pour les fonctions statiques et les propriétés. J'utilise Kohana, et peut-être que les contrôleurs sont rendus statiques.

Answer 3

Il existe une différence.

$this fait référence à une instance d'un objet.

parent et self sont utilisés pour appeler des méthodes statiquement. Je l'explique plus en détail que je n'ai le temps d'écrire pour l'instant. Le premier exemple en particulier devrait aider à mettre en évidence certaines des différences. Je vous encourage à copier le premier exemple et à le déconner, car je pense que c'est un concept important à prendre en compte si vous ne connaissez pas déjà la différence.

Answer 4

Je ne pouvais pas ajouter un commentaire (apparemment je n'ai pas le représentant nécessaire!)

class Forum_Controller extends Controller { 

public function __construct() 
{ 
    parent::__construct(); 
} 

public function index() 
{ 
    echo self::categories(); 
} 

/* 
* get a list of categories from a specific site. 
*/ 
private static function categories() 
{ 
    $db = new Database; 

    // You cannot use $this in a static function, because static functions are per class 
    // and not per object it doesnt know what $this is :) (make private static $site_id and use self::$site_id) if this is what you want 

    $categories = $db->query(" 
      SELECT * FROM 
      forum_categories 
      WHERE fk_site = '$this->site_id' 
    "); 
    $view = new View('categories_view'); 
    $view->categories = $categories; 
    return $view; 
} 

}

Comme je l'ai dit, vous devez utiliser error_reporting (E_ALL | E_STRICT) ; (Modifier dans le fichier kohana)

appelant catégories de fonctions privées() fonctionne de manière statique en raison d'un bogue dans PHP, vous ne devriez pas être en mesure de le faire :)

Answer 5

Une autre chose à noter par la façon dont est que ce n'est pas très bon design MVC pour faire des fonctions de contrôleur statiques qui renvoient des listes de catégories.

Les contrôleurs servent à traiter les demandes. Les modèles sont destinés à traiter les données (ce qui est ce que c'est) et les vues sont à afficher.

faire un modèle!

class Category_Model extends Model 
{ 
     public function categories($site_id) 
     { 
      $categories = $this->db->from('forum_categories')->where('fk_site',$site_id)->get(); 

       return new View('categories_view', array('categories' => $categories)); 
     } 
} 

...

$cat = new Category_Model; 

echo $cat->categories(1); 

Answer 6

J'utilise strictement auto :: uniquement pour les variables statiques et fonction membre statique