add_action référence une classe

Non,vousne pouvezpas «initialiser» ouinstancier la classe via un hook,pas directement. Un code supplémentaireesttoujoursnécessaire (et cen'estpas une chose souhaitable depouvoir lefaire,car vous ouvrez uneboîte de verspour vous-même.

Voici unemeilleurefaçon deprocéder:

 class MyClass {
     function __construct() {
          add_action( 'admin_init', [ $this, 'getStuffDone' ] );
     }
     function getStuffDone() {
          // .. This is where stuff gets done ..
     }
}
$var = new MyClass();
 

Bien sûr,onpourrait créer une classe d'interfacepour la simplifierencoreplus dans le casgénéral:

 class IGetStuffDone {
    function IGetStuffDone(){
        add_action( 'admin_init', [ $this, 'getStuffDone' ] );
    }
    public abstract function getStuffDone();
}
 

Notez qu'entant qu'interface,vousne pouvezpas créer directement un objet de cetype,mais vouspouvez créer une sous-classeen vous laissant dire:

 class CDoingThings extends IGetStuffDone {
    function getStuffDone(){
        // doing things
    }
}
$var = new CDoingThings();
 

Ce qui ajouterait alors automatiquementtous les hooks,il vous suffit de définirexactement ce quiestfait dans une sous-classepuis de la créer!

Sur les constructeurs

Jen'ajouteraispas de constructeur commefonction de hook,c'est unemauvaisepratique,et celapeut conduire à denombreux événementsinhabituels. Deplus,dans laplupart des langages,un constructeur renvoie l'objet quiestinstancié,donc si votre hook doit renvoyer quelque chose comme dans unfiltre,ilne retournerapas la variablefiltrée comme vous le souhaitez,mais à laplaceil retournera l'objet de classe.

L'appel direct d'un constructeur ou d'un destructeurest unetrès,très,trèsmauvaisepratique deprogrammation,quel que soit le langage dans lequel vous voustrouvez,et ne devrait jamais êtrefait.

Les constructeurs devraient également construire des objets,pour lesinitialiserprêts à être utilisés,paspour untravail réel. Letravail àeffectuerpar l'objet doit être dans unefonction distincte.

Méthodes de classe statiques,et n'ayantpas dutoutbesoin d'instancier/initialiser

Si votreméthode de classeest uneméthode de classe statique,vouspouvezpasser lenom de la classeentreguillemetsplutôt que $this commeindiqué ci-dessous:

 class MyClass {
    public static function getStuffDone() {
        // .. This is where stuff gets done ..
    }
}
add_action( 'admin_init', [ __NAMESPACE__ . '\MyClass','getStuffDone' ] );
 

Notez l'utilisation de __NAMESPACE__ quiest requis si votre classeest à l'intérieur d'unespace denoms.

<₹Closures

Malheureusement,vousne pouvezpas éviter la ligne créant lanouvelle classe. La seule autre solutionpour l'ignorerimpliquerait un code deplaque de chaudière qui atoujours cette ligne,parexemple:

 add_action( 'admin_init', function() {
    $var = new MyClass();
    $var->getStuffDone();
} );
 

À ce stade,vouspouvez aussiignorer le courset simplement utiliser unefonction:

 add_action( 'admin_init', function() {
   // do stuff
} );
 

Maisgardez à l'esprit que vous avezmaintenantintroduit le spectre desfonctions anonymes. Iln'y a aucunmoyen de supprimer l'action ci-dessusen utilisant remove_action,et celapeut causerbeaucoup de douleur aux développeurs qui doiventtravailler avec le code d'autrespersonnes.

Sur lesesperluettes

Vouspouvez voir des actions utilisées comme ceci:

 array( &$this, 'getStuffDone' )
 

C'estmauvais . & a été rajouté dans PHP 4 lorsque les objets étaientpassésen tant que valeurs,pasen tant que références. PHP 4 aplus de dix anset n'apas étéprisen chargepar WordPress depuistrès longtemps.

Iln'y a aucune raison d'utiliser &this lors de l'ajout de hookset defiltres,et la suppression de la référencene posera aucunproblèmeet pourramême améliorer la compatibilité avec lesfutures versions PHP

Utilisezplutôt ceci:

 [ $this, 'getStuffDone' ]
 

No, you cannot 'initialise' or instantiate the class through a hook, not directly. Some additional code is always required ( and it is not a desirable thing to be able to do that, as you're opening a can of worms for yourself.

Here is a better way of doing it:

class MyClass {
     function __construct() {
          add_action( 'admin_init', [ $this, 'getStuffDone' ] );
     }
     function getStuffDone() {
          // .. This is where stuff gets done ..
     }
}
$var = new MyClass();

Of course one could create an interface class to simplify it for the general case even further:

class IGetStuffDone {
    function IGetStuffDone(){
        add_action( 'admin_init', [ $this, 'getStuffDone' ] );
    }
    public abstract function getStuffDone();
}

Note that as an interface, you can't create an object of this type directly, but you could create a sub-class, letting you say:

class CDoingThings extends IGetStuffDone {
    function getStuffDone(){
        // doing things
    }
}
$var = new CDoingThings();

Which would then automatically add all the hooks, you just need to define what exactly is being done in a subclass and then create it!

On Constructors

I wouldn't add a constructor as a hook function, it's bad practice, and can lead ot a lot of unusual events. Also in most languages a constructor returns the object that is being instantiated, so if your hook needs to return something like in a filter, it will not return the filtered variable as you want, but instead it will return the class object.

Directly calling a constructor or a destructor is very, very, very bad programming practice, no matter which language you're in, and should never be done.

Constructors should also construct objects, to initialise them ready for use, not for actual work. Work to be done by the object should be in a separate function.

Static class methods, and not needing to instantiate/initialise at all

If your class method is a static class method, you can pass the name of the class in quotes rather than $this as shown below:

class MyClass {
    public static function getStuffDone() {
        // .. This is where stuff gets done ..
    }
}
add_action( 'admin_init', [ __NAMESPACE__ . '\MyClass','getStuffDone' ] );

Note the use of __NAMESPACE__ which is required if your class is inside a namespace.

Closures

Sadly you cannot avoid the line creating the new class. The only other solution to skipping it would involve boiler plate code that still has that line e.g.:

add_action( 'admin_init', function() {
    $var = new MyClass();
    $var->getStuffDone();
} );

At which point you may as well skip the class, and just use a function:

add_action( 'admin_init', function() {
   // do stuff
} );

But keep in mind you have now introduced the spectre of anonymous functions. There is no way to remove the above action using remove_action, and this can and does cause great pain for developers who have to work with other peoples code.

On Ampersands

You may see actions used like this:

array( &$this, 'getStuffDone' )

This is bad. & was added back in PHP 4 when objects were passed as values, not as references. PHP 4 is more than a decade old, and hasn't been supported by WordPress in a very long time.

There is no reason to use &this when adding hooks and filters, and removing the reference will cause no issues, and may even improve compatibility with future versions of PHP

Use this instead:

[ $this, 'getStuffDone' ]

Exemple de classe

Remarques:

• Initier la classe une seulefois
  • Appel à lapriorité 0,afin que vouspuissiez utiliser lemême hook avec laprioritépar défautplustard
  • Enveloppez-le dans un ! class_existspour éviter de l'appeler deuxfoiset placer l'appelantinit à l'intérieur
• Créez lafonction initet la classe var static
• Appelez le constructeur depuis l'intérieur de votreinit,lorsque vous appelez la classe new self.

Voici unexemple

 if ( ! class_exists( 'WPSESampleClass' ) )
{
    // Init the class on priority 0 to avoid adding priority inside the class as default = 10
    add_action( 'init', array ( 'WPSESampleClass', 'init' ), 0 );

class WPSESampleClass
{
    /**
     * The Class Object
     */
    static private $class = null;

    public static function init()
    {
        if ( null === self::$class ) 
            self :: $class = new self;

        return self :: $class;
    }

    public function __construct()
    {
        // do stuff like add action calls:
        add_action( 'init', array( $this, 'cb_fn_name' ) );
    }

    public function cb_fn_name()
    {
        // do stuff 
    }
} // END Class WPSESampleClass

} // endif;
 

Php 5+

Veuillez ,laissez le & de côté. Nous sommes déjà au-delà dephp4. :)

Example class

Notes:

• Init the class only once
  • Call on priority 0, so you can use the same hook with the default priority later
  • Wrap it up in a ! class_exists to avoid calling it twice and place the init caller inside
• Make the init function and the class var static
• Call the constructor from inside your init, when you call the class new self.

Here's an example

if ( ! class_exists( 'WPSESampleClass' ) )
{
    // Init the class on priority 0 to avoid adding priority inside the class as default = 10
    add_action( 'init', array ( 'WPSESampleClass', 'init' ), 0 );

class WPSESampleClass
{
    /**
     * The Class Object
     */
    static private $class = null;

    public static function init()
    {
        if ( null === self::$class ) 
            self :: $class = new self;

        return self :: $class;
    }

    public function __construct()
    {
        // do stuff like add action calls:
        add_action( 'init', array( $this, 'cb_fn_name' ) );
    }

    public function cb_fn_name()
    {
        // do stuff 
    }
} // END Class WPSESampleClass

} // endif;

Php 5+

Please, leave the & out. We're already beyond php4. :)

 if (!class_exists("AllInOneWoo")){
    class AllInOneWoo {
        function __construct(){
            add_action('admin_menu', array($this, 'all_in_one_woo') );
        }
        function all_in_one_woo(){
            $page_title = 'All In One Woo';
            $menu_title = 'All In One Woo';
            $capability = 'manage_options';
            $menu_slug  = 'all-in-one-woo-menu';
            $function   = array($this, 'all_in_one_woo_menu');
            $icon_url   = 'dashicons-media-code';
            $position   = 59;

            add_menu_page($page_title, $menu_title, $capability, $menu_slug, $function, $icon_url, $position);
        }
        function all_in_one_woo_menu(){?>
            <div class="wrap">
                <h1><?php _e('All In One Woo', 'all_in_one_woo'); ?></h1>
            </div>
        <?php }
    }// end class
}// end if

if (class_exists("AllInOneWoo")){       
    $all_in_one_woo = new AllInOneWoo();
}
 

if (!class_exists("AllInOneWoo")){
    class AllInOneWoo {
        function __construct(){
            add_action('admin_menu', array($this, 'all_in_one_woo') );
        }
        function all_in_one_woo(){
            $page_title = 'All In One Woo';
            $menu_title = 'All In One Woo';
            $capability = 'manage_options';
            $menu_slug  = 'all-in-one-woo-menu';
            $function   = array($this, 'all_in_one_woo_menu');
            $icon_url   = 'dashicons-media-code';
            $position   = 59;

            add_menu_page($page_title, $menu_title, $capability, $menu_slug, $function, $icon_url, $position);
        }
        function all_in_one_woo_menu(){?>
            <div class="wrap">
                <h1><?php _e('All In One Woo', 'all_in_one_woo'); ?></h1>
            </div>
        <?php }
    }// end class
}// end if

if (class_exists("AllInOneWoo")){       
    $all_in_one_woo = new AllInOneWoo();
}

Celafonctionnepourmoi:

 class foo
{
    public static function bar()
    {
        echo 'it works!';
    }
}

add_action('foo_bar', array('foo', 'bar'));
 

This works for me:

class foo
{
    public static function bar()
    {
        echo 'it works!';
    }
}

add_action('foo_bar', array('foo', 'bar'));

Demanièregénérale,vousn'ajouteriezpas une classe entière à un hook.Les hooks add_action()/add_filter() attendent des fonctions de rappel,qui peuvent être référencées depuis dansune classe .

Disons que vous avez unefonction init() à l'intérieur de votre classe,que vous souhaitez connecter au hook WordPress init.

Mettez votre appel add_action() dans votre classe,puisidentifiez le rappel comme ceci:

 add_action( 'init', array( $this, 'init' ) );
 

(Remarque:je suppose que votre classeest correctementespacée denoms; sinon,assurez-vous d'espacer vosfonctions de rappel.)

Generally speaking, you wouldn't add an entire class to a hook. The add_action()/add_filter() hooks expect callback functions, which can be referenced from within a class.

Let's say that you have an init() function inside your class, that you want to hook into the WordPress init hook.

Put your add_action() call inside your class, and then identify the callback like so:

add_action( 'init', array( $this, 'init' ) );

(Note: I'm assuming your class is properly namespaced; otherwise, be sure to namespace your callback functions.)

Vous devriezpouvoir lefaireen passant lenom de la classe au lieu de l'objetinstancié:

 add_action( 'init', array( 'MyClass', '__construct' ) );
 

(Enthéorie,votre autre solution devrait égalementfonctionner

 $var = new MyClass();
add_action( 'admin_init', array( $var, '__construct' ) );
 

Jene saispaspourquoi cen'estpas le cas.Peut-être que si vousn'appelezpaspar référence?)

You should be able to do it by passing the class name instead of the instantiated object:

add_action( 'init', array( 'MyClass', '__construct' ) );

(In theory, your other solution should work too

$var = new MyClass();
add_action( 'admin_init', array( $var, '__construct' ) );

Not sure off the head why it doesn't. Maybe if you don't call by reference?)

Vouspouvez déclencher des événements dans votre classe sans avoir à le charger initialement .C'estpratique si vousne voulezpas charger la classe complète à l'avance,mais devez accéder auxfiltreset actions WordPress.

Voici unexempletrès simple

 <?php
class MyClass
{
    public static function init()
    {
        add_filter( 'the_content', array('MyClass', 'myMethod') );
    }

    public static function myMethod($content)
    {
        $content = $content . 'Working without loading the object';
    }
}

MyClass::init();
 

Ceciest une versiontrès simplifiée de la réponse de Kaisermaismontreen termes simples le comportement.Celapourrait être utilepour ceux qui regardent ce stylepour lapremièrefois.

D'autresméthodespeuventtoujours lancer l'objet sinécessaire.J'utilisepersonnellement cetteméthodepourpermettre auxparties optionnelles demonplugin demettre des scriptsen file d'attente,maisne déclenche l'objet que sur une requête AJAX.

You can trigger events in your class without the need to load it initially. This is handy if you don't want to load the full class up front, but need to access the WordPress filters and actions.

Here's a very simple example

<?php
class MyClass
{
    public static function init()
    {
        add_filter( 'the_content', array('MyClass', 'myMethod') );
    }

    public static function myMethod($content)
    {
        $content = $content . 'Working without loading the object';
    }
}

MyClass::init();

This is a very simplified version of Kaiser's answer but shows in simple terms the behaviour. Might be handy for those looking at this style for the first time.

Other methods can still initiate the object if required. I'm personally using this method to allow optional parts of my plugin to enqueue scripts, but only triggering the object on an AJAX request.