Share
Per molti progetti WordPress in questi giorni usiamo tipi di post personalizzati. Il team di sviluppo di WordPress ha creato alcuni metodi utili per integrarli nei tuoi progetti. Ma quando usi spesso tipi di post personalizzati, tassonomie e meta-box, è molto probabile che tu ti ripeta. Ecco perché useremo la potenza di queste funzioni di WordPress per costruire una classe più potente, che possiamo usare per registrare rapidamente tipi di post, tassonomie e meta-box.
È così che chiamiamo la nostra classe quando è fatta.
Accentsconagua
include ( 'custom-post-type.php'); $ book = new Custom_Post_Type ('Book'); $ book-> add_taxonomy ('category'); $ book-> add_taxonomy ('author'); $ book-> add_meta_box ('Book Info', array ('Year' => 'text', 'Genre' => 'text')); $ book-> add_meta_box ('Info autore', array ('Nome' => 'testo', 'Nazionalità' => 'testo', 'Compleanno' => 'testo')); Iniziamo con la creazione della classe, delle proprietà principali, del costruttore e dei metodi. In questo tutorial li riempiremo con la nostra logica di programmazione.
class Custom_Post_Type public $ post_type_name; pubblico $ post_type_args; pubblico $ post_type_labels; / * Costruttore di classi * / public function __construct () / * Metodo che registra il tipo di post * / public function register_post_type () / * Metodo per collegare la tassonomia al tipo di post * / public function add_taxonomy () / * Allega meta box al tipo di messaggio * / funzione pubblica add_meta_box () / * Ascolta quando il tipo di messaggio viene salvato * / public function save ()
All'interno del costruttore creiamo alcune variabili importanti, che sono usate nell'intera classe. Chiamiamo anche add_action per registrare il tipo di post e ascoltiamo quando viene salvato il tipo di post, così possiamo salvare i metadati del nostro post. Se il tipo di messaggio esiste, il add_action non è chiamato, ma il $ post_type_name è impostato, quindi possiamo aggiungere tassonomie e meta-box.
funzione pubblica __construct ($ name, $ args = array (), $ labels = array ()) // Imposta alcune variabili importanti $ this-> post_type_name = strtolower (str_replace (", '_', $ name)); $ this-> post_type_args = $ args; $ this-> post_type_labels = $ labels; // Aggiungi azione per registrare il tipo di post, se il tipo di post non esiste già se (! post_type_exists ($ this-> post_type_name)) add_action ( 'init', array (& $ this, 'register_post_type')); // Ascolta per il salvataggio post hook $ this-> save (); All'interno del register_post_type metodo, che viene chiamato dal add_action nel costruttore, prima determiniamo il nome (in maiuscolo) e il plurale. Con questo nome e plurale costruiamo le nostre etichette per il tipo di post e le sovrascriviamo (e le uniamo) con le etichette fornite dal $ This-> post_type_labels variabile. Quindi creiamo i nostri argomenti con lo stesso principio.
public function register_post_type () // Capitolare le parole e renderlo plurale $ name = ucwords (str_replace ('_', ", $ this-> post_type_name)); $ plural = $ name. 's'; // Impostiamo le etichette predefinite in base al nome del post e al plurale. Le sovrascriviamo con le etichette indicate. $ labels = array_merge (// Array predefinito ('name' => _x ($ plural, 'nome del tipo generico'), 'nome_solo '=> _x ($ name,' post type singular name '),' add_new '=> _x (' Aggiungi nuovo ', strtolower ($ name)),' add_new_item '=> __ (' Aggiungi nuovo '. $ name) , 'edit_item' => __ ('Modifica'. $ name), 'new_item' => __ ('Nuovo'. $ name), 'all_items' => __ ('Tutti'. $ plural), 'view_item' = > __ ('Visualizza'. $ Name), 'search_items' => __ ('Cerca'. $ Plural), 'not_found' => __ ('No'. Strtolower ($ plurale). 'Found'), 'not_found_in_trash '=> __ (' No '. Strtolower ($ plurale).' Trovato nel Cestino '),' parent_item_colon '=> ",' menu_name '=> $ plural), // Dato etichette $ this-> post_type_labels); // Lo stesso principio delle etichette. Impostiamo alcuni valori di default e li sovrascriviamo con gli argomenti dati. $ args = array_merge (// array predefinito ('label' => $ plural, 'labels' => $ labels, 'public' => true, 'show_ui' => true, 'supports' => array ('title' , 'editor'), 'show_in_nav_menus' => true, '_builtin' => false,), // Dato args $ this-> post_type_args); // Registra il tipo di messaggio register_post_type ($ this-> post_type_name, $ args); Per prima cosa controlliamo se il nome $ parametro è vuoto. Quando lo è, non facciamo nulla. Quando non lo è, creiamo tre variabili in cui memorizziamo le informazioni per la tassonomia: $ taxonomy_name, $ taxonomy_labels e $ taxonomy_args.
funzione pubblica add_taxonomy ($ name, $ args = array (), $ labels = array ()) if (! empty ($ name)) // È necessario conoscere il nome del tipo di post, in modo che la nuova tassonomia possa essere allegata ad esso. $ post_type_name = $ this-> post_type_name; // Proprietà di tassonomia $ taxonomy_name = strtolower (str_replace (", '_', $ name)); $ taxonomy_labels = $ labels; $ taxonomy_args = $ args; / * Altro codice in arrivo * / Dopo aver eseguito i primi controlli e quindi aver impostato alcune variabili, registreremo il tipo di post. Ma prima controlliamo se la tassonomia esiste già.
if (! taxonomy_exists ($ taxonomy_name)) / * Crea la tassonomia e collegalo al tipo di oggetto (tipo di post) * / else / * La tassonomia esiste già. Stiamo per allegare la tassonomia esistente al tipo di oggetto (tipo di post) * /
Se la tassonomia non esiste, la registriamo. Usiamo un add_action, ma non nel modo normale. Normalmente, il secondo parametro del add_action è il nome di una funzione, ma poiché usiamo ogni volta parametri diversi, passeremo una funzione senza nome (Nota: questa funzione richiede PHP 5.3+) e usa il uso() funzione. Con il uso() funzione possiamo passare variabili alla funzione senza nome. Questa volta dobbiamo passare $ taxonomy_name, $ post_type_name e $ taxonomy_args per registrare la tassonomia.
// Capitolare le parole e renderlo plurale $ name = ucwords (str_replace ('_', ", $ name)); $ plural = $ name. 'S'; // Le etichette predefinite, le sovrascrivono con le etichette specificate. $ labels = array_merge (// array predefinito ('name' => _x ($ plural, 'nome generale della tassonomia'), 'singular_name' => _x ($ name, 'taxonomy singular name'), 'search_items' => __ ( 'Cerca'. $ Plurale), 'all_items' => __ ('Tutti'. $ Plurale), 'parent_item' => __ ('Parent'. $ Name), 'parent_item_colon' => __ ('Parent'. $ name. ':'), 'edit_item' => __ ('Modifica'. $ name), 'update_item' => __ ('Aggiorna'. $ name), 'add_new_item' => __ ('Aggiungi Nuovo'. $ nome), 'new_item_name' => __ ('Nuovo'. $ nome. 'Nome'), 'menu_name' => __ ($ name),), // Etichette fornite $ taxonomy_labels); // Argomenti predefiniti, sovrascritti con gli argomenti dati $ args = array_merge (// array predefinito ('label' => $ plural, 'labels' => $ labels, 'public' => true, 'show_ui' => true, 'show_in_nav_menus' => true, '_builtin' => falso,), // Dato $ taxonomy_args); // Aggiungi la tassonomia al tipo di post add_action (uso 'init', function () ($ taxonomy_name, $ post_type_name, $ args) register_taxonomy ($ taxonomy_name, $ post_type_name, $ args); ); Quando la tassonomia non esiste, la colleghiamo solo al nostro tipo di post. Proprio come prima, usiamo una funzione senza nome e il uso() funzione. Questa volta dobbiamo solo passare $ taxonomy_name e $ post_type_name.
add_action ('init', function () use ($ taxonomy_name, $ post_type_name) register_taxonomy_for_object_type ($ taxonomy_name, $ post_type_name);); Per la registrazione dei meta-box, abbiamo bisogno del nome del tipo di post, quindi per prima cosa lo determiniamo. Dopodiché abbiamo bisogno di alcune variabili per la stessa meta-box e rendiamo globali i metadati personalizzati, così possiamo accedervi nel gancio di salvataggio. Qui non tratteremo troppi dettagli, perché Tammy Hart ha già fatto un tutorial molto utile sulle meta box riutilizzabili.
funzione pubblica add_meta_box ($ title, $ fields = array (), $ context = 'normal', $ priority = 'default') if (! empty ($ title)) // È necessario conoscere nuovamente il nome del tipo di post $ post_type_name = $ this-> post_type_name; // Meta variabili $ box_id = strtolower (str_replace (", '_', $ title)); $ box_title = ucwords (str_replace ('_',", $ title)); $ box_context = $ contesto; $ box_priority = $ priority; // Rendi globali i campi $ custom_fields; $ custom_fields [$ title] = $ fields; / * Più codice in arrivo * / Quando impostiamo le variabili e le globali, registriamo la meta-scatola con un add_action. Come prima, usiamo una funzione senza nome. Questa volta abbiamo bisogno $ box_id, $ box_title, $ post_type_name, $ box_context, $ box_priority e campi $.
add_action ('admin_init', function () usa ($ box_id, $ box_title, $ post_type_name, $ box_context, $ box_priority, $ campi) add_meta_box ($ box_id, $ box_title, funzione ($ post, $ data) global $ post ; // Nonce field per alcune convalide wp_nonce_field (plugin_basename (__FILE__), 'custom_post_type'); // Ottieni tutti gli input da $ data $ custom_fields = $ data ['args'] [0]; // Ottieni i valori salvati $ meta = get_post_custom ($ post-> ID); // Controlla la matrice e cicla su se (! empty ($ custom_fields)) / * Passa attraverso $ custom_fields * / foreach ($ custom_fields come $ label => $ type) $ field_id_name = strtolower (str_replace (", '_', $ data ['id'])). '_'. strtolower (str_replace (", '_', $ label)); echo ''; , $ post_type_name, $ box_context, $ box_priority, array ($ fields)); ); Salva tutti i metadati del post. Li analizziamo, usando il globale $ custom_fields. Questa è anche una copertura rapida, vedi il tutorial di Tammy Hart sui meta box riutilizzabili.
public function save () // Richiede ancora il nome del tipo di post $ post_type_name = $ this-> post_type_name; add_action ('save_post', function () usa ($ post_type_name) // Rifiuta la funzione di salvataggio automatico di WordPress se (definito ('DOING_AUTOSAVE') && DOING_AUTOSAVE) restituisce; if (! wp_verify_nonce ($ _POST ['custom_post_type'], plugin_basename ( __FILE__))) return; globale $ post; if (isset ($ _POST) && isset ($ post-> ID) && get_post_type ($ post-> ID) == $ post_type_name) global $ custom_fields; // Ciclo continuo meta box foreach ($ custom_fields as $ title => $ fields) // Passa attraverso tutti i campi foreach ($ campi come $ label => $ tipo) $ field_id_name = strtolower (str_replace (", '_', $ title) ). '_'. strtolower (str_replace (", '_', $ label)); update_post_meta ($ post-> ID, $ field_id_name, $ _POST ['custom_meta'] [$ field_id_name]);) ; Come puoi vedere, usiamo strtolower (str_replace (", '_', $ string)) e ucwords (str_replace ('_', ", $ string)) un certo numero di volte. Il motivo per cui creo questa lezione è che non ci ripetiamo, quindi non vogliamo farlo neanche in questa parte. Ecco perché creiamo alcuni metodi di supporto. In questo modo possiamo fare questo: $ name = self :: beautify ($ string); invece di $ name = strtolower (str_replace (", '_', $ title));
public static function beautify ($ stringa) return ucwords (str_replace ('_', ", $ string)); public static function uglify ($ string) return strtolower (str_replace (", '_', $ string)) ; Un altro punto sono le forme plurali che creiamo. Li creiamo semplicemente aggiungendo una "s" alla parola. Ma cosa succede quando la parola termina con una "y"? Per questo motivo creiamo un metodo di supporto per determinare la forma plurale di una parola. Ora possiamo farlo facilmente: $ plural = self :: pluralize ($ string) e la forma plurale della nostra parola sarà determinata.
public static function pluralize ($ string) $ last = $ string [strlen ($ string) - 1]; if ($ last == 'y') $ cut = substr ($ stringa, 0, -1); // converti y in ies $ plural = $ cut. 'i'; else // basta allegare una stringa $ pl $ = $. 'S'; return $ plural;
E ora abbiamo finito. Ora puoi usare questa classe per registrare facilmente tipi di post, tassonomie e meta-box. Se hai suggerimenti o domande, lascia un commento, quindi possiamo parlarne. Spero di vederti la prossima volta!
Inoltre, vorrei dare un po 'di merito a Jeffrey Way. Ho usato la sua classe come ispirazione per la mia classe e per questo tutorial. Inoltre, vorrei dare un po 'di merito a Tammy Hart, per aver creato il tutorial sui meta box riutilizzabili. Dai un'occhiata al loro lavoro.
