La meilleure façon D'accéder aux Classes Autoload en PHP

s'il vous Plaît, si vous avez besoin d'auto-chargement des classes - utiliser les espaces de noms et les noms de classe conventions avec autoload SPL, il permettra d'économiser votre temps pour le refactoring. Et bien sûr, vous aurez besoin d'instancier chaque classe comme un objet. Remercier.

Comme dans ce fil: PHP Chargement automatique dans les espaces de noms

mais si vous voulez une solution complexe, s'il vous plaît jeter un oeil à Symfony autoload classe: https://github.com/symfony/ClassLoader/blob/master/ClassLoader.php

Ou comme ça (je l'ai fait dans un de mes projets):

<?
spl_autoload_register(function($className)
{
    $namespace=str_replace("\","/",__NAMESPACE__);
    $className=str_replace("\","/",$className);
    $class=CORE_PATH."/classes/".(empty($namespace)?"":$namespace."/")."{$className}.class.php";
    include_once($class);
});
?>

et puis vous pouvez instancier ta classe comme ceci:

<?
$example=new NS1\NS2\ExampleClass($exampleConstructParam);
?>

et c'est votre classe (trouvée dans /NS1/NS2/ExampleClass.classe.php):

<?
namespace NS1\NS2
{
    class Symbols extends \DB\Table
    {
        public function __construct($param)
        {
            echo "hello!";
        }
    }
}
?>

si vous avez un accès à la ligne de commande, vous pouvez l'essayer avec composer dans la section classMap avec quelque chose comme ceci:

{
    "autoload": {
        "classmap": ["yourpath/", "anotherpath/"]
    }
}

alors vous avez un plugin wordpress pour activer composer dans le clip wordpress:http://wordpress.org/plugins/composer/

function __autoload($class_name) {
   $class_name = strtolower($class_name);
   $path       = "{$class_name}.php";
   if (file_exists($path)) {
       require_once($path);
   } else {
       die("The file {$class_name}.php could not be found!");
   }
}

mise à jour: __autoload() est obsolète depuis PHP 7.2

http://php.net/manual/de/function.spl-autoload-register.php

spl_autoload_register(function ($class) {
    @require_once('lib/type/' . $class . '.php');   
    @require_once('lib/size/' . $class . '.php');
});

j'ai ici un exemple que j'utilise pour l'autoloading et l'initilization.

Fondamentalement une meilleure version de spl_autoload_register puisqu'il ne cherche à requérir le fichier de classe que lorsque vous initialisez la classe.

Ici, il reçoit automatiquement chaque fichier à l'intérieur de votre dossier de classe, nécessite les fichiers et l'initialise. Tout ce que vous avez à faire, est de nommer la classe comme le fichier.

index.php

<?php
require_once __DIR__ . '/app/autoload.php';

$loader = new Loader(false);

User::dump(['hello' => 'test']);

autoload.php

<?php
class Loader 
{

    public static $library;

    protected static $classPath = __DIR__ . "/classes/";

    protected static $interfacePath = __DIR__ . "/classes/interfaces/";

    public function __construct($requireInterface = true) 
    {
        if(!isset(static::$library)) {
            // Get all files inside the class folder
            foreach(array_map('basename', glob(static::$classPath . "*.php", GLOB_BRACE)) as $classExt) {
                // Make sure the class is not already declared
                if(!in_array($classExt, get_declared_classes())) {
                    // Get rid of php extension easily without pathinfo
                    $classNoExt = substr($classExt, 0, -4); 
                    $file = static::$path . $classExt;

                    if($requireInterface) {
                        // Get interface file
                        $interface = static::$interfacePath . $classExt;
                        // Check if interface file exists
                        if(!file_exists($interface)) {
                            // Throw exception
                            die("Unable to load interface file: " . $interface);
                        }

                        // Require interface
                        require_once $interface;
                        //Check if interface is set
                        if(!interface_exists("Interface" . $classNoExt)) {
                            // Throw exception
                            die("Unable to find interface: " . $interface);
                        }
                    }

                    // Require class
                    require_once $file;
                    // Check if class file exists
                    if(class_exists($classNoExt)) {
                        // Set class        // class.container.php
                        static::$library[$classNoExt] = new $classNoExt();
                    } else {
                        // Throw error
                        die("Unable to load class: " . $classNoExt);
                    }

                }
            }
        }
    }

    /*public function get($class) 
    {
        return (in_array($class, get_declared_classes()) ? static::$library[$class] : die("Class <b>{$class}</b> doesn't exist."));
    }*/
}

vous pouvez facilement gérer avec un peu de codage, pour exiger des classes dans différents dossiers aussi.

espérons que cela puisse vous être utile.