Devrais-je utiliser spl_autoload_register () dans mon plugin?

10

Lorsque 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 un SO 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 version de 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.

    
posée johnny 21.08.2014 - 21:46

2 réponses

1

Je ne suis vraiment pas sûr si c'est une bonne ou une mauvaise pratique de charger automatiquement les classes dans le plugin WP. Pour moi, je ne vois aucun effet secondaire à l’utilisation de 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 tout se passe bien pour moi 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 plusieurs parties, comme vous le voyez, j'utilise un modèle Singleton. Constructor est privé et instance() & $_instance appartient au modèle. Le constructeur a spl_autoload_register fonction.

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

qui appelle la méthode load à partir de self class. Les deux premières lignes de cette méthode sont:

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

qui est assez simple. Si vous suivez WPCS , il vous incite à suivre une convention de dénomination de classe précédée du mot classe , puis du nom de la classe. Bien sûr, tout tiret bas (_) est remplacé par un tiret (-).

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

Réduisez les noms de classe de casse avec strtolower et utilisez str_replace pour remplacer les traits de soulignement par des tirets. donc 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 est 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 classes à 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 qu’une personne tire au moins des avantages du chargement dynamique des classes.

    
réponse donnée Anwer AR 24.02.2018 - 23:58
-1
    function MyPluginClasses_autoloader( $class_name ) {
  if ( false !== strpos( $class_name, 'MyPluginClasses' ) ) {
    $parts = explode('\', $class_name);
    require_once RoothPath . DIRECTORY_SEPARATOR .'lib'.DIRECTORY_SEPARATOR.end($parts) . '.php';
  }
}
spl_autoload_register( 'MyPluginClasses_autoloader' );
use MyPluginClasses\Student as MS;
$student = new MS\Student();
echo $student->sayHello();
    
réponse donnée Meldin Xavier 22.02.2017 - 09:54

Lire d'autres questions sur les étiquettes