Il modo migliore per iniziare una lezione in un plugin WP?

Bella domanda,ci sono diversi approccie dipende da ciò che vuoi ottenere.

Lofaccio spesso;

 add_action( 'plugins_loaded', array( 'someClassy', 'init' ));

class someClassy {

    public static function init() {
        $class = __CLASS__;
        new $class;
    }

    public function __construct() {
           //construct what you see fit here...
    }

    //etc...
}
 

Unesempiopiù approfonditoe approfondito che è venutofuori come risultato di alcune recenti discussioni su questo stesso argomento all'interno della chat roompuòessere vistoin questa sintesi delmembro WPSE toscho .

L'approccio del costruttore vuoto.

Ecco unestratto dei vantaggi/svantaggipresi dall'essenzaprecedente cheesemplifica completamente l'approccio del costruttore vuoto.

• Vantaggi:

  • Gli unittestpossono crearenuoveistanze senza attivare alcun hook automaticamente. Nessun singleton.

  • Nessuna variabileglobalenecessaria.

  • Chiunque voglia lavorare con l'istanza delpluginpuò semplicemente chiamare T5_Plugin_Class_Demo ::get_instance ().

  • Facile da disattivare.

  • OOP ancora reale:nessunmetodo di lavoro è statico.

• Svantaggio:

  • Forse èpiù difficile da leggere?

Lo svantaggio secondome è debole,motivoper cui dovrebbeessereilmio approcciopreferito,manon l'unico che uso. Ineffetti molti altripesimassimiinterverranno senza dubbio su questo argomento con la loropresa sull'argomento abreveperché ci sono alcunebuone opinioni su questo argomento che dovrebberoessereespresse.

_{nota: hobisogno ditrovare l'esempioessenziale da toscho che ha superato 3 o 4 confronti su comeistanziare una classe all'interno di unplug-in che haesaminatoi proei contro di ciascuno,cheil collegamento sopraerailmodopreferitoperfarlo,magli altriesempiforniscono unbuon contrasto con questo argomento. Si spera che toscho lo abbia ancorain archivio.}

Nota: Risposta WPSE a questo argomento conesempie confrontipertinenti. Anche lamigliore soluzioneperesempio una classein WordPress.

 add_shortcode( 'baztag', array( My_Plugin::get_instance(), 'foo' ) );
class My_Plugin {

    private $var = 'foo';

    protected static $instance = NULL;

    public static function get_instance() {

        // create an object
        NULL === self::$instance and self::$instance = new self;

        return self::$instance; // return the object
    }

    public function foo() {

        return $this->var; // never echo or print in a shortcode!
    }
}
 

Good question, there are a number of approaches and it depends on what you want to achieve.

I often do;

add_action( 'plugins_loaded', array( 'someClassy', 'init' ));

class someClassy {

    public static function init() {
        $class = __CLASS__;
        new $class;
    }

    public function __construct() {
           //construct what you see fit here...
    }

    //etc...
}

A more thorough an indepth example which came about as a result of some recent discussions on this very topic within the chat room can be seen in this gist by WPSE member toscho.

The empty constructor approach.

Here is an excerpt of advantages/disadvantages taken from the above gist which exemplifies the empty constructor approach in full.

• Advantages:

  • Unit tests can create new instances without activating any hooks automatically. No Singleton.

  • No global variable needed.

  • Whoever wants to work with the plugin instance can just call T5_Plugin_Class_Demo::get_instance().

  • Easy to deactivate.

  • Still real OOP: no working methods are static.

• Disadvantage:

  • Maybe harder to read?

The disadvantage in my opinion is a weak one at that which is why it would have to be my favored approach, however not the only one I use. In fact several other heavy weights will no doubt chime in on this topic with their take on the subject shortly because there are some good opinions surrounding this topic that should be voiced.

_{note: I need to find the gist example from toscho that ran through 3 or 4 comparisons of how to instantiate a class within a plugin that looked at the pros and cons of each, which the above link was the favored way to do it, but the other examples provide a good contrast to this topic. Hopefully toscho still has that on file.}

Note: The WPSE Answer to this topic with relevant examples and comparisons. Also the best solution for instance a class in WordPress.

add_shortcode( 'baztag', array( My_Plugin::get_instance(), 'foo' ) );
class My_Plugin {

    private $var = 'foo';

    protected static $instance = NULL;

    public static function get_instance() {

        // create an object
        NULL === self::$instance and self::$instance = new self;

        return self::$instance; // return the object
    }

    public function foo() {

        return $this->var; // never echo or print in a shortcode!
    }
}

Uso la seguente struttura:

 Prefix_Example_Plugin::on_load();

/**
 * Example of initial class-based plugin load.
 */
class Prefix_Example_Plugin {

    /**
     * Hooks init (nothing else) and calls things that need to run right away.
     */
    static function on_load() {

        // if needed kill switch goes here (if disable constant defined then return)

        add_action( 'init', array( __CLASS__, 'init' ) );
    }

    /**
     * Further hooks setup, loading files, etc.
     *
     * Note that for hooked methods name equals hook (when possible).
     */
    static function init(  ) {


    }
}
 

Note:

• ha definitoilpostoper le cose che devonoessereeseguiteimmediatamente
• disabilitare/ignorare lemodifiche èfacile (sgancia unmetodo init)
• Non credo di avermai usato/necessario un oggetto della classeplugin - richiede ditenernetraccia,ecc; questo è davvero uno spazio deinomifalsoper scopo,non OOP (lamaggiorparte delle volte)

Disclaimer Non uso ancoragli unittest ( cosìtante cose sumyplate )e ho sentito cheper loro staticopuòesseremenopreferibile. Fai latua ricerca su questo se haibisogno ditestarlo.

I use following structure:

Prefix_Example_Plugin::on_load();

/**
 * Example of initial class-based plugin load.
 */
class Prefix_Example_Plugin {

    /**
     * Hooks init (nothing else) and calls things that need to run right away.
     */
    static function on_load() {

        // if needed kill switch goes here (if disable constant defined then return)

        add_action( 'init', array( __CLASS__, 'init' ) );
    }

    /**
     * Further hooks setup, loading files, etc.
     *
     * Note that for hooked methods name equals hook (when possible).
     */
    static function init(  ) {


    }
}

Notes:

• has defined place for things that need to run right away
• disable/override for tweaks is easy (unhook one init method)
• I don't think I ever used/needed object of plugin class - requires keeping track of it, etc; this is really fake namespacing by purpose, not OOP (most of the time)

Disclaimer I don't use unit tests yet (so many things on myplate) and I hear that static can be less preferable for them. Do your research on this if you need to unit test it.

Tutto dipende dallafunzionalità.

Una volta ho creato unplugin che registravagli script quando è stato chiamatoil costruttore,quindi ho dovuto agganciarlo all'hook wp_enqueue_scripts.

Se vuoi chiamarlo quandoiltuofile functions.php è caricato,potresti anche creare un'istanzatu stesso $class_instance = new ClassName(); cometumenzionato.

Potrestiprenderein considerazione la velocitàe l'utilizzo dellamemoria.Nonne sono a conoscenza,mapossoimmaginare chein alcuni casi ci sianogancinon chiamati.Creando latuaistanza su quell'hookpotresti risparmiare alcune risorse del server.

It all depends on functionality.

I once made a plugin that registered scripts when the constructor was called so I had to hook it at the wp_enqueue_scripts hook.

If you want to call it when your functions.php file is loaded, you might as well create an instance yourself $class_instance = new ClassName(); as you mentioned.

You might want to consider speed and memory usage. I'm not aware of any, but I can imagine there are uncalled hooks in some cases. By creating your instance at that hook you might save some server resources.

So che ha unpaio di anni,manelfrattempo php 5.3 supportametodi anonimi ,quindi hopensato a questo:

 add_action( 'plugins_loaded', function() { new My_Plugin(); } );
 

e in qualchemodomi piace dipiù.Posso usare costruttori regolarie non hobisogno di definire alcunmetodo "init" o "on_load" che rovini lemie strutture OOP.

I know this is a couple years old, but meanwhile php 5.3 supports anonymous methods, so I came up with this:

add_action( 'plugins_loaded', function() { new My_Plugin(); } );

and somehow I like it the most. I can use regular constructors and don't need to define any "init" or "on_load" methods that mess up my OOP structures.