PHP
Caricamento automatico del primer

Sintassi

• richiedere
• spl_autoload_require

Osservazioni

Definizione della classe inline, nessun caricamento richiesto

// zoo.php
class Animal {
    public function eats($food) {
        echo "Yum, $food!";
    }
}

$animal = new Animal();
$animal->eats('meat');

PHP sa cos'è Animal prima di eseguire new Animal , perché PHP legge i file sorgente dall'alto verso il basso. Ma se volessimo creare nuovi animali in molti posti, non solo nel file sorgente in cui è definito? Per fare ciò, dobbiamo caricare la definizione della classe.

Caricamento manuale della classe con richiesta

// Animal.php
class Animal {
    public function eats($food) {
         echo "Yum, $food!";
    }
}

// zoo.php
require 'Animal.php';
$animal = new Animal;
$animal->eats('slop');

// aquarium.php
require 'Animal.php';
$animal = new Animal;
$animal->eats('shrimp');

Qui abbiamo tre file. Un file ("Animal.php") definisce la classe. Questo file non ha effetti collaterali oltre a definire la classe e mantiene tutte le informazioni su un "animale" in un unico posto. È facilmente controllabile in versione. È facilmente riutilizzabile.

Due file utilizzano il file "Animal.php" require manualmente il file. Ancora una volta, PHP legge i file sorgente dall'alto verso il basso, quindi la richiesta va e trova il file "Animal.php" e rende disponibile la definizione della classe Animal prima di chiamare new Animal .

Ora immaginiamo di avere dozzine o centinaia di casi in cui volevamo eseguire un new Animal . Ciò richiederebbe (molti giochi di parole) molti, molti require affermazioni che sono molto noiose da codificare.

Il caricamento automatico sostituisce il caricamento manuale delle definizioni di classe

// autoload.php
spl_autoload_register(function ($class) {
    require_once "$class.php";
});

// Animal.php
class Animal {
    public function eats($food) {
         echo "Yum, $food!";
    }
}

// zoo.php
require 'autoload.php';
$animal = new Animal;
$animal->eats('slop');

// aquarium.php
require 'autoload.php';
$animal = new Animal;
$animal->eats('shrimp');

Confronta questo con gli altri esempi. Nota come require "Animal.php" stato sostituito con require "autoload.php" . Stiamo ancora includendo un file esterno in fase di esecuzione, ma piuttosto che includere una specifica definizione di classe includiamo la logica che può includere qualsiasi classe. È un livello di indirezione che facilita il nostro sviluppo. Invece di scrivere uno require per ogni classe di cui abbiamo bisogno, scriviamo uno require per tutte le classi. Possiamo sostituire N require con 1 require .

La magia accade con spl_autoload_register . Questa funzione PHP richiede una chiusura e aggiunge la chiusura a una coda di chiusure. Quando PHP incontra una classe per la quale non ha una definizione, PHP consegna il nome della classe a ogni chiusura nella coda. Se la classe esiste dopo aver chiamato una chiusura, PHP ritorna alla sua attività precedente. Se la classe non riesce a esistere dopo aver provato l'intera coda, PHP si blocca con "Class" Whatever "not found."

Autoloading come parte di una soluzione quadro

// autoload.php
spl_autoload_register(function ($class) {
    require_once "$class.php";
});

// Animal.php
class Animal {
    public function eats($food) {
         echo "Yum, $food!";
    }
}

// Ruminant.php
class Ruminant extends Animal {
    public function eats($food) {
        if ('grass' === $food) {
            parent::eats($food);
        } else {
            echo "Yuck, $food!";
        }
    }
}

// Cow.php
class Cow extends Ruminant {
}

// pasture.php
require 'autoload.php';
$animal = new Cow;
$animal->eats('grass');

Grazie al nostro caricatore automatico generico, abbiamo accesso a qualsiasi classe che segue la nostra convenzione di denominazione del caricatore automatico. In questo esempio, la nostra convenzione è semplice: la classe desiderata deve avere un file nella stessa directory chiamata per la classe e che termina con ".php". Si noti che il nome della classe corrisponde esattamente al nome del file.

Senza l'autoloading, dovremmo require manualmente le classi base. Se costruissimo un intero zoo di animali avremmo migliaia di istruzioni che potrebbero essere più facilmente sostituite con un singolo caricatore automatico.

In ultima analisi, l'autoloading di PHP è un meccanismo che ti aiuta a scrivere meno codice meccanico in modo da poterti concentrare sulla risoluzione dei problemi aziendali. Tutto quello che devi fare è definire una strategia che associ il nome della classe al nome del file . Puoi lanciare la tua strategia di autoloading, come fatto qui. Oppure, puoi usare uno qualsiasi di quelli standard che la comunità PHP ha adottato: PSR-0 o PSR-4 . Oppure, puoi usare il compositore per definire e gestire genericamente queste dipendenze.

Caricamento automatico con Composer

Il compositore genera un file vendor/autoload.php .

Si potrebbe semplicemente includere questo file e si otterrà il caricamento automatico gratuitamente.

require __DIR__ . '/vendor/autoload.php';

Ciò rende molto semplice il lavoro con dipendenze di terze parti.

È inoltre possibile aggiungere il proprio codice al caricatore automatico aggiungendo una sezione di caricamento automatico a composer.json .

{
    "autoload": {
        "psr-4": {"YourApplicationNamespace\\": "src/"}
    }
}

In questa sezione definisci i mapping autoload. In questo esempio è una mappatura PSR-4 di uno spazio dei nomi in una directory: la directory /src risiede nella cartella principale dei progetti, allo stesso livello della directory /vendor . Un esempio di nome file potrebbe essere src/Foo.php contenente una classe YourApplicationNamespace\Foo .

Importante: Dopo aver aggiunto nuove voci alla sezione di caricamento automatico, è necessario rieseguire il comando dump-autoload per rigenerare e aggiornare il file vendor/autoload.php con le nuove informazioni.

Oltre al caricamento automatico della PSR-4 , Composer supporta anche PSR-0 , classmap e autoloading dei files . Vedere il riferimento del caricamento automatico per ulteriori informazioni.

Quando /vendor/autoload.php file /vendor/autoload.php , verrà restituita un'istanza del /vendor/autoload.php automatico Composer. È possibile memorizzare il valore restituito della chiamata di inclusione in una variabile e aggiungere altri spazi dei nomi. Questo può essere utile per il caricamento automatico delle classi in una suite di test, ad esempio.

$loader = require __DIR__ . '/vendor/autoload.php';
$loader->add('Application\\Test\\', __DIR__);