[PHP] __autoload() magische Methode und spl_autoload_register

Referenzlink:

1. Detaillierte Erläuterung des Unterschieds zwischen spl_autoload_register und autoload

2. Automatische Ladeklasse von php.net

Viele Entwickler erstellen beim Schreiben objektorientierter Anwendungen eine PHP-Quelldatei für jede Klassendefinition. Ein großes Ärgernis ist, dass am Anfang jedes Skripts eine lange Liste von Include-Dateien (eine Datei pro Klasse) geschrieben werden muss.

In PHP 5 ist dies nicht mehr notwendig. Sie können eine __autoload()-Funktion definieren, die automatisch aufgerufen wird, wenn versucht wird, eine Klasse zu verwenden, die noch nicht definiert wurde. Durch den Aufruf dieser Funktion hat die Skript-Engine eine letzte Chance, die erforderlichen Klassen zu laden, bevor PHP mit einem Fehler abstürzt.

Einfaches Importbeispiel:

Erstellen Sie zunächst eine neue Klassendatei MyClass.class.php:

<?php

class MyClass
{
    public function __construct()
    {
        echo "This is MyClass's construct";
    }

}

Erstellen Sie eine neue PHP-Datei mit einem beliebigen Namen im selben Verzeichnis:

<?php

function __autoload($cls){
    var_dump($cls);
    require './'.$cls.".class.php";
}

$o1 = new MyClass();
// 这里不会再执行__autoload了,因为这个类已经require进来了。只有在当前文件中找不到该类的时候才会调用__autoload函数
$o2 = new MyClass();

Hier wird der erforderliche Inhalt in __autoload() platziert. Wenn diese Funktion nicht definiert ist, wird ein schwerwiegender Fehler (Fatal) gemeldet, der darauf hinweist, dass die MyClass-Klasse nicht gefunden werden kann.

Und die Definition dieser magischen Methode wird Wenn ein neues Objekt gefunden wird und die Klassendefinition nicht im aktuellen Code gefunden werden kann (die beiden oben genannten Bedingungen sind erfüllt), wird die Funktion __autoload() an a übergeben Klassenparameter und führen Sie das Funktionscodesegment aus.

Also werden var_dump("MyClass"); und require './MyClass.class.php';

in der Funktion ausgeführt

Die Ergebnisse sind wie folgt:

string(7) "MyClass" This is MyClass's constructThis is MyClass's construct

Hier wird einmal der Inhalt von var_dump und zweimal der Inhalt von Konstruktor echo ausgegeben. Es kann bewiesen werden, dass die Funktion __autoload() nicht erneut aufgerufen wird, wenn „require“ eintrifft und eine neue MyClass erneut erstellt wird.

Autoload hat Nachteile: Es kann nicht wiederholt definiert werden (eine Eigenschaft der PHP-Sprache), was es unpraktisch und konfliktanfällig macht, wenn eine Teamentwicklung durchgeführt werden soll.

Es gibt also eine Autoload-Registrierungsfunktion spl_autoload_register nach PHP 5.1.2. Im Folgenden finden Sie einige Anweisungen für diese Funktion:

Registrieren Sie die Funktion in der SPL __autoload-Funktionswarteschlange. Aktivieren Sie Funktionen in dieser Warteschlange, sofern sie noch nicht aktiv sind.

Wenn Sie mehrere Autoload-Funktionen benötigen, spl_autoload_register() erfüllt diese Anforderungen. Es erstellt tatsächlich eine Warteschlange von Autoload-Funktionen und führt sie einzeln in der Reihenfolge aus, in der sie definiert sind. Im Gegensatz dazu kann __autoload() nur einmal definiert werden.

Nach der Einführung von Namespaces in PHP 5.3 haben die Parameter dieser Funktion verschiedene Formen:

spl_autoload_register('my_autoloader');    // my_autoloader是一个函数名

spl_autoload_register(array('Loader', 'loadClass'));  // 表示类内的静态方法，Loader::loadClass

// 或者，自 PHP 5.3.0 起可以使用一个匿名函数
spl_autoload_register(function ($class) {
    include 'classes/' . $class . '.class.php';
});

spl_autoload_register(__NAMESPACE__ .'\Foo::test'); // 自 PHP 5.3.0 起，可以使用命名空间的形式

Diese Funktion muss nur vor dem neuen Objekt aufgerufen werden.

Das Folgende ist ein Beispiel (Testen der oben genannten 4 Formen):

<?php

// namespace Atl;   // 加了这句话报错了!

function my_autoloader($cls){
    echo "<br/>$cls - my_autoloader <br/>";
    require_once './MyClass1.class.php';
}

class Loader{

    public static function loadClass($cls){
        echo "<br/>$cls - Loader::loadClass <br/>";
        require_once './MyClass2.class.php';
    }

    public static function nspClass($cls){
        echo "<br/>$cls - Loader::nspClass <br/>";
        require_once './MyClass3.class.php';
    }

}

spl_autoload_register('my_autoloader');

$o1 = new MyClass1();

spl_autoload_register(array('Loader', 'loadClass'));

$o2 = new MyClass2();

// 版本检测
if(version_compare(PHP_VERSION, '5.3.0', '<'))  die("以下的两个测试需要PHP 5.3及以上");

spl_autoload_register(__NAMESPACE__ .'\Loader::nspClass');
$o3 = new MyClass3();

spl_autoload_register(function ($cls) {
    echo "<br/>$cls - anonymous function <br/>";
    require_once './MyClass4.class.php';
});

$o4 = new MyClass4();

Die Ausgabeergebnisse lauten wie folgt (beachten Sie, dass die Suchreihenfolge mit der Registrierungsreihenfolge übereinstimmt):

MyClass1 - my_autoloader 
This is MyClass1's construct
MyClass2 - my_autoloader 

MyClass2 - Loader::loadClass 
This is MyClass2's construct
MyClass3 - my_autoloader 

MyClass3 - Loader::loadClass 

MyClass3 - Loader::nspClass 
This is MyClass3's construct
MyClass4 - my_autoloader 

MyClass4 - Loader::loadClass 

MyClass4 - Loader::nspClass 

MyClass4 - anonymous function 
This is MyClass4's construct