web-dev-qa-db-fra.com

Dois-je utiliser spl_autoload_register () dans mon plugin?

Quand j'utilise spl_autoload_register dans mon plugin, je reçois:

    Fatal error: Uncaught exception 'LogicException' with message
   'Class wp_atom_server could not be loaded'

    wp-includes\pluggable-deprecated.php on line 182

J'ai lu un peu et j'ai trouvé diverses corrections. Un sur SO dit de ne pas utiliser spl_autoload_register avec WordPress.

Est-ce exact?

Je suis sûr que je peux trouver un "correctif" pour l'erreur, mais je ne suis pas sûr de vouloir le faire avec chaque release WP.

Si je n'utilise pas la fonction de chargement automatique, comment devrais-je charger mes classes? Voici ce qui casse maintenant:

spl_autoload_extensions(".php");
spl_autoload_register();

use MyPluginClasses\Student as MS;

$student = new MS\Student();

echo $student->sayHello();

En étudiant:

<?PHP
namespace MyPluginClasses\Student
{
    class Student{
        public function __Construct(){
            echo "Hello Johnny";
        }
        public function sayHello(){
            echo "Hello Johnny's Method";

        }

    }
}

Cette conception fonctionne très bien en dehors de WordPress.

phpplugin-developmenterrors
10
johnny

Je ne suis vraiment pas sûr que ce soit une bonne ou une mauvaise pratique de charger automatiquement les classes dans le plugin WP. Pour moi, je ne vois aucun effet secondaire à utiliser spl_autoload_register (performances non testées)

Donc, pour répondre à votre question, j'aimerais partager une classe de mon prochain plugin que j'utilise pour charger automatiquement les classes à partir d'un seul répertoire, sans aucun problème, et cela me convient jusqu'à présent.

/**
 * Annframe Class Autoloader.
 *
 * @package Annframe
 * @since 0.1.0
 */
class Annframe_Autoloader {
    /**
     * Singleton.
     *
     * @since 0.1.0
     * @var Annframe_Autoloader - Single instance.
     */
    private static $_instance = null;

    /**
     * Private Construct.
     *
     * @package Annframe
     * @since 0.1.0
     */
    private function __construct() {
        spl_autoload_register( array( $this, 'load' ) );
    }

    /**
     * Singleton method.
     *
     * @package Annframe
     * @since 0.1.0
     */
    public static function _instance() {
        if ( ! self::$_instance ) {
            self::$_instance = new Annframe_Autoloader();
        }
        return self::$_instance;
    }

    /**
     * Class Loader.
     *
     * @package Annframe
     * @since 0.1.0
     *
     * @param string $class_name - Class name to load.
     * @return null - Do not return anything.
     */
    public function load( $class_name ) {
        $file = str_replace( '_', '-', strtolower( $class_name ) );
        $file = 'class-' . $file;
        if ( is_readable( trailingslashit( YOUR_PLUGIN_PATH. '/classes-dir' ) . $file . '.php' ) ) {
            include_once trailingslashit( YOUR_PLUGIN_PATH. '/classes-dir' ) . $file . '.php';
        }
        return;
    }
}

Annframe_Autoloader::_instance();

Pour casser cette classe simple en parties, comme vous le voyez, j'utilise le modèle Singleton. Constructor est privé et instance() & $_instance appartient au modèle. Le constructeur a la fonction spl_autoload_register.

spl_autoload_register( array( $this, 'load' ) );

qui appelle la méthode load depuis la classe auto. Les deux premières lignes de cette méthode sont:

$file = str_replace( '_', '-', strtolower( $class_name ) );
$file = 'class-' . $file;

ce qui est assez simple. si vous suivezWPCS, il vous incite à suivre une convention de dénomination de classe préfixée par Word class puis par nom de classe. Bien sûr, tout tiret bas (_) est remplacé par (-) tiret.

donc un nom de fichier de classe WPSE_Post serait class-wpse-post.php

Abaissez les noms de classe avec strtolower et utilisez str_replace pour remplacer les traits de soulignement par des tirets. alors WPSE_Post devient maintenant wpse-post. en ajoutant enfin un préfixe class- sur la ligne suivante.

j'utilise is_readable dans une instruction conditionnelle échangeable avec file_exists. en supposant que YOUR_PLUGIN_PATH est le chemin de base du plugin et que classes-dir se trouve sous le répertoire principal du plugin contenant toutes vos classes nécessitant un chargement automatique.

include_once est utilisé pour charger le fichier en cours d'appel.

Utilisation:

il vous suffit d'inclure la classe de chargeur automatique ci-dessus dans le fichier de base de votre plugin

/**
 * Class autoloader.
 */
if ( ! class_exists( 'Annframe_Autoloader' ) ) {
    include_once YOUR_PLUGIN_PATH/class-annframe-autoloader.php';
}

puis appelez vos cours à la demande.

new XYX_Class();
Another_Class::instance(); // etc

Remarque: / Je n'utilise pas la méthode des espaces de noms dans ma solution, elle peut donc ne pas correspondre à vos besoins, mais elle est publiée ici dans l'espoir que quelqu'un bénéficiera au moins du chargement dynamique des classes.

1
Anwer AR