La scorsa settimana ho tenuto la mia presentazione al WordCamp Atlanta su Namespaces e Autoloading. (il titolo completo era Namespaces, Autoloading e Improving Plugin Architecture ma è un boccone, vero?)

A causa della natura del discorso, ho scelto di scrivere un post per accompagnare il post, condividere le diapositive e condividere un plug-in di esempio GitHub per supportare il discorso.

Quindi, se eri presente, grazie (!) ed ecco il post, l’avevo promesso. E per quelli di voi che non hanno partecipato, spero che questo post aiuti ancora a dimostrare i concetti e gli argomenti che ho discusso al WordCamp.

Spazi dei nomi e caricamento automatico

Prima di parlare di namespace e caricamento automatico in WordPress, il motivo per cui voglio parlarne è perché può avere un impatto diretto sulla qualità del tuo codice e può farlo per mesi e anni a venire.

Dopotutto, molti di noi sviluppatori non fanno già la domanda:

Come possiamo rendere il nostro codice migliore di quello che già è?

E molti di noi sono abbastanza intelligenti da sapere ciò che non sappiamo. Quindi ci troviamo di fronte a lavorare entro i vincoli che ci vengono dati.

A volte abbiamo tempo per indagare sui modi per farlo; altre volte, lavoriamo con la conoscenza che abbiamo. E non c’è niente di sbagliato in questo.

Ma poiché sappiamo ciò che non sappiamo, sappiamo che c’è il potenziale per di più.

Primo, il tuo codice

Quando si tratta di parlare di argomenti come gli spazi dei nomi e il caricamento automatico nel contesto di WordPress, penso che incontriamo spesso risposte contrastanti.

Dopotutto, potremmo parlare di cose come The Theme Customizer o l’ API REST o qualcosa di più divertente.

Voglio dire, "spazi dei nomi e caricamento automatico" semplicemente non suona eccitante o all’avanguardia rispetto alle nuove funzionalità e tecnologie disponibili, giusto?

Ma no, non sono proprio noiosi. E attraverso questo post e la presentazione e il codice sorgente di accompagnamento, ti mostrerò perché e come non lo sono.

Non sono noiosi

Penso sia giusto dire che gli sviluppatori – almeno una parte di noi o una parte di loro a seconda di come ti vedi – sono famosi per litigare sugli aspetti della programmazione.

"Comunque conversazione noiosa."

In effetti, non è affatto raro sentire qualcuno discutere sul modo migliore per inizializzare e scrivere un ciclo for che sia il più performante possibile quando si esegue l’iterazione su un piccolo set di database nonostante il fatto che abbiamo processori quad-core e 16 GB di RAM nelle nostre macchine desktop.

Quindi, se ci preoccupiamo così tanto di qualcosa di così piccolo, sicuramente ci preoccupiamo del quadro più ampio. Cose come:

Codice migliorato
Migliore organizzazione
Maggiore manutenibilità
Debug più semplice
Fare più soldi (beh, forse).

E gli spazi dei nomi e il caricamento automatico possono portare direttamente a tutto quanto sopra (beh, non posso parlare di soldi, ma ha del potenziale).

Se dovessi riassumere gli spazi dei nomi dei ruoli e il luogo di caricamento automatico in tutto quanto sopra, direi che:

Gli spazi dei nomi e il caricamento automatico portano a un codice migliorato attraverso una migliore organizzazione, compartimentazione o modularizzazione e relazioni più strette attraverso i loro concetti.

Inoltre, ciò aumenta la manutenibilità perché il codice è organizzato in pacchetti che possono portare a un debug più semplice man mano che il prodotto cresce.

Tutto ciò può comportare un risparmio di tempo o un migliore utilizzo del tempo, che, a seconda del modello di business, può influire sui profitti.

Ma questo ancora non descrive nessuna di queste cose. Ma sicuramente, a questo punto, suonano più interessanti di quando furono introdotti per la prima volta.

Allora, cosa sono?

Prima di entrare nelle definizioni di ciascuno e dei ruoli che svolgono, diamo un’occhiata a come la mancanza di spazi dei nomi e il caricamento automatico in WordPress ha avuto un impatto negativo sulla tua esperienza quando utilizzi temi, plug-in, componenti aggiuntivi o qualsiasi altra cosa tu abbia.

Quindi torniamo indietro per un momento e osserviamo ciascuno di essi individualmente.

Spazi dei nomi

Immagina di aver ereditato un progetto e di iniziare a lavorarci. Supponiamo che sia un plugin per WordPress.

Tu lo installi; vai ad attivarlo e poi ti viene dato almeno uno di questi:

Forse vedi quel brutto messaggio di organizzazione nella parte superiore della finestra del browser che mostra una traccia dello stack.
Forse vedi un messaggio che parla di qualche conflitto con un altro pacchetto esistente.
O forse quando provi ad attivare un plugin, la pagina si aggiorna ma il plugin non si attiva.
Forse hai anche eseguito un controllo del codice e vedi i controlli class_exists in tutta la base di codice.

Qualsiasi o tutto quanto sopra può contribuire a problemi, ovviamente, con i progetti WordPress. Ma gli spazi dei nomi possono davvero risolvere molto di questo la maggior parte delle volte.

Cioè, il motivo per cui stai riscontrando questi problemi è che il codice con cui stai lavorando fa tutto parte dello spazio dei nomi globale (rispetto al suo spazio dei nomi) e PHP non piace quando ci sono classi e moduli con lo stesso nome .

Ma quando lo spazio dei nomi qualcosa, gli dai la sua area relativa a se stesso che funzionerà comunque bene con altri componenti anche se hanno lo stesso nome di classe.

Caricatori automatici

Per quanto riguarda i caricatori automatici, in qualche modo sono un po’ meno complicati. Per prima cosa, pensa al codice che scrivi o al codice con cui lavori, specialmente nel contesto dei plugin di WordPress, e poi pensa a quante volte scrivi o vedi quanto segue:

includere
includere_una volta
richiedere
richiedono_una volta

E a volte li vedi nella parte superiore del file che avvia il plug-in, ea volte li vedi sparsi nella codebase.

Se sono tutti contenuti in un unico file, non è così male perché almeno sai dove si trovano. Ma se sono disseminati dappertutto, non hai idea di dove venga introdotta una dipendenza nel sistema.

Il caricamento automatico può risolvere tutto questo caricando le dipendenze quando necessario (e per coloro che sono interessati, il caricamento automatico è più veloce dell’inclusione manuale).

Spazi dei nomi

Detto questo, siamo pronti a parlare sia degli spazi dei nomi che del caricamento automatico. Ma gli spazi dei nomi sono il concetto fondamentale, quindi inizieremo da lì.

Ma dopo tutto quanto sopra, puoi vedere i vantaggi del loro utilizzo. Forse sono anche divertenti, giusto? Forse?

Indipendentemente da ciò, abbiamo bisogno di una definizione su cui possiamo lavorare quando ne parleremo per il resto dell’articolo.

Il manuale PHP fornisce la seguente definizione :

I namespace sono progettati per risolvere due problemi che gli autori di librerie e applicazioni incontrano durante la creazione di elementi di codice riutilizzabili come classi o funzioni…

E non è male, ma è piuttosto lungo, tecnico e potrebbe essere un po’ troppo per coloro che hanno appena iniziato. Quindi semplifichiamolo un po’ per questo articolo:

Un po’ meglio, forse?

Un modo per raggruppare classi e interfacce correlate con uno scopo simile.

Non parlerò di interfacce in questo discorso; tuttavia, so che ci sono sviluppatori orientati agli oggetti di livello intermedio che li usano, quindi volevo assicurarmi di menzionarli almeno.

Un esempio pratico

Non mi piacciono gli esempi di programmazione che non forniscono applicazioni pratiche o reali. Spesso ci vengono forniti esempi di cose che non codificheremmo mai.

Quante volte hai letto un articolo orientato agli oggetti e fornisce un esempio di una classe di animali o di una classe di auto? Non programmiamo un’auto.

È molto più probabile che lavoriamo con i file. Quindi daremo un’occhiata a un insieme di classi responsabili della lettura e della scrittura di file. Vale a dire, siamo stati bravi programmatori orientati agli oggetti e abbiamo separato le nostre classi in base alle responsabilità che mantengono.

E sì, potresti avere interfacce; tuttavia, esulano dallo scopo di questo articolo, quindi non verranno inclusi.

Quindi per il nostro FileReader, forse le basi della classe sono queste:

Una classe per leggere i file.

Si noti che la funzione accetta il nome del file che dovrebbe aprire per leggere. Il controllo degli errori, come legge il file e cosa restituisce è tutto lasciato all’implementazione della classe.

E per FileWriter, abbiamo qualcosa del genere:

Una classe per scrivere file.

Questa classe, d’altra parte, accetta le informazioni che scriverà su disco e il nome del file su cui dovrebbe essere scritta.

Ancora una volta, come nell’esempio sopra, non include il controllo degli errori, la scrittura di una risorsa, la chiusura delle risorse e così via.

Ma non si tratta di lavorare con i file. Invece, si tratta di mostrare come assegnare uno spazio ai nomi del codice e questi due esempi sono pensati per essere fondamentali per questo.

Note sui namespace

C’è un avvertimento su ciò che vedi nelle immagini del codice di esempio sopra: queste classi non hanno lo spazio dei nomi. Vale a dire, risiedono nello spazio dei nomi globale che li lascia maturi per conflitti con altre classi.

Guardala in questo modo: immagina di impacchettare questo codice in un plug-in per qualcun altro, e quindi caricare un altro plug-in che ha anche come FileReader o FileWriter. Dal momento che farà tutto parte dello stesso spazio dei nomi globale, dovrai affrontare un conflitto.

Ricorda:

Gli spazi dei nomi sono un modo per raggruppare classi e interfacce correlate con uno scopo simile.

Quindi prendiamo le classi e namespace il codice.

In primo luogo, forniremo uno spazio dei nomi di primo livello sotto il quale risiederanno queste classi e tutte le altre classi; quindi forniremo un sottopacchetto (o sottospazio dei nomi o sottospazio come li ho sentiti chiamare) in cui risiederanno queste classi di file.

Ciò significa che il nostro FileReader ora apparirà così:

Una classe con spazio dei nomi per la lettura di file.

E il nostro FileWriter ora apparirà così:

Una classe con spazio dei nomi per la scrittura di file.

Innanzitutto, puoi vedere che l’uso degli spazi dei nomi è facile: usi semplicemente la parola chiave namespace e quindi dichiara lo spazio dei nomi (che potrebbe essere altrettanto facilmente WCATL) in alto con i sottopacchetti seguenti.

Ma questo porta ad altri argomenti, vale a dire l’organizzazione dei file, l’istanziazione e il caricamento automatico, che vale la pena affrontare.

Sull’organizzazione dei file

A questo punto, è importante avere una parola sull’organizzazione dei file. A seconda della persona con cui parli, scoprirai che alcuni sviluppatori – sorpresa, sorpresa – hanno un’opinione su come dovrebbero essere organizzati i file (e io non sono diverso).

Da un lato, non devi affatto organizzare i tuoi file. In effetti, puoi trascinare ogni singola cosa nella directory principale del tuo progetto, nello spazio dei nomi le informazioni ed essere pronto per partire.

File non organizzati

Il set di file sopra è per un piccolo progetto, quindi puoi immaginare quanti file esisterebbero per un grande progetto.

Ma quando hai i tuoi file organizzati in questo modo, può rendere un po’ difficile scrivere un caricatore automatico perché un caricatore automatico deve sapere dove trovare i file in base al loro spazio dei nomi.

È qui che entrano in gioco i termini “organizzazione logica" e “organizzazione virtuale”.

L’organizzazione logica si riferisce al modo in cui i file sono organizzati su disco, come quello che vedi sopra. Si trovano logicamente nella directory principale.
Organizzazione virtuale si riferisce al modo in cui i file sono organizzati per quanto riguarda i loro spazi dei nomi. Ciò significa che ci sono directory e sottodirectory che mappano agli spazi dei nomi, ai sottopacchetti e così via.

Quindi, se dovessi prendere il progetto sopra, i suoi spazi dei nomi, i suoi sottopacchetti e quindi organizzarli sia logicamente che virtualmente, sembrerebbe qualcosa del genere:

Spazi dei nomi e caricamento automatico: file organizzati

E anche se puoi scegliere di organizzare i tuoi file come preferisci, sono un fan di assicurarmi che ci sia parità tra i due. Cioè, mi piace che la mia organizzazione logica e virtuale corrisponda come vedi nell’immagine sopra.

Mentre passo alla discussione sul caricamento automatico, vedrai perché questo è importante.

Note sui namespace

Cosa succede, però, quando abbiamo bisogno di istanziare classi con namespace? Quando le classi non hanno uno spazio dei nomi, è facile usare la parola chiave ‘new’.

Istanza senza uno spazio dei nomi.

Ma dobbiamo istanziare una classe namespace, dobbiamo fare un ulteriore passo avanti e usare il nome completo:

Spazi dei nomi e caricamento automatico: istanza con uno spazio dei nomi.

Ma questo diventa ingombrante, vero? Questo particolare esempio non è così male, ma immagina se stessi lavorando su qualcosa con più sottopacchetti. Diventerebbe piuttosto ingombrante, vero?

A tal fine, possiamo utilizzare ciò che viene chiamato aliasing. È anche semplice. Possiamo definire l’uso della parola chiave ‘use’ nella parte superiore del file per fare riferimento allo spazio dei nomi a cui vogliamo alias e quindi utilizzare l’ultimo sottopacchetto come parte dell’alias per istanziare la nostra classe.

Suona confuso, vero? Forse vederlo in azione aiuterà:

Alias di namespace.

E questo è tutto ciò che c’è da fare. Sì, puoi fare un ulteriore passo avanti con l’aliasing, ma questo è quanto lo sto portando nel contesto di questo articolo.

Caricamento automatico

A questo punto, abbiamo gettato le basi per il caricamento automatico. Sì, lavorare con gli spazi dei nomi può essere molto faticoso se non ci sei abituato; tuttavia, è importante capire perché il caricamento automatico richiede un po’ di lavoro che potrebbe essere inaspettato se non ti è mai stato presentato prima.

Indipendentemente da ciò, le cose più importanti da ricordare riguardo agli spazi dei nomi, a questo punto, sono:

Gli spazi dei nomi sono un modo per raggruppare classi e interfacce correlate con uno scopo simile.
Crea parità attraverso i tuoi file e spazi dei nomi assicurandomi che la tua organizzazione logica e virtuale sia la stessa.

E ora è il momento di dare un’occhiata al caricamento automatico.

Note sul caricamento automatico

Per prima cosa, diamo un’occhiata alla definizione di caricamento automatico fornita dal manuale PHP :

La funzione spl_autoload_register() registra un numero qualsiasi di caricatori automatici, consentendo il caricamento automatico di classi e interfacce se non sono attualmente definite. Registrando i caricatori automatici, a PHP viene data un’ultima possibilità di caricare la classe o l’interfaccia prima che fallisca con un errore.

Non è male. È lungo, però. Quindi, proprio come abbiamo fatto con gli spazi dei nomi, usiamo una definizione più breve per questo articolo:

Un modo per caricare automaticamente interfacce e classi senza utilizzare istruzioni include e require.

Ancora una volta, non utilizzeremo le interfacce in questo articolo, sebbene alcuni sviluppatori lo facciano. E questo fornirà la definizione di lavoro per il resto di questo articolo.

Un esempio pratico

Una volta che i file sono organizzati, assegnati allo spazio dei nomi e pronti per essere caricati, è il momento di farlo, giusto? Intendo:

i tuoi file sono organizzati,
sei pronto per caricarli

Quindi è ora di farlo automaticamente, giusto? Ma c’è un problema. L’intero "caricamento automatico" dei file richiede un po’ di lavoro.

Scrivere un caricatore automatico

Cioè, è automatico, ma richiede ancora un po’ più di lavoro da parte nostra. Prima di entrare in questi passaggi, è importante notare:

non è completamente automatizzato,
dobbiamo scriverlo.

Per quanto bello sarebbe avere il codice caricato automaticamente, dobbiamo leggere alcuni dati, analizzarli e quindi provare a caricare il file corretto.

Ma supponendo che tu lo scriva correttamente e il tuo spazio dei nomi e organizzi i tuoi file nello stesso modo per ogni progetto, puoi riutilizzare il tuo caricatore automatico. Cioè, lo scrivi una volta e puoi usarlo in altri progetti.

Passaggi per un caricatore automatico

Quando si scrive un caricatore automatico, ci sono solo alcuni passaggi da seguire. Il caricatore automatico deve essere in grado di rispondere ai seguenti file:

Dove sono i file?
Come si chiamano?
Il file esiste?

Se tutto quanto sopra è vero (o puoi rispondere "sì" a tutti loro), il caricatore automatico farà ciò che dovrebbe fare.

Tra poco daremo un’occhiata ad un po’ di codice, ma la prima cosa da notare è che usa una funzione chiamata spl_autoload_register.

SPL fa riferimento alla libreria PHP standard e la funzione accetta una funzione come argomento e quella funzione accetta il nome della classe che verrà istanziata. È più procedurale che orientato agli oggetti e ne parlerò momentaneamente, ma è importante tenerlo a mente mentre leggi questo codice.

Ecco la prima parte del codice. Spiegherò cosa sta facendo dopo il fatto:

Caricamento automatico, parte 1 – Trovare la classe

In questa parte del codice, la funzione riceve il nome completo della classe da istanziare (come "WCATLFileFileReader()").

Successivamente, separa tutte le parti del nome completo in parti. Il nome della classe è l’ultimo indice dell’array e scelgo di nominare i miei file come "class-filereader.php" in modo che la funzione crei una variabile, $class_file, che fa riferimento al nome del file.

Ma non abbiamo ancora finito. Dobbiamo ancora ottenere il nome completo (ovvero, dove si trova il file sul disco). Questo potrebbe assomigliare a questo:

Caricamento automatico, parte 2 – Ottenere il nome completo

A questo punto, prepariamo una variabile, $full_qualified_path, che farà riferimento alla directory di primo livello.

Successivamente, il codice scorre tutti gli indici dell’array e crea un percorso per il file di classe. Puoi immaginarlo come costruire una stringa come "wcatlfile" che poi combiniamo con $class_file.

Ciò significa che il percorso completo del file diventa "wcatlfileclass-filereader.php".

E infine, includiamo il file. Si noti che questo codice non sta verificando se il file esiste. Anche se lo consiglio, è stato tralasciato per motivi di lunghezza e perché, nel nostro esempio, sappiamo che il file esiste.

Se il file non esiste, sono disponibili diverse opzioni:

Lancia un’eccezione,
Prendi un’eccezione,
Visualizza un tuo messaggio di errore,
O qualche altra opzione che potrei prendere in considerazione in questo articolo.

Indipendentemente da ciò, l’idea è di essere difensivi nel codice in modo da poterti preparare al caso in cui un file non esiste e puoi gestire con grazia l’errore.

Al caricamento automatico

Prima di concludere, è importante notare quanto segue:

In tutto l’esempio, abbiamo utilizzato codice orientato agli oggetti durante lo spazio dei nomi del codice. Dopotutto, è un concetto orientato agli oggetti.
Il nostro caricatore automatico è scritto in codice procedurale. Cosa dà?

In definitiva, questo ha a che fare con la libreria PHP standard. Puoi scrivere un caricatore automatico orientato agli oggetti, ma penso che in molti casi sia un po’ eccessivo.

Il processo di caricamento di un file è un processo graduale, quindi scriverlo in modo procedurale è una scelta naturale.

Infine, altri possono scegliere di utilizzare strumenti come Composer per inserire le dipendenze. Questi sono ottimi strumenti e ci sono molti vantaggi nell’usare qualcosa di simile; tuttavia, va oltre i concetti e gli argomenti in questo articolo ed è meglio lasciarlo per un discorso futuro.

Risorse (e grazie!)

Questo è stato uno degli articoli più lunghi che ho scritto per il mio sito.

Ciò è in parte dovuto al fatto che si basa su un discorso per un WordCamp e anche perché voglio assicurarmi di fornire una solida introduzione e base in cui puoi iniziare a incorporare spazi dei nomi e caricare automaticamente nei tuoi plugin di WordPress.

Oltre a questo articolo, ho fornito anche le seguenti risorse:

Le slide della mia presentazione sono disponibili su SpeakerDeck.
Ho il codice di questa presentazione disponibile per il download su GitHub.

E con ciò, spero che questo fornisca una solida introduzione ai namepsace e al caricamento automatico e che tu sia in grado di iniziare a incorporarlo sempre di più nel tuo lavoro. Beneficia notevolmente del tuo lavoro e anche di altri sviluppatori che potrebbero finire per utilizzare il tuo lavoro.

Fonte di registrazione: tommcfarlin.com