¿Debo usar spl_autoload_register () en mi complemento?

Question

¿Debo usar spl_autoload_register () en mi complemento?

#1 de Anwer AR (1 votos)
#2 de Meldin Xavier (-1 votos)

10

Cuando uso spl_autoload_register en mi complemento, obtengo:

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

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

Hice algunas lecturas y encontré varias correcciones. One on SO dijo no usar spl_autoload_register con WordPress.

¿Eso es correcto?

Estoy seguro de que puedo encontrar una "solución" para el error, pero no estoy seguro de querer hacerlo con cada versión de WP.

Si no uso la función de carga automática, ¿cómo debo cargar mis clases? Esto es lo que rompe ahora:

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

use MyPluginClasses\Student as MS;

$student = new MS\Student();

echo $student->sayHello();

En estudiante:

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

        }

    }
}

Este diseño funciona bien fuera de WordPress.

plugin-development php errors

pregunta johnny 21.08.2014 - 21:46

2 respuestas

Lea otras preguntas en las etiquetas plugin-development php errors

CSS no se actualiza en el navegador cuando lo cambio ¿Por qué las actualizaciones simples de "_edit_lock" de wp_postmeta son tan lentas?

score 1 · Answer 1

Realmente no estoy seguro de si es una buena o mala práctica cargar automáticamente las clases en el complemento WP. Para mí, no veo efectos secundarios por el uso de spl_autoload_register (rendimiento no probado)

Entonces, para responder a su pregunta, me gustaría compartir una clase de mi próximo complemento que estoy usando para cargar automáticamente las clases desde un solo directorio sin ningún problema y hasta ahora me va bien.

/**
 * 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();

Para dividir esta clase simple en partes cuando vea que estoy usando el patrón Singleton. Constructor es privado y instance() & $_instance pertenece al patrón. El constructor tiene la función spl_autoload_register .

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

que está llamando al método load de self class. Las dos primeras líneas de este método son:

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

que es bastante recto. si sigue WPCS , le recomendamos que siga una convención de nomenclatura de clase con el prefijo palabra clase y luego el nombre de la clase. por supuesto, cualquier subrayado (_) se reemplaza con (-) guión.

por lo que un nombre de archivo de la clase WPSE_Post sería class-wpse-post.php

Baje los nombres de las clases de carcasas con strtolower y use str_replace para reemplazar los guiones bajos con guiones. entonces WPSE_Post ahora se convierte en wpse-post . finalmente agregando un prefijo class- en la siguiente línea.

Estoy usando is_readable en una declaración condicional que es intercambiable con file_exists . asumiendo que YOUR_PLUGIN_PATH es la ruta base del complemento y classes-dir se encuentra en el directorio del complemento principal que contiene todas las clases que necesitan carga automática.

include_once se usa para cargar el archivo real en la llamada.

Uso :

solo necesita incluir la clase de cargador automático anterior en el archivo base de su complemento

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

y luego llame a sus clases a pedido.

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

Nota: No estoy usando el método de espacio de nombres en mi solución, por lo que puede o no ajustarse a sus necesidades, pero publicado aquí con la esperanza de que al menos alguien obtenga los beneficios de cargar clases de forma dinámica.

score -1 · Answer 2

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