Share
Pentru multe proiecte WordPress din zilele noastre folosim tipuri personalizate de posturi. Echipa de dezvoltare WordPress a creat câteva metode la îndemână pentru a le integra în proiectele dvs. Dar când utilizați frecvent tipuri personalizate de posturi, taxonomii și căsuțe meta, este foarte probabil să vă repetați. De aceea vom folosi puterea acestor funcții WordPress pentru a construi o clasă mai puternică, pe care o putem folosi pentru a înregistra rapid tipuri de posturi, taxonomii și căsuțe meta.
Acesta este modul în care numim clasa noastră când este terminat.
Accentsconagua
includ ( 'custom-post-type.php'); $ book = nou Custom_Post_Type ("Carte"); $ book-> add_taxonomy ('categoria'); $ book-> add_taxonomy ("autor"); $ book-> add_meta_box ('Cartea Info', array ('Anul' => 'text', 'Genre' => 'text')); $ book-> add_meta_box ("Informații despre autor", array ('Nume' => 'text', 'Naționalitate' => 'text', 'Zi de naștere' => 'text')); Începem cu crearea clasei, a proprietăților principale, a constructorului și a metodelor. În acest tutorial le vom umple cu logica noastră de programare.
clasa Custom_Post_Type public $ post_type_name; public $ post_type_args; public $ post_type_labels; / * Functia publica __construct () / * Metoda care inregistreaza tipul postului * / functionala publica register_post_type () / * Metoda de atasare a taxonomiei tipului post * / public function add_taxonomy () / * Atașează metadatele la tipul postului * / funcția publică add_meta_box () / * Ascultă când se salvează tipul postului * / public save ()
În constructor vom crea câteva variabile importante, care sunt folosite în întreaga clasă. De asemenea sunăm ADD_ACTION pentru a înregistra tipul postului și pentru a asculta când se salvează tipul postului, astfel încât să putem salva datele meta postului nostru. Dacă există tipul postului, ADD_ACTION nu este numit, ci $ post_type_name este setat, astfel încât să putem adăuga taxonomii și căsuțe meta.
funcția publică __construct ($ name, $ args = array (), $ labels = array ()) // Setați câteva variabile importante $ this-> post_type_name = strtolower (str_replace (", '_', $ name) acest lucru ar trebui să se întâmple în cazul în care tipul de postare nu există deja dacă (post_type_exists ($ this-> post_type_name)) add_action ( 'init', array (& $ this, 'register_post_type')); // Ascultă pentru salvarea postului cârlig $ this-> save (); În cadrul register_post_type metodă, care este chemată de către ADD_ACTION în constructor, vom determina mai întâi numele (capitalizat) și plural. Cu acest nume și plural construim etichetele pentru tipul de post și suprascrie (și îmbinăm) cu etichetele date de la $ This-> post_type_labels variabil. Atunci ne creăm argumentele noastre cu același principiu.
funcția publică register_post_type () // Capitilizează cuvintele și le face plural $ name = ucwords (str_replace ('_', '$ this-> post_type_name)); $ plural = $ name.' s '; etichetele implicite bazate pe numele tipului de post și pe plural, le înlocuim cu etichetele date $ labels = array_merge (// Array implicit ('name' => _x ($ plural, 'post type general name'), 'singular_name 'add_new' => _x ('Add New', strtolower ($ name)), 'add_new_item' => __ ('Add New'. $ name) , 'edit_item' => __ ('Edit'. $ name), 'new_item' => __ ('New'. $ name), 'all_items' => > __ ('Vezi'. $ Name), 'search_items' => __ ('Search'. $ Plural), 'not_found' '=> __ (' Nu '; strtolower ($ plural);' found in Trash '),' parent_item_colon '=>', 'nume_menu' => $ plural), // etichete $ this-> post_type_labels; // Același principiu ca și etichetele. Am setat unele setări implicite și le suprascriem cu argumentele date. $ args = array_merge (// array_merge ('default' => true, 'supports' => array (' , 'editor'), 'show_in_nav_menus' => true, '_builtin' => false,), // args $ this-> post_type_args); // Înregistrați tipul postului register_post_type ($ this-> post_type_name, $ args); Mai întâi verificăm dacă numele $ parametrul este gol. Când este, nu facem nimic. Atunci când nu este, vom crea trei variabile în care stocăm informațiile pentru taxonomie: $ taxonomy_name, $ taxonomy_labels și $ taxonomy_args.
funcția publică add_taxonomy ($ nume, $ args = array (), $ labels = array ()) if ! empty $ name) // Trebuie să cunoaștem numele postului, la el. $ post_type_name = $ this-> post_type_name; // Proprietăți de taxonomie $ taxonomy_name = strtolower (str_replace (", '_', $ name)); $ taxonomy_labels = $ labels; $ taxonomy_args = $ args; / * După ce am efectuat primele verificări și apoi am setat câteva variabile, vom înregistra tipul postării. Dar mai întâi verificăm dacă taxonomia există deja.
dacă (! taxonomy_exists ($ taxonomy_name)) / * Creați taxonomia și atașați-o la tipul de obiect (tip post) * / altceva / * Taxonomia există deja. Vom atașa taxonomia existentă la tipul de obiect (tip post) * /
Dacă taxonomia nu există, o înregistrăm. Noi folosim un ADD_ACTION, dar nu în mod normal. În mod normal, al doilea parametru al lui ADD_ACTION este numele unei funcții, dar din moment ce folosim parametri diferiți de fiecare dată, vom trece o funcție fără nume (Notă: această caracteristică necesită PHP 5.3 +) și utilizați utilizare() funcţie. Cu utilizare() putem trece variabile la funcția fără nume. De data asta trebuie să trecem $ taxonomy_name, $ post_type_name și $ taxonomy_args să înregistreze taxonomia.
// Capitilizează cuvintele și le face plural $ name = ucwords (str_replace ('_', '$ name)); $ plural = $ name.' S '; // Etichete implicite, suprascrie-le cu etichetele date $ etichete = array_merge (// Array implicit ('nume' => _x ($ plural, taxonomy general name), singular_name '=> _x (nume nume taxonomie), search_items = 'Plural', 'all_items' => __ ('Toate'. $ Plural), 'parent_item' => __ ('Parent'. ('Edit'. $ nume), 'update_item' => __ ('Update'. $ name), 'add_new_item' => __ (' nume_name, 'new_item_name' => __ ('New'. $ name. ')', 'nume_menu' => __ ($ name), // // etichete $ taxonomy_labels); argumentele aratate $ args = array_merge (// array_merge ('array_merge' => $ plural, 'labels' => $ etichete, 'public' => true, 'show_ui' => true, 'show_in_nav_menus' '_builtin' => false,), // Given $ taxonomy_args); // Adăugați taxonomia la tipul postului add_action ('init', funcția () folosiți ($ taxonomy_name, $ post_type_name, $ args) register_taxonomy ($ taxonomy_name, $ post_type_name, $ args); ); Atunci când taxonomia nu există, o atașăm doar tipului nostru de post. La fel ca înainte, folosim o funcție fără nume și utilizare() funcţie. De data aceasta nu trebuie decât să trecem $ taxonomy_name și $ post_type_name.
add_action ('init', function () folosiți ($ taxonomy_name, $ post_type_name) register_taxonomy_for_object_type ($ taxonomy_name, $ post_type_name);); Pentru a înregistra metadatele, avem nevoie de numele tipului de post, deci mai întâi vom determina acest lucru. După asta avem nevoie de câteva variabile pentru meta-box în sine și facem meta-urile globale globale, astfel că le putem accesa în cârligul de salvare. Nu vom acoperi prea multe detalii aici, pentru că Tammy Hart a făcut deja un tutorial foarte util despre cutii de metale reutilizabile.
funcția publică add_meta_box ($ title, $ fields = array (), $ context = 'normal', $ priority = 'implicit') if empty $ title // $ post_type_name = $ this-> post_type_name; // variabilele Meta $ box_id = strtolower (str_replace (", '_', $ title)); $ box_title = ucwords (str_replace ('_', $ titlu)); $ box_context = $ context; $ box_priority = $ prioritate; // Faceți câmpurile globale globale $ custom_fields; $ custom_fields [$ title] = câmpuri $; / * Mai vine codul * / Când setăm variabilele și globalele, înregistrăm caseta meta cu o ADD_ACTION. Ca și înainte, folosim o funcție fără nume. De data asta avem nevoie $ box_id, $ box_title, $ post_type_name, $ box_context, $ box_priority și câmpuri $.
add_action ('admin_init', funcția () folosiți ($ box_id, $ box_title, $ post_type_name, $ box_context, $ box_priority, $ fields) add_meta_box ($ box_id, $ box_title, function ; // Câmp nonce pentru unele validări wp_nonce_field (plugin_basename (__FILE__), 'custom_post_type'); // Obțineți toate intrările din $ data $ custom_fields = $ data ['args'] [0]; // Obțineți valorile salvate $ meta = get_post_custom ($ post-> ID); // Verificați matricea și buclă prin ea dacă (! empty ($ custom_fields)) / * Loop prin $ custom_fields * / foreach ($ custom_fields ca $ label => type $) $ field_id_name = strtolower (str_replace (", '_', $ data ['id'])).„; , $ post_type_name, $ box_context, $ box_priority, array (câmpuri $)); ); Salvați datele meta postului. Vom trage prin ele, folosind globul $ custom_fields. Aceasta este, de asemenea, o acoperire rapidă, a se vedea tutorialul lui Tammy Hart despre cutii de meta reutilizabile.
funcția publică salvați () // Aveți nevoie de numele de tip post din nou $ post_type_name = $ this-> post_type_name; add_action ('save_post', functie () foloseste ($ post_type_name) // Refuza functia de salvare automata a lui WordPress daca (definita ('DOING_AUTOSAVE' && DOING_AUTOSAVE)) return (if_post_type '), plugin_basename __FILE__))) întoarcere globală $ post; dacă (isset ($ _POST) && isset ($ post-> ID) && get_post_type ($ post-> ID) == $ post_type_name) global $ custom_fields; ($ field_id_name = strtolower (str_replace (", '_', $ title)) $ $ field_id_name = strtolower) ) $ _POST ['custom_meta'] [$ field_id_name]);); "_" strtolower (str_replace (", '_' ; După cum puteți vedea, vom folosi strtolower (str_replace (", '_', $ șir)) și ucwords (str_replace ('_', ', $ șir)) de mai multe ori. Motivul creării acestei clase este că nu ne repetă, deci nu vrem să facem acest lucru și în această parte. De aceea noi creăm câteva metode de ajutor. În acest fel putem face acest lucru: $ nume = auto :: beautify ($ string); in loc de $ nume = strtolower (str_replace (", '_', $ titlu));
funcția publică statică înfrumusețează ($ string) returnează ucwords (str_replace ('_', '$ string)); funcția publică statică uglify ($ string) return strtolower (str_replace (",' _ ', $ string) ; Un alt punct este forma plurală pe care o creăm. Noi le creăm doar prin adăugarea unui cuvânt. Dar ce se întâmplă atunci când cuvântul se termină cu un "y"? Din acest motiv, creăm o metodă de ajutor pentru a determina forma plurală a unui cuvânt. Acum putem face acest lucru cu ușurință: $ plural = auto :: pluralizare ($ string) și forma plurală a cuvântului nostru va fi determinată.
funcția publică statică plurală ($ string) $ last = $ string [strlen ($ string) - 1]; dacă ($ ultima == 'y') $ cut = substr ($ string, 0, -1); // converti y la ies $ plural = $ cut. „agențiilor“; altceva // atașați doar s $ plural = $ string. 'S'; return $ plural;
Și acum am terminat. Acum puteți folosi această clasă pentru a înregistra cu ușurință tipurile de posturi, taxonomiile și căsuțele meta. Dacă aveți sugestii sau întrebări, lăsați un comentariu, ca să putem vorbi despre el. Sper să vă văd data viitoare!
De asemenea, aș dori să acord ceva credit lui Jeffrey Way. Mi-am folosit clasa ca o sursă de inspirație pentru clasa mea și pentru acest tutorial. De asemenea, aș dori să acord un anumit credit Tammy Hart, pentru construirea tutorialului cu meta-boxuri reutilizabile. Uitați-vă la munca lor.
