Share
In questa serie, abbiamo dato un'occhiata a come possiamo implementare un sistema che ci consente di definire in modo programmatico i messaggi personalizzati che vengono visualizzati su una determinata pagina di amministrazione nel back-end di WordPress.
Se hai seguito la serie fino ad ora, allora sai:
Come menzionato nel precedente tutorial:
Ma se hai letto uno dei miei tutorial precedenti, sai che non sono un fan di avere il codice duplicato. Nemmeno io sono fan di avere una classe fare molte cose. E, sfortunatamente, è esattamente quello che stiamo facendo qui.
E ci occuperemo di questo in questo ultimo tutorial. Entro la fine, avremo una soluzione refactored completa che utilizza alcuni principi intermedi orientati agli oggetti come l'ereditarietà. Avremo anche alcuni metodi che possiamo usare a livello di programmazione o che possono essere registrati con il sistema di aggancio WordPress.
A questo punto dovresti sapere esattamente di cosa hai bisogno nel tuo ambiente di sviluppo locale. Nello specifico, dovresti avere quanto segue:
Raccomando anche la versione più recente del codice sorgente in quanto ti consentirà di esaminare tutte le modifiche che stiamo apportando. Se non ce l'hai, va bene, ma ti consiglio di leggere le esercitazioni precedenti prima di andare oltre.
Come potresti ricordare (o avere accertato dal commento sopra), il tutorial precedente ci ha lasciato con una sola classe che stava facendo troppo lavoro.
Un modo per sapere questo è che se dovessi descrivere quello che stava facendo la classe, non saresti in grado di dare una singola risposta. Invece, dovresti dire che era responsabile della gestione dei messaggi di successo, dei messaggi di avviso, dei messaggi di errore e del rendering di tutti loro indipendentemente l'uno dall'altro.
E benché si possa affermare che si trattava di "gestire messaggi personalizzati", non si descriverebbe necessariamente la verbosità della classe. Questo è ciò che speriamo di risolvere in questo tutorial.
In particolare, stiamo andando a fare quanto segue:
Abbiamo il nostro lavoro tagliato per noi, quindi andiamo avanti e cominciamo con tutto quanto sopra.
Quando si tratta di refactoring del nostro lavoro, aiuta a sapere esattamente cosa vogliamo fare. Nel nostro caso, riconosciamo che abbiamo un sacco di codice duplicato che potrebbe essere condensato.
Inoltre, abbiamo tre diversi tipi di messaggi gestiti esattamente allo stesso modo, tranne per il modo in cui sono resi. E in questo caso, è un problema degli attributi della classe HTML.
Quindi, possiamo generalizzare quel codice per focalizzarci su uno specifico genere, e possiamo consolidare molti metodi per aggiungere messaggi di successo o recuperare messaggi di errore generalizzando un metodo per riconoscere detto genere.
In definitiva, lo faremo. Ma prima, alcune pulizie.
Nelle esercitazioni precedenti, abbiamo lavorato con una classe chiamata Settings_Messenger. Fino a questo punto, è servito al suo scopo, ma stiamo rifacendo questa lezione per il resto di questo tutorial.
Quando si tratta di questo tipo di refactoring, è facile voler semplicemente cancellare la classe e ricominciare da capo. Ci sono momenti in cui questo è appropriato, ma questo non è uno di questi. Invece, prenderemo quella classe e refactor cosa c'è già.
Tutto ciò per dire, non cancellare il file e iniziare con uno nuovo. Invece, segui ciò che stiamo facendo in questo tutorial.
Per prima cosa, introduciamo un Settings_Message classe. Questo rappresenta qualunque tipo di messaggio di impostazioni con cui scriveremo. Cioè, gestirà messaggi di successo, messaggi di errore e messaggi di avvertimento.
Per fare ciò, definiremo la classe, introdurremo una singola proprietà e quindi la istanziamo nel costruttore. Dai un'occhiata a questo codice e ti spiegherò un po 'più in basso:
Accentsconagua
messages = array ('success' => array (), 'error' => array (), 'warning' => array (),); Si noti che abbiamo creato un attributo privato, $ messages. Quando la classe viene istanziata, creiamo una matrice multidimensionale. Ogni indice, identificato da successo, errore, o avvertimento, si riferisce al proprio array in cui memorizzeremo i messaggi corrispondenti.
Successivamente, dobbiamo essere in grado di aggiungere un messaggio, ottenere un messaggio e ottenere tutti i messaggi. Discuterò ciascuno di questi in modo più dettagliato momentaneamente.
Per prima cosa, vediamo come aggiungeremo i messaggi:
messaggi [$ tipo])) return; array_push ($ this-> messages [$ type], $ message);
Questo messaggio prende prima la stringa in entrata e disinfetta i dati. Quindi controlla se esiste già nei messaggi di successo. Se è così, restituisce semplicemente. Dopotutto, non vogliamo messaggi duplicati.
In caso contrario, aggiunge il messaggio alla raccolta.
Il recupero dei messaggi ha due forme:
Ricorda, ci sono momenti in cui potremmo voler solo visualizzare messaggi di avvertimento. Altre volte, potremmo voler visualizzare tutti i messaggi. Poiché ci sono due modi per farlo, possiamo sfruttarne uno e poi sfruttarlo in un'altra funzione.
Suona confuso? Aspetta con me e ti spiegherò tutto. La prima parte su cui ci concentreremo è la modalità di rendering dei messaggi genere (pensa al successo, all'errore o all'avviso). Ecco il codice per farlo (e dovrebbe sembrare familiare):
messaggi [$ tipo])) return; $ html = ""; $ html. = ''; $ allowed_html = array ('div' => array ('class' => array (),), 'ul' => array (), 'li' => array (),); echo wp_kses ($ html, $ allowed_html);'; foreach ($ this-> messages [$ type] come $ message) $ html. = "
'; $ html. = '- $ messaggio
"; $ html. = '
Si noti qui che stiamo utilizzando gran parte dello stesso codice del precedente tutorial; tuttavia, lo abbiamo generalizzato in modo che guardi l'arrivo $ tipo e lo applica dinamicamente al markup.
Questo ci permette di avere un'unica funzione per rendere i nostri messaggi. Questo non è tutto, però. Che dire delle volte che vogliamo ottenere tutti messaggi? Questo potrebbe essere quello di eseguire il rendering su una pagina o di acquisirli a livello di codice per altre elaborazioni.
Per fare questo, possiamo introdurre un'altra funzione:
messaggi come $ tipo => $ messaggio) $ this-> get_messages ($ tipo);
Questo messaggio dovrebbe essere abbastanza facile da capire. Semplicemente scorre attraverso tutti i messaggi che abbiamo nella nostra collezione e chiama il get_messages funzione che abbiamo delineato sopra.
Li rende ancora tutti insieme (che vedremo un loro utilizzo nella nostra implementazione di un amo personalizzato momentaneamente). Se si desidera utilizzarli per un altro scopo, è possibile aggiungere il risultato in una stringa e restituirlo al chiamante o eseguire qualche altra funzione programmatica.
Questa è solo un'implementazione.
Questo lo fa per il reale Settings_Message classe. Ma come possiamo comunicare con esso? Certo, possiamo parlarne direttamente, ma se c'è una classe intermedia, abbiamo il controllo su ciò che ci viene restituito senza aggiungere ulteriori responsabilità al Settings_Message classe, giusto?
Inserisci il Settings_Messenger. Questa classe è responsabile per ci consente di leggere e scrivere i messaggi delle impostazioni. Penso che si possa fare un caso in cui potresti dividerlo in due classi con la sua responsabilità perché legge e scrive ma, come un messaggero che invia e riceve, questo è lo scopo di questa classe.
La configurazione iniziale della classe è semplice.
Settings_Message classe che possiamo usare per inviare e ricevere messaggi.tutsplus_settings_messages gancio che abbiamo definito in un precedente tutorial.Dai uno sguardo al primo paio di metodi:
messaggio = new Settings_Message (); public function init () add_action ('tutsplus_settings_messages', array ($ this, 'get_all_messages')); Ricordati di prima in questo tutorial, abbiamo il gancio definito nella nostra vista che può essere trovato in settings.php. Per completezza, è elencato qui:
In realtà non visualizzeremo opzioni in questa pagina. Invece, useremo questa pagina per dimostrare come collegarci al nostro messenger personalizzato.
Si noti, tuttavia, che questo particolare hook sfrutta il get_all_messages metodo che esamineremo in un momento. Non deve usare questo metodo. Invece poteva essere utilizzato per rendere semplicemente i messaggi di successo o qualsiasi altro metodo che si desidera utilizzare.
Creare le funzioni per aggiungere messaggi è semplice in quanto queste funzioni richiedono un tipo e il messaggio stesso. Ricorda il Settings_Message si occupa di disinfettare le informazioni in modo che possiamo semplicemente passare i messaggi in arrivo.
Vedi sotto dove stiamo aggiungendo successo, avviso e messaggi di errore:
add_message ('successo', $ messaggio); public function add_warning_message ($ message) $ this-> add_message ('warning', $ message); public function add_error_message ($ message) $ this-> add_message ('error', $ message); È facile, non è vero??
Recupero dei messaggi non è molto diverso, tranne che dobbiamo solo fornire il tipo di messaggi che vogliamo recuperare:
get_messages ('successo'); public function get_warning_messages () echo $ this-> get_messages ('warning'); public function get_error_messages () echo $ this-> get_messages ('error'); Fatto e fatto, giusto?
Si noti che i messaggi si riferiscono soprattutto a due altri metodi che non abbiamo ancora affrontato. Questi sono messaggi privati che ci aiutano a semplificare le chiamate sopra.
Scopri i seguenti metodi privati che sono entrambi responsabili dell'aggiunta e del recupero dei messaggi direttamente dal Settings_Message istanza mantenuta sull'oggetto di messaggistica:
messaggio-> add_message ($ tipo, $ messaggio); funzione privata get_messages ($ tipo) return $ this-> message-> get_messages ($ type);
E quello avvolge il nuovo Settings_Messenger classe. Tutto questo è molto più semplice, no??
Tuttavia, solleva la domanda: come possiamo avviare il plugin ora che abbiamo avuto tutte queste modifiche?
Vedi l'intera funzione qui sotto:
dentro(); $ messenger = new Settings_Messenger (); $ Messenger-> init (); $ messenger-> add_success_message ('Nice shot kid, era uno su un milione!'); $ messenger-> add_warning_message ('Non andare dolcemente in quella buona notte.'); $ messenger-> add_error_message ('Danger Will Robinson.'); E questo è tutto.
Alcuni punti da notare:
Settings_Messenger, quindi non devi preoccuparti di visualizzare alcun messaggio nella tua pagina delle impostazioni.Settings_Messenger, ma in realtà non ne recupera nessuno perché io sono usando il metodo init.Questo è tutto per il refactoring. Questo non funzionerà Esattamente fuori dalla scatola perché c'è ancora del codice necessario per caricare tutti i file PHP necessari per far funzionare il plugin; tuttavia, il codice sopra si concentra sul refactoring che è il punto di questo intero tutorial.
Per una versione completa di questo tutorial e completo del codice sorgente fa lavoro fuori dalla scatola, si prega di scaricare il codice sorgente allegato a questo post sulla barra laterale destra.
Spero che nel corso di questo materiale tu abbia acquisito una serie di nuove competenze e modi per affrontare lo sviluppo di WordPress. Quando guardiamo oltre la serie, abbiamo coperto molto:
Come al solito, sono sempre felice di rispondere alle domande tramite i commenti, e puoi anche controllare il mio blog e seguirmi su Twitter. Di solito parlo anche dello sviluppo del software all'interno di WordPress e di argomenti tangenziali. Se ti interessa più sviluppo di WordPress, non dimenticare di dare un'occhiata alle mie serie ed esercitazioni precedenti e l'altro materiale WordPress che abbiamo qui su Envato Tuts+.
