Der beste Weg, um eine Klasse in einem WP-Plugin zu initiieren?

Gute Frage,esgibt eine Reihe von Ansätzen undes hängt davon ab,was Sieerreichenmöchten.

macheich oft;

 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...
}
 

Ein ausführlicheres Beispiel,das sich auseinigen jüngsten Diskussionen zu diesem Themaim Chatraumergibt,finden Sie unter "noreferrer"> dieses Wesentliche von WPSE-Mitglied toscho .

Der Ansatzfür leere Konstruktoren.

Hieristein Auszug der Vor- und Nachteile aus dem obigen Kern,der den leeren Konstruktoransatz vollständig veranschaulicht.

• Vorteile:

  • Unit-Tests könnenneue Instanzenerstellen,ohne Hooks zu aktivieren automatisch. Kein Singleton.

  • Keineglobale Variableerforderlich.

  • Wermit der Plugin-Instanz arbeitenmöchte,kanneinfach anrufen T5_Plugin_Class_Demo ::get_instance ().

  • Einfach zu deaktivieren.

  • Immernochechtes OOP: Keine Arbeitsmethoden sind statisch.

Nachteil:

• Vielleicht schwerer zu lesen?

Der Nachteilistmeiner Meinungnachein schwacher,weshalbesmein bevorzugter Ansatz seinmüsste,jedochnicht dereinzige,denich verwende. Tatsächlich werden sich zweifelloseinige andere Schwergewichtein Kürzemit diesem Themabefassen,daeseinige gute Meinungen zu diesem Themagibt,diegeäußert werden sollten.

_{Hinweis: Ichmuss das Hauptbeispiel von toscho finden,das 3 oder 4 durchlaufen hat Vergleiche,wieeine Klasseinnerhalbeines Pluginsinstanziiert werden kann,wobei die Vor- und Nachteile dereinzelnen Klassen untersucht wurden. Der obige Link war derbevorzugte Weg,dies zutun. Die anderen Beispielebieten jedocheinen guten Kontrast zu diesem Thema. Hoffentlich hat toscho dasnochin der Datei.}

Hinweis: Die WPSE Antwort auf dieses Themamit relevanten Beispielen und Vergleichen. Auch diebeste Lösung zum Beispieleine Klassein 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!
    }
}

Ich verwendefolgende Struktur:

 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(  ) {


    }
}
 

Hinweise:

• hat Platzfür Dinge definiert,die sofort ausgeführt werdenmüssen
• Das Deaktivieren/Überschreibenfür Optimierungenisteinfach (eine init -Methode aushängen)
• Ichglaubenicht,dassichjemalsein Objekt der Plugin-Klasse verwendet/gebraucht habe -eserfordert,den Überblick zubehalten usw.; Diesist wirklichein gefälschter Namespace,nicht OOP (meistens)

Haftungsausschluss Ich verwendenoch keine Komponententests ( so viele Dinge aufmyplate ) und höre,dass statische Aufladungfür sie weniger vorzuziehenist. Machen Sie Ihre Recherchen dazu,wenn Sieeseinem Unit-Test unterziehenmüssen.

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.

Alles hängt von der Funktionalität ab.

Ich habeeinmalein Pluginerstellt,das Skripte registriert,als der Konstruktor aufgerufen wurde,alsomussteiches am Hook wp_enqueue_scriptseinbinden.

Wenn Sieesbeim Laden Ihrer Datei functions.php aufrufenmöchten,können Sie auch selbsteine Instanzerstellen. $class_instance = new ClassName(); wie Sieerwähnt.

Möglicherweisemöchten Sie die Geschwindigkeit und die Speichernutzungberücksichtigen.Mir sind keinebekannt,aberich kannmir vorstellen,dassesin einigen Fällen unaufgeforderte Hakengibt.Wenn Sie Ihre Instanz an diesem Hookerstellen,können Siemöglicherweiseeinige Serverressourcen sparen.

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.

Ich weiß,dass diesein paar Jahre altist,abermittlerweile unterstützt PHP 5.3 anonyme Methoden ,also habeichmir Folgendes ausgedacht:

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

undirgendwiegefälltesmir ambesten.Ich kann reguläre Konstruktoren verwenden undmuss keine "init" - oder "on_load" -Methoden definieren,diemeine OOP-Strukturen durcheinanderbringen.

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.