Share
A questo punto della serie, siamo pronti ad andare avanti completando il nostro plugin documentando i nostri file, classi, funzioni, variabili e altro.
Anche se questo è l'ultimo passo in cui dobbiamo completare il plugin, non è l'ultimo post della serie, poiché continueremo a esaminare alcuni argomenti avanzati nella programmazione orientata agli oggetti.
Ma prima di farlo, portiamo il nostro plugin alla versione 1.0 mettendo in pratica tutto ciò che abbiamo imparato nel precedente articolo.
Certo, come con tutti articoli precedenti, raccomando di recuperare tutto ciò che abbiamo trattato fino ad ora, in modo che tu sia completamente in grado di accelerare non solo con il lavoro che abbiamo svolto nell'ultimo articolo, ma con il modo in cui siamo arrivati ai punti finali stiamo discutendo in questo articolo.
Con tutti quelli trattati e revisionati, iniziamo con la documentazione di ciascuno dei nostri file.
Ci sono diversi modi in cui possiamo documentare questo plugin:
Ovviamente, l'opzione produrrà più documentazione per sezione, ma dovrebbe comportare un articolo molto meno noioso e una comprensione molto più semplice del flusso di controllo per l'intero plugin.
A tal fine, lavoreremo attraverso il plugin, file per file, introducendo la documentazione per ogni pezzo di codice che abbiamo e poi discuteremo di eventuali punti di interesse seguendo il codice.
Infine, ci assicureremo di fare riferimento alla versione finale del plugin alla fine dell'articolo. Detto ciò, iniziamo.
Ricorda che il file principale per avviare il plugin è il file single-post-meta-manager.php che si trova nella directory principale del plugin.
Ecco come appare la versione completamente documentata del file. Leggi attentamente ogni commento prestando attenzione non solo al formato che segue, ma al contenuto che fornisce.
correre(); // Chiama la funzione sopra per iniziare l'esecuzione del plugin. run_single_post_meta_manager ();
Nel codice precedente, notiamo che abbiamo definito un'intestazione del file secondo le convenzioni che abbiamo delineato nell'articolo precedente. Abbiamo anche mantenuto i tag di intestazione del plug-in necessari affinché WordPress li leggesse correttamente.
Nota che, in questo caso, li abbiamo inclusi sotto un'abitudine @ Wordpress-plugin etichetta. Questo non è richiesto ma aiuta a separare i commenti dell'intestazione del file dai commenti del plug-in richiesti.
Infine, tieni presente che abbiamo superato la versione di questo plug-in 1.0, e abbiamo anche fornito questo plugin @pacchetto valore di SPMM che è a corto di Meta Manager Single Post. Lo useremo attraverso il plugin.
Accentsconagua
include elencoSuccessivamente, rivolgiamo la nostra attenzione a tutti i file che si trovano nella directory includes.
Dato che questi file sono necessari prima di qualsiasi cosa nella directory di amministrazione, ha senso esaminare ciascuno di questi file singolarmente, quindi completare la discussione con i file rimanenti nella directory di amministrazione.
plugin_slug = 'single-post-meta-manager-slug'; $ this-> version = '1.0.0'; $ This-> load_dependencies (); $ This-> define_admin_hooks (); / ** * Importa le classi di amministrazione Meta post singolo e il Meta Loader post singolo. * * La classe di amministrazione di Meta Manager Single Post definisce tutte le funzionalità uniche per * l'introduzione di funzionalità personalizzate nel dashboard di WordPress. * * Il caricatore di Meta Manager a post singolo è la classe che coordinerà gli hook e le callback * da WordPress e dal plug-in. Questa funzione crea un'istanza e imposta il riferimento alla proprietà della classe * $ loader. * * @accesso privato * / funzione privata load_dependencies () require_once plugin_dir_path (dirname (__FILE__)). 'Admin / classe-single-post-meta-manager-admin.php'; require_once plugin_dir_path (__FILE__). 'Class-single-post-meta-manager-loader.php'; $ this-> loader = new Single_Post_Meta_Manager_Loader (); / ** * Definisce le funzioni di hook e callback utilizzate per impostare i fogli di stile del plugin * e la meta-box del plugin. * * Questa funzione si basa sulla classe di amministrazione Meta Manager Single Post e sulla proprietà della classe Loader di Single Post Meta Manager *. * * @accesso privato * / funzione privata define_admin_hooks () $ admin = new Single_Post_Meta_Manager_Admin ($ this-> get_version ()); $ this-> loader-> add_action ('admin_enqueue_scripts', $ admin, 'enqueue_styles'); $ this-> loader-> add_action ('add_meta_boxes', $ admin, 'add_meta_box'); / ** * Imposta questa classe in movimento. * * Esegue il plugin chiamando il metodo run della classe loader che * registrerà tutti gli hook e le funzioni di callback utilizzati in tutto il plugin * con WordPress. * / public function run () $ this-> loader-> run (); / ** * Restituisce la versione corrente del plugin al chiamante. * * @return string $ this-> versione La versione corrente del plugin. * / public function get_version () return $ this-> version; Chiaramente, ci sono Un sacco di nuovi commenti che sono stati introdotti in questo particolare file; tuttavia, dovrebbe essere molto intuitivo riguardo a cosa stanno facendo ciascuna proprietà di classe, il costruttore e le funzioni interne.
La cosa fondamentale da notare - a parte il modo in cui le informazioni sono coordinate attraverso il plugin - è il modo in cui abbiamo aderito agli standard definiti nel precedente articolo.
Si noti, tuttavia, che noi avere preso la libertà se non utilizzando determinati tag e / o caratteristiche della documentazione quando non sono pertinenti. Questo è qualcosa che continueremo a fare nel resto dell'articolo.
actions = array (); $ this-> filters = array (); / ** * Registra le azioni con WordPress e i rispettivi oggetti e * i loro metodi. * * @param string $ hook Il nome del gancio WordPress al quale stiamo registrando un callback. * @param object $ component L'oggetto che contiene il metodo da chiamare quando viene attivato l'hook. * @param string $ callback La funzione che risiede sul componente specificato. * / funzione pubblica add_action ($ hook, $ component, $ callback) $ this-> actions = $ this-> add ($ this-> actions, $ hook, $ component, $ callback); / ** * Registra i filtri con WordPress e i rispettivi oggetti e * i loro metodi. * * @param string $ hook Il nome del gancio WordPress al quale stiamo registrando un callback. * @param object $ component L'oggetto che contiene il metodo da chiamare quando viene attivato l'hook. * @param string $ callback La funzione che risiede sul componente specificato. * / funzione pubblica add_filter ($ hook, $ componente, $ callback) $ this-> filters = $ this-> add ($ this-> filters, $ hook, $ component, $ callback); / ** * Registra i filtri con WordPress e i rispettivi oggetti e * i loro metodi. * * @accesso privato * * @param array $ hooks La raccolta di hook esistenti da aggiungere alla raccolta di hook. * @param string $ hook Il nome del gancio WordPress al quale stiamo registrando un callback. * @param object $ component L'oggetto che contiene il metodo da chiamare quando viene attivato l'hook. * @param string $ callback La funzione che risiede sul componente specificato. * * @return array La collezione di ganci registrati con WordPress tramite questa classe. * / funzione privata add ($ hooks, $ hook, $ componente, $ callback) $ hooks [] = array ('hook' => $ hook, 'component' => $ component, 'callback' => $ callback) ; restituire $ ganci; / ** * Registra tutti i filtri e le azioni definite con WordPress. * / public function run () foreach ($ this-> filtri come $ hook) add_filter ($ hook ['hook'], array ($ hook ['component'], $ hook ['callback'])); foreach ($ this-> azioni come $ hook) add_action ($ hook ['hook'], array ($ hook ['component'], $ hook ['callback'])); Si noti che questa classe è più o meno un componente fondamentale del plugin in quanto coordina tutte le azioni e i filtri utilizzati nel plugin. Questo plugin centralizza tutta la registrazione e il coordinamento dei ganci che vengono utilizzati in tutto il plugin.
Finalmente, quando correre viene chiamato, tutti gli hook sono registrati con WordPress così come il plugin si attiva, chiamerà ciascuna delle azioni e dei filtri registrati.
Admin elencoA questo punto, siamo pronti a rivolgere la nostra attenzione ai file che si trovano nella directory di amministrazione del plugin.
Sebbene il file sia costituito da un paio di file PHP, è costituito anche da un file CSS. Ai fini di questo articolo, non stiamo per documentare i file CSS; tuttavia, il codice WordPress fa definire la documentazione per questo.
Per ora, però, continuiamo a documentare le classi e i file che esistono nel Admin elenco.
La classe Amministratore di Meta Manager Single Post ha una sola responsabilità: definire la funzionalità per il rendering della meta box e dei suoi stili per il dashboard.
versione = $ versione; / ** * Accoda il foglio di stile responsabile per lo styling del contenuto di questa * meta-box. * / public function enqueue_styles () wp_enqueue_style ('single-post-meta-manager-admin', plugin_dir_url (__FILE__). 'css / single-post-meta-manager-admin.css', array (), $ this- > versione, FALSE); / ** * Registra la meta-box che verrà utilizzata per visualizzare tutti i meta dati post * associati al post corrente. * / funzione pubblica add_meta_box () add_meta_box ('single-post-meta-manager-admin', 'Single Post Meta Manager', array ($ this, 'rendering_meta_box'), 'post', 'normal', 'core' ); / ** * Richiede il file che viene utilizzato per visualizzare l'interfaccia utente della metatag posta. * / public function render_meta_box () require_once plugin_dir_path (__FILE__). 'Parziali / single-post-meta-manager.php'; Si noti che la classe di cui sopra ha pochissimi dettagli funzionali. In primo luogo, la classe mantiene un riferimento alla versione del plug-in, al foglio di stile usato per disegnare la meta-box e alla funzione richiesta per rendere effettivamente la meta-box.
Ricorda che tutto questo è impostato nel file del plugin principale e nel caricatore. Ciò aiuta a rimuovere la logica esistente all'interno del plugin in modo che ogni classe possa concentrarsi su quale sia il suo scopo principale.
Naturalmente, il pezzo finale del plugin si basa sul file parziale effettivo che contiene il markup necessario per visualizzare la meta-box.
$ post_meta_value) ?>
Questo dovrebbe essere relativamente auto-esplicativo; tuttavia, per essere completo, si noti che questo file prende l'ID del post corrente (attraverso l'uso di get_the_ID () funzione), legge i metadati del post, quindi esegue un'iterazione attraverso la creazione di una tabella che visualizza le chiavi e i valori.
A questo punto, abbiamo completato l'implementazione del nostro plugin. Dalla messa in atto delle pratiche di programmazione di programmazione orientata agli oggetti, alla documentazione del codice.
Puoi prendere la versione finale del plugin su GitHub; tuttavia, continueremo la nostra discussione orientata agli oggetti su alcuni altri post in modo che possiamo esplorare alcuni argomenti più avanzati come l'ereditarietà, l'astrazione e altri argomenti.
Nel frattempo, se hai domande o commenti sul plug-in, non esitare a lasciarli nei commenti!
