Développement orienté objet avec WordPress

Le code orienté objet est partout et WordPress ne fait pas exception.

Le cœur de WordPress est construit sur des séries d'objets / classes utilisées pour contrôler tout, de la manipulation de la base de données à l'apparence de votre site.

Tout au long de ce tutoriel, nous examinerons la conception orientée objet et comment vous pouvez les utiliser dans des applications pratiques lors du développement de WordPress, y compris:

• comprendre exactement ce qu'est la conception orientée objet.
• Discuter de la raison pour laquelle nous devons utiliser la conception orientée objet.
• Examiner un exemple du monde réel pour montrer comment cela peut fonctionner.

Remarque 1: Notez également que ce tutoriel décrit principalement les concepts centrés sur WordPress, donc si vous êtes entièrement nouveau dans la conception orientée objet, vous devriez probablement obtenir un aperçu rapide de OO via le guide de référence PHP.

Remarque 2: Si vous souhaitez tout télécharger tout de suite, n'hésitez pas à télécharger la source à partir de mon référentiel GitHub et à suivre le tutoriel.

Sautons directement dedans!

Les plats clés

• Conception orientée objet (OOD) Dans les fonctions et informations liées aux groupes WordPress dans les classes, améliorant l'organisation et la maintenance du code.
• OOD offre des avantages tels qu'une meilleure organisation par l'encapsulation, l'évolutivité via l'héritage et la modularité pour une réutilisation et une gestion de code plus faciles.
• Le tutoriel fournit un exemple pratique de la création d'une vitrine d'événements personnalisée dans WordPress, démontrant la mise en œuvre des principes OOD.
• Les étapes de clé de l'exemple incluent la configuration d'une structure de répertoire, la création de fichiers de classe et la mise en œuvre de fonctions pour ajouter et afficher des types de contenu personnalisés et des méta-box.
• Le guide met l'accent sur les avantages de l'OOD par rapport à la programmation procédurale, en mettant en évidence l'organisation, l'évolutivité et la modularité.
• Le tutoriel se termine par un appel à l'action pour télécharger le code source de GitHub, encourageant les lecteurs à appliquer les concepts OOD démontrés dans leurs projets de développement WordPress.

Qu'est-ce que la conception orientée objet de toute façon?

La conception de l'orientation des objets (conception OO) est une méthodologie différente pour résoudre les problèmes, distinct de l'approche procédurale traditionnelle.

Avec la conception orientée objet, vous créez une structure (classe) qui regroupera toutes vos fonctions (méthodes) et informations (propriétés) pour résoudre un problème.

Ceci est différent du développement procédural dans lequel vous créez des fonctions et des variables pour résoudre les problèmes, cependant, ces éléments peuvent être séparés sur plusieurs fichiers, redéclarés et souvent liés de manière lâche.

En un mot, la conception orientée objet consiste à rassembler les fonctionnalités connexes en un seul endroit afin qu'il puisse être maintenu, étendu et utilisé à partir d'un seul emplacement.

Pourquoi l'orientation des objets est une bonne idée?

Étant donné que le code procédural a bien fonctionné, vous vous demandez peut-être quel est l'intérêt de se développer dans une approche orientée objet?

Bien qu'il n'y ait rien de «mal» avec la conception procédurale, il y a plusieurs avantages à se développer dans un style plus orienté objet.

Organisation

Votre code est généralement mieux organisé lors de l'utilisation d'une approche orientée objet. La création de classes signifie que la fonctionnalité de résolution de votre problème est tout dans un fichier (contrairement au développement procédural où vous pouvez avoir des fonctions et des variables partout).

Avoir tout votre code en un seul endroit vous aide à garder les choses organisées et aide les autres développeurs qui peuvent venir et avoir besoin de comprendre comment fonctionne votre système.

Il n'y a rien de pire que de prendre un projet et de devoir trouver pour trouver les fonctions et variables utilisées pour créer divers éléments du site (qui sont invariablement répartis sur plusieurs fichiers pour des raisons inconnues).

Évolutivité

Lors de la résolution de problèmes avec une approche orientée objet, vous créez des classes.

Ces classes peuvent être élargies ou mises à l'échelle en les étendant en utilisant l'héritage. L'héritage vous permettra de créer une classe basée sur une autre classe qui donne accès à toutes ses propriétés et méthodes à la nouvelle classe.

Vous pouvez étendre une classe pour effectuer des fonctionnalités supplémentaires, ou même remplacer ses méthodes et propriétés pour répondre à la situation.

Avec le code procédural, vous devez soit refacter la partie de votre code, soit créer entièrement un nouveau code pour gérer des situations supplémentaires.

Modularité

Le but de la conception orientée objet est d'encapsuler toutes les fonctionnalités pour résoudre une situation en classe.

Étant donné que tout le code pour résoudre un problème est à l'intérieur d'une classe et que cette classe généralement dans son propre fichier PHP, vous pouvez prendre un fichier entier et l'utiliser dans un autre endroit, donc il est de nature modulaire.

L'avantage de ceci est que si vous écrivez assez bien des cours, vous devriez être en mesure de les réutiliser plus tard et que vous n'avez qu'à effectuer de légères personnalisations.

Bien que vous puissiez copier et coller du code de procédure, il n'est généralement pas aussi bien organisé et vous devrez peut-être passer par plusieurs fichiers pour vous assurer que vous avez la fonctionnalité nécessaire.

Exemple de scénario - Création d'une vitrine d'événement simple

Dans ce scénario, notre client veut un emplacement sur son site Web où il peut créer et gérer des événements. Ces événements seront utilisés pour promouvoir les nuits de trivia à venir, les compétitions de bingo et d'autres activités amusantes.

Les premières étapes consistent à décomposer les fonctionnalités souhaitées afin que nous puissions planifier notre solution (bien planifier ici aidera notre approche orientée objet à l'avenir). Dans notre scénario, nous pouvons voir l'ensemble de tâches suivant:

• Créez un type de contenu personnalisé pour gérer ces «événements».
• Ajouter des méta-boîtes supplémentaires pour gérer le traitement des informations supplémentaires.
• Enregistrer les méta-informations supplémentaires.
• Afficher les méta-informations pour nos «événements».

Nous pouvons créer un plugin ou nous pouvons modifier le thème de l'enfant pour fournir cette fonctionnalité.

Pour ce scénario, nous créerons nos fonctionnalités à l'intérieur d'un fichier que nous pouvons ensuite inclure dans le thème de l'enfant. J'ai choisi cette méthode parce que nous voulons éditer nos modèles de thème afin que nous puissions sortir nos informations d'événement supplémentaires.

La configuration de votre répertoire et la création de vos fichiers

Parce que nous voulons que tout soit facilement géré et modulaire, commençons par configurer la structure du dossier à l'intérieur du thème de l'enfant.

Un moyen facile d'organiser tout est de créer un répertoire inclue dans le thème de votre enfant. Ce répertoire contiendra d'autres code ou fonctionnalités que votre thème inclura / implémentera (vous pouvez appeler cela comme vous voulez, le but est d'avoir un seul répertoire à l'intérieur du thème).

À l'intérieur de ce répertoire, nous devons créer un autre dossier, cette fois appelé Event_showcase. C'est à l'intérieur de ce dossier que nous placerons tous nos fichiers applicables pour ce scénario. Nous aurons également besoin d'un dossier JS et CSS.

L'organisation de vos fonctionnalités dans des dossiers signifiera qu'à l'avenir, vous pouvez voir plus facilement quelles modules / fonctionnalités que votre thème implémente. Par exemple, vous voudrez peut-être implémenter un autre ensemble de fonctionnalités pour votre thème, vous pouvez simplement ajouter un nouveau dossier et logiquement tout est soigneusement organisé.

Créons les fichiers pour notre exemple et faisons-les dans leurs répertoires corrects

• event_showcase_class.php
• event_showcase_admin_styles.css
• event_showcase_admin_scripts.js
• event_showcase_public_styles.css
• event_showcase_public_scripts.js

vous devriez avoir quelque chose de similaire à ci-dessous:

Plus tard, vous devrez télécharger et placer le script et le style JQuery Time Picker à l'intérieur de ce répertoire. Ne vous inquiétez pas pour l'instant.

Chargement de vos fichiers dans WordPress

Avec la configuration de nos fichiers, nous devons maintenant les inclure à l'intérieur du thème de notre enfant.

Ouvrez les fonctions de votre thème d'enfant.PHP et placez le code suivant en haut ou en bas

<span>//Theme functions for child theme
</span>
<span>//load our event showcase class
</span><span>$event_showcase = get_stylesheet_directory() . '/includes/event_showcase/event_showcase_class.php';
</span><span>include($event_showcase);</span>

Cela chargera le fichier de classe principale qui décrira nos fonctionnalités. À l'intérieur de cette classe, nous gérerons le script et le style en cours avec d'autres éléments.

Création de contour de votre classe

Notre fichier de classe appelé event_showcase_class.php contiendra la majorité des fonctionnalités utilisées pour notre système d'événements; En tant que tel, c'est une bonne idée de cartographier un aperçu de base des méthodes et des propriétés dont nous aurons besoin pour que cela fonctionne.

Copiez le code suivant dans votre fichier de classe.

<span>//Theme functions for child theme
</span>
<span>//load our event showcase class
</span><span>$event_showcase = get_stylesheet_directory() . '/includes/event_showcase/event_showcase_class.php';
</span><span>include($event_showcase);</span>

Passons à travers les méthodes et les propriétés afin que nous puissions comprendre le flux de processus:

• Variables - Nous déclarons quelques variables pour rendre la classe plus modulaire (afin que nous puissions copier ce fichier et modifier quelques propriétés et la classe gère les autres modifications).
• __ Construct () - Tous nos crochets, filtres et code initialisant entreront ici.
• set_directory_value () - Définit notre propriété de répertoire qui nous permettra d'obtenir facilement des fichiers que nous placons dans nos répertoires CSS ou JS.
• check_flush_rewrite_rules () - gère le rinçage des jolis permalinks lorsque nous ajoutons notre type de contenu (ce qui fait fonctionner les nouveaux éléments).
• enqueue_public_scripts_and_styles () - Charge nos scripts et styles face au public.
• enqueue_admin_scripts_and_styles () - charge les scripts et les styles d'administration.
• add_content_type () - définit le nouveau type de contenu que nous créons.
• add_meta_boxes_for_content_type () - ajoute les méta-boîtes pour notre nouveau type de contenu.
• display_function_for_content_type_meta_box - construit l'interface d'administration à fond pour le type de contenu afin que nous puissions enregistrer des informations supplémentaires.
• Save_Custom_Content_Type ($ post_id) - gère la sauvegarde du type de contenu personnalisé (et de nos méta-informations).
• display_additional_meta_data () - affiche les méta-informations enregistrées à l'avant.

passons maintenant et mettons à jour ces éléments et décrivons le code

les propriétés de classe

Nous déclarons certaines propriétés au sommet de notre classe qui seront référencées via nos méthodes. Le but de ceux-ci est qu'ils facilitent la réduction de cette classe et changent sa fonctionnalité à l'avenir.

<span>/*
</span><span> * Event Showcase
</span><span> * Creates an 'event' content type to showcase upcoming functions and information
</span><span> * Uses hooks and filters inside your theme to output relevant information
</span><span> */
</span> 
 <span>class event_showcase{
</span> 	
	<span>//variables
</span>	<span>private $directory = '';
</span>	<span>private $singular_name = 'event';
</span>	<span>private $plural_name = 'events';
</span>	<span>private $content_type_name = 'event_showcase';
</span>	
	<span>//magic function, called on creation
</span>	<span>public function __construct(){}
</span>	<span>//sets the directory (path) so that we can use this for our enqueuing
</span>	<span>public function set_directory_value(){}
</span>	<span>//check if we need to flush rewrite rules
</span>	<span>public function check_flush_rewrite_rules(){}
</span>	<span>//enqueue public scripts and styles
</span>	<span>public function enqueue_public_scripts_and_styles(){}
</span>	<span>//enqueue admin scripts and styles
</span>	<span>public function enqueue_admin_scripts_and_styles(){}
</span>	<span>//adding our new content type
</span>	<span>public function add_content_type(){}
</span>	<span>//adding meta box to save additional meta data for the content type
</span>	<span>public function add_meta_boxes_for_content_type(){}
</span>	<span>//displays the visual output of the meta box in admin (where we will save our meta data)
</span>	<span>public function display_function_for_content_type_meta_box($post){}
</span>	<span>//when saving the custom content type, save additional meta data
</span>	<span>public function save_custom_content_type($post_id){}
</span>	<span>//display additional meta information for the content type
</span>	<span>//@hooked using 'display_additional_meta_data' in theme
</span>	<span>function display_additional_meta_data(){}
</span> <span>}
</span> 
 <span>//create new object 
</span> <span>$event_showcase = new event_showcase;</span>

__ Construction ()

Notre fonction __construct est une fonction magique. Ces fonctions sont des fonctions PHP5 spéciales auxquelles les classes peuvent accéder pour effectuer des actions spécifiques.

tous commencent par le double soulignement avant leur nom et peuvent être éventuellement inclus dans n'importe quelle définition de classe. Il est préférable de comprendre toutes les fonctions magiques pour une autre discussion (voici un autre article sur les fonctions magiques et les constantes).

La fonction __Contruct est appelée dès qu'une classe est initialisée, c'est donc la première fonction qui sera déclenchée. C'est ici que nous ajoutons tous nos crochets, filtres et logique de démarrage. Mettez à jour le plan de base avec le code suivant.

<span>//variables
</span><span>private $directory = '';	
</span><span>private $singular_name = 'event';
</span><span>private $plural_name = 'events';
</span><span>private $content_type_name = 'event_showcase';</span>

Vous pensez peut-être que l'add_action semble un peu différent de ce que vous avez peut-être vu auparavant et que vous avez raison.

Lorsque vous utilisez des appels add_action et add_filter à l'intérieur d'une classe, vous devez fournir le deuxième argument dans un tableau. La première valeur du tableau est la $ cette variable (c'est-à-dire la classe elle-même) et le second est le nom de la fonction qui sera utilisé (enveloppé dans les devis).

Pour plus d'informations, consultez la note de bas de page de classe pour la fonction add_action sur le codex WordPress.

set_directory_value ()

Étant donné que nous entendrons CSS et JS, il est logique de stocker l'URL du répertoire de fichiers dans une variable à laquelle nous pouvons accéder. Notre structure de répertoire est / inclut / event_showcase, mais il peut personnaliser en fonction de votre structure.

<span>//Theme functions for child theme
</span>
<span>//load our event showcase class
</span><span>$event_showcase = get_stylesheet_directory() . '/includes/event_showcase/event_showcase_class.php';
</span><span>include($event_showcase);</span>

check_flush_rewrite_rules ()

Puisque nous ajoutons un type de contenu personnalisé, nous devons gérer de jolis permaliens; Ces permaliens sont des réécritures qui rendent votre URL de page moins moche (au lieu d'avoir http://mywebsite.com.au/?p=123, vous pouvez avoir http://mywebsite.com.au/my-event).

La réécriture garantit que vos types de contenu sont convertis en joli format, cependant, cette réécriture est coûteuse et si elle peut ralentir excessivement votre site. Parce que la réécriture peut affecter votre site, elle n'est généralement modifiée que sur l'activation ou la désactivation du thème / du plugin.

Puisque vous ne voudrez peut-être pas mettre à jour manuellement vos permaliens, cette fonction demande à WordPress de le faire automatiquement et une seule fois (après que votre nouveau type de contenu a été ajouté).

Cette fonction vérifiera si le site Web doit être rincé via une option de thème. Si une chasse d'eau est requise, elle mettra à jour les permaliens, puis définisse la valeur de l'option sur false (donc elle ne se déclenche qu'une seule fois, pas à chaque fois que nous chargeons une page).

<span>/*
</span><span> * Event Showcase
</span><span> * Creates an 'event' content type to showcase upcoming functions and information
</span><span> * Uses hooks and filters inside your theme to output relevant information
</span><span> */
</span> 
 <span>class event_showcase{
</span> 	
	<span>//variables
</span>	<span>private $directory = '';
</span>	<span>private $singular_name = 'event';
</span>	<span>private $plural_name = 'events';
</span>	<span>private $content_type_name = 'event_showcase';
</span>	
	<span>//magic function, called on creation
</span>	<span>public function __construct(){}
</span>	<span>//sets the directory (path) so that we can use this for our enqueuing
</span>	<span>public function set_directory_value(){}
</span>	<span>//check if we need to flush rewrite rules
</span>	<span>public function check_flush_rewrite_rules(){}
</span>	<span>//enqueue public scripts and styles
</span>	<span>public function enqueue_public_scripts_and_styles(){}
</span>	<span>//enqueue admin scripts and styles
</span>	<span>public function enqueue_admin_scripts_and_styles(){}
</span>	<span>//adding our new content type
</span>	<span>public function add_content_type(){}
</span>	<span>//adding meta box to save additional meta data for the content type
</span>	<span>public function add_meta_boxes_for_content_type(){}
</span>	<span>//displays the visual output of the meta box in admin (where we will save our meta data)
</span>	<span>public function display_function_for_content_type_meta_box($post){}
</span>	<span>//when saving the custom content type, save additional meta data
</span>	<span>public function save_custom_content_type($post_id){}
</span>	<span>//display additional meta information for the content type
</span>	<span>//@hooked using 'display_additional_meta_data' in theme
</span>	<span>function display_additional_meta_data(){}
</span> <span>}
</span> 
 <span>//create new object 
</span> <span>$event_showcase = new event_showcase;</span>

enqueue_public_scripts_and_styles ()

Cette fonction gère l'agrandissement des scripts et des styles du site Web sur le front-end.

Nous utilisons le nom du type de contenu dans les appels d'effondrement afin qu'il n'y ait pas de conflits de nommage avec d'autres plugins (car il se traduira par quelque chose d'unique, c'est-à-dire `event_showcase_public_scripts`).

Nous appelons à la fois wp_enqueue_style et wp_enqueue_script pour charger nos ressources.

Nous utilisons également les propriétés de répertoire $ et de contenu_type_name lors du chargement de nos ressources.

<span>//variables
</span><span>private $directory = '';	
</span><span>private $singular_name = 'event';
</span><span>private $plural_name = 'events';
</span><span>private $content_type_name = 'event_showcase';</span>

enqueue_admin_scripts_and_styles ()

Cette fonction gère l'agrandissement des scripts et des styles du site Web sur le back-end admin.

Nous vérifions si nous sommes sur un écran d'édition ou un nouvel écran pour notre type de contenu et procédons uniquement si nous sommes (pas besoin de charger des ressources lorsque nous ne sommes pas sur la bonne page).

Nous appelons à la fois wp_enqueue_style et wp_enqueue_script pour charger nos ressources, essentiellement la même que notre fonction de face publique.

Pour cet exemple, j'utilise à la fois le jQuery UI DatePicker (une partie de la bibliothèque d'interface utilisateur jQuery) et le cueilleur de temps jQuery UI (conçu pour avoir un style similaire à celle du sélecteur de dattes).

Allez télécharger la bibliothèque Time Picker à partir du lien ci-dessus et incluez le fichier CSS et JS pertinent dans votre répertoire.

<span>//magic function, called on creation
</span><span>public function __construct(){
</span>	
	<span>$this->set_directory_value(); //set the directory url on creation
</span>	<span>add_action('init', array($this,'add_content_type')); //add content type
</span>	<span>add_action('init', array($this,'check_flush_rewrite_rules')); //flush re-write rules for permalinks (because of content type)
</span>	<span>add_action('add_meta_boxes', array($this,'add_meta_boxes_for_content_type')); //add meta boxes 
</span>	<span>add_action('wp_enqueue_scripts', array($this,'enqueue_public_scripts_and_styles')); //enqueue public facing elements
</span>	<span>add_action('admin_enqueue_scripts', array($this, 'enqueue_admin_scripts_and_styles')); //enqueues admin elements
</span>	<span>add_action('save_post_' . $this->content_type_name, array($this,'save_custom_content_type')); //handles saving of content type meta info
</span>	<span>add_action('display_content_type_meta', array($this,'display_additional_meta_data')); //displays the saved content type meta info	
</span><span>}</span>

add_content_type ()

Nous déclarons notre type de contenu personnalisé dans cette fonction.

La fonction utilise les $ Sinking_name, $ Plural_name et $ content_type_nameproperties pour faciliter l'enregistrement de ce nouveau type de post.

Structurer la fonction d'enregistrement comme ceci signifie que vous pouvez facilement changer et enregistrer un type de poste en ne supportant que quelques informations.

Pour un contour plus détaillé sur l'enregistrement des types de contenu personnalisés, veuillez consulter le codex WordPress pour la fonction register_post_type

<span>//Theme functions for child theme
</span>
<span>//load our event showcase class
</span><span>$event_showcase = get_stylesheet_directory() . '/includes/event_showcase/event_showcase_class.php';
</span><span>include($event_showcase);</span>

Une fois que vous avez ajouté cette étape, vous devriez voir qu'un nouvel élément a été ajouté au menu WordPress back-end.

add_meta_boxes_for_content_type ()

Nous ajoutons les méta-boîtes dont nous avons besoin pour notre type de contenu ici. Nous appelons la fonction add_meta_box et lui fournissons des fonctionnalités out. La nouvelle est que nous l'utilisons pour créer une nouvelle boîte d'administration pour contenir nos nouveaux éléments de formulaire que nous voulons enregistrer.

<span>/*
</span><span> * Event Showcase
</span><span> * Creates an 'event' content type to showcase upcoming functions and information
</span><span> * Uses hooks and filters inside your theme to output relevant information
</span><span> */
</span> 
 <span>class event_showcase{
</span> 	
	<span>//variables
</span>	<span>private $directory = '';
</span>	<span>private $singular_name = 'event';
</span>	<span>private $plural_name = 'events';
</span>	<span>private $content_type_name = 'event_showcase';
</span>	
	<span>//magic function, called on creation
</span>	<span>public function __construct(){}
</span>	<span>//sets the directory (path) so that we can use this for our enqueuing
</span>	<span>public function set_directory_value(){}
</span>	<span>//check if we need to flush rewrite rules
</span>	<span>public function check_flush_rewrite_rules(){}
</span>	<span>//enqueue public scripts and styles
</span>	<span>public function enqueue_public_scripts_and_styles(){}
</span>	<span>//enqueue admin scripts and styles
</span>	<span>public function enqueue_admin_scripts_and_styles(){}
</span>	<span>//adding our new content type
</span>	<span>public function add_content_type(){}
</span>	<span>//adding meta box to save additional meta data for the content type
</span>	<span>public function add_meta_boxes_for_content_type(){}
</span>	<span>//displays the visual output of the meta box in admin (where we will save our meta data)
</span>	<span>public function display_function_for_content_type_meta_box($post){}
</span>	<span>//when saving the custom content type, save additional meta data
</span>	<span>public function save_custom_content_type($post_id){}
</span>	<span>//display additional meta information for the content type
</span>	<span>//@hooked using 'display_additional_meta_data' in theme
</span>	<span>function display_additional_meta_data(){}
</span> <span>}
</span> 
 <span>//create new object 
</span> <span>$event_showcase = new event_showcase;</span>

display_function_for_content_type_meta_box ($ post)

Nous utilisons cette fonction pour publier les options de back-end pour la nouvelle méta-information pour notre type de contenu.

Pour notre exemple, nous collectons des dates, des temps et d'autres informations sur l'événement que nous montrerons à l'utilisateur final.

Nous commençons par collecter toutes les méta du post supplémentaire en variables et affichant la sortie du formulaire HTML. Certains de ces champs déclencheront l'interface de sélecteur de date et d'autres déclencheront le sélecteur de temps (déterminé par la classe utilisée sur l'élément).

De plus, nous définissons un champ non -ce afin que nous puissions vérifier sur Save si la demande provient de cette page.

<span>//variables
</span><span>private $directory = '';	
</span><span>private $singular_name = 'event';
</span><span>private $plural_name = 'events';
</span><span>private $content_type_name = 'event_showcase';</span>

Lorsque vous avez terminé cette étape, vous devriez voir que la nouvelle méta-boîte vide a été transformée et peut maintenant contenir toutes nos nouvelles informations.

Save_Custom_Content_Type ($ post_id)

Voici où nous enregistrons nos métadonnées supplémentaires pour notre type de contenu personnalisé.

Nous vérifions d'abord le nonce que nous avons ajouté dans notre méta-boîte et vérifions son authenticité. Après cela, nous vérifions que nous ne faisons pas de sauvetage automatique et que l'utilisateur peut réellement modifier cette page. Si tous ces chèques sont passés, nous avançons.

Nous collectons toutes nos valeurs en variables et les désinfectant à l'aide de la fonction Sensize_Text_field. Après cela, nous appelons la fonction update_post_meta pour enregistrer nos données.

<span>//magic function, called on creation
</span><span>public function __construct(){
</span>	
	<span>$this->set_directory_value(); //set the directory url on creation
</span>	<span>add_action('init', array($this,'add_content_type')); //add content type
</span>	<span>add_action('init', array($this,'check_flush_rewrite_rules')); //flush re-write rules for permalinks (because of content type)
</span>	<span>add_action('add_meta_boxes', array($this,'add_meta_boxes_for_content_type')); //add meta boxes 
</span>	<span>add_action('wp_enqueue_scripts', array($this,'enqueue_public_scripts_and_styles')); //enqueue public facing elements
</span>	<span>add_action('admin_enqueue_scripts', array($this, 'enqueue_admin_scripts_and_styles')); //enqueues admin elements
</span>	<span>add_action('save_post_' . $this->content_type_name, array($this,'save_custom_content_type')); //handles saving of content type meta info
</span>	<span>add_action('display_content_type_meta', array($this,'display_additional_meta_data')); //displays the saved content type meta info	
</span><span>}</span>

display_additional_meta_data ()

Cette fonction affiche la méta-information enregistrée pour un seul message de notre nouveau type de contenu (événement unique).

Nous avons défini une nouvelle action appelée affichage_content_type_meta à l'intérieur de notre fonction __CONSTRUCT, voici à quoi il ressemblait:

<span>//sets the directory (path) so that we can use this for our enqueuing
</span><span>public function set_directory_value(){
</span>	<span>$this->directory = get_stylesheet_directory_uri() . '/includes/event_showcase';
</span><span>}</span>

La deuxième valeur de cette action a été appelée affichage_additional_meta_data et correspond à cette fonction. Cela signifie que chaque fois que quelqu'un appelle DO_Action ('display_content_type_meta'); Il appellera cette fonction et affichera le nouveau post Meta Information.

Vous pouvez appeler DO_ACTION ('display_content_type_meta'); de n'importe où à l'intérieur de votre thème (tant que vous êtes sur un seul article de ce type de contenu) et il affichera les méta-informations.

J'utilise un thème parent de vingt-treize, donc je m'accroche au contenu.php du thème de l'enfant pour mon affichage.

Cette fonction obtiendra le Global $ POST et $ POST_TYPE et vérifiera que l'élément actuel visualisé est de notre nouveau type de contenu.

Après cela, la fonction collecte les méta-informations et l'affiche (effectuant quelques vérifications rapides en cours de route.

<span>//Theme functions for child theme
</span>
<span>//load our event showcase class
</span><span>$event_showcase = get_stylesheet_directory() . '/includes/event_showcase/event_showcase_class.php';
</span><span>include($event_showcase);</span>

Fichiers supplémentaires, CSS et JS

Maintenant que la majeure partie de la fonctionnalité a été achevée, échangeons-nous dans nos fichiers CSS et JS pour ajouter rapidement des styles et de l'interactivité.

event_showcase_admin_styles.css

<span>/*
</span><span> * Event Showcase
</span><span> * Creates an 'event' content type to showcase upcoming functions and information
</span><span> * Uses hooks and filters inside your theme to output relevant information
</span><span> */
</span> 
 <span>class event_showcase{
</span> 	
	<span>//variables
</span>	<span>private $directory = '';
</span>	<span>private $singular_name = 'event';
</span>	<span>private $plural_name = 'events';
</span>	<span>private $content_type_name = 'event_showcase';
</span>	
	<span>//magic function, called on creation
</span>	<span>public function __construct(){}
</span>	<span>//sets the directory (path) so that we can use this for our enqueuing
</span>	<span>public function set_directory_value(){}
</span>	<span>//check if we need to flush rewrite rules
</span>	<span>public function check_flush_rewrite_rules(){}
</span>	<span>//enqueue public scripts and styles
</span>	<span>public function enqueue_public_scripts_and_styles(){}
</span>	<span>//enqueue admin scripts and styles
</span>	<span>public function enqueue_admin_scripts_and_styles(){}
</span>	<span>//adding our new content type
</span>	<span>public function add_content_type(){}
</span>	<span>//adding meta box to save additional meta data for the content type
</span>	<span>public function add_meta_boxes_for_content_type(){}
</span>	<span>//displays the visual output of the meta box in admin (where we will save our meta data)
</span>	<span>public function display_function_for_content_type_meta_box($post){}
</span>	<span>//when saving the custom content type, save additional meta data
</span>	<span>public function save_custom_content_type($post_id){}
</span>	<span>//display additional meta information for the content type
</span>	<span>//@hooked using 'display_additional_meta_data' in theme
</span>	<span>function display_additional_meta_data(){}
</span> <span>}
</span> 
 <span>//create new object 
</span> <span>$event_showcase = new event_showcase;</span>

event_showcase_public_styles.css

<span>//variables
</span><span>private $directory = '';	
</span><span>private $singular_name = 'event';
</span><span>private $plural_name = 'events';
</span><span>private $content_type_name = 'event_showcase';</span>

event_showcase_admin_scripts.js

<span>//magic function, called on creation
</span><span>public function __construct(){
</span>	
	<span>$this->set_directory_value(); //set the directory url on creation
</span>	<span>add_action('init', array($this,'add_content_type')); //add content type
</span>	<span>add_action('init', array($this,'check_flush_rewrite_rules')); //flush re-write rules for permalinks (because of content type)
</span>	<span>add_action('add_meta_boxes', array($this,'add_meta_boxes_for_content_type')); //add meta boxes 
</span>	<span>add_action('wp_enqueue_scripts', array($this,'enqueue_public_scripts_and_styles')); //enqueue public facing elements
</span>	<span>add_action('admin_enqueue_scripts', array($this, 'enqueue_admin_scripts_and_styles')); //enqueues admin elements
</span>	<span>add_action('save_post_' . $this->content_type_name, array($this,'save_custom_content_type')); //handles saving of content type meta info
</span>	<span>add_action('display_content_type_meta', array($this,'display_additional_meta_data')); //displays the saved content type meta info	
</span><span>}</span>

Fonctionnalité terminée en action!

Lorsque tout est assemblé, vous devriez être en mesure de créer un nouvel «événement» avec des métadonnées supplémentaires. Lorsque vous visualisez votre événement, vous devriez voir quelque chose sur mon échantillon ci-dessous

Vous pouvez voir le sous-titre, les dates, les temps et les données de billets supplémentaires.

étendre un type de publication de base comme celui-ci et ajouter des éléments supplémentaires aide à créer un site Web beaucoup plus interactif et facile à gérer. L'utilisateur ne devra plus ajouter toutes ces informations via la zone de contenu qui peut être désordonnée, difficile à utiliser et incohérente. Ils ont maintenant une simple interface facile à gérer.

où à partir d'ici?

Maintenant que vous avez vu un exemple pratique de conception orientée objet et à quel point il peut être facile d'améliorer votre développement, vous pouvez appliquer ces compétences et créer de meilleurs thèmes et plugins.

Vous voudrez peut-être télécharger la source de cet exemple à partir de ma page GitHub, puis la modifier convient à un projet à venir ou l'étendre pour fournir des fonctionnalités supplémentaires.

J'espère que cet article vous aidera à planifier votre développement et à voir comment une méthodologie orientée objet peut vous faire gagner du temps et des efforts.

Les questions fréquemment posées sur le développement orienté objet avec WordPress

Qu'est-ce que la programmation orientée objet (OOP) dans WordPress?

La programmation orientée objet (OOP) dans WordPress est un style de programmation qui utilise des «objets» - des instances de classes, qui sont comme des Blueprints. Ces objets sont utilisés pour interagir les uns avec les autres pour concevoir des applications et des logiciels. La POO dans WordPress est bénéfique car elle fournit une structure modulaire claire pour les programmes qui le rend bon à définir des données abstraites où les détails de l'implémentation sont masqués et l'unité a une interface clairement définie.

En quoi la programmation orientée objet diffère-t-elle de la programmation procédurale dans WordPress?

La programmation procédurale dans WordPress implique la rédaction d'une liste d'instructions pour que l'ordinateur suive étape par étape afin d'accomplir une tâche. D'un autre côté, la programmation orientée objet organise un programme autour de ses données (objets) et un ensemble d'interfaces bien définies à ces données. Cette approche facilite la gestion et le contrôle des applications complexes en les décomposant en pièces plus petites et réutilisables.

Quel est le cache d'objet WordPress?

Le cache d'objet WordPress est un système qui améliore WordPress Performances en stockant les données de la base de données en mémoire pour éviter les requêtes inutiles. Cela peut accélérer considérablement WordPress car il réduit la charge sur la base de données.

Comment puis-je supprimer OBJ dans une boîte dans WordPress?

Pour supprimer l'OBJ dans une boîte dans WordPress, vous pouvez utiliser Diverses méthodes telles que la désactivation du cache d'objet, l'utilisation d'un plugin ou le supprimer manuellement du code. Cependant, il est important de noter que cela devrait être fait attentivement pour éviter de casser votre site.

Comment puis-je implémenter la programmation orientée objet dans mon thème WordPress?

Pour implémenter une programmation orientée objet dans Votre thème WordPress, vous devez définir des classes et des méthodes dans votre fichier functions.php ou dans des fichiers de modèle individuels. Ces classes et méthodes peuvent ensuite être utilisées pour créer des objets, qui peuvent interagir les uns avec les autres pour effectuer des tâches.

Quels sont les avantages de l'utilisation de la programmation orientée objet dans WordPress?

La programmation dans WordPress offre plusieurs avantages. Il rend le code plus compact, plus facile à comprendre et plus facile à entretenir. Il permet également de créer des fonctionnalités plus complexes avec moins de code. De plus, il permet une meilleure analyse des données, un codage plus précis et un développement plus rapide.

Que signifie 'OBJ' qui apparaît dans le titre de poste dans WordPress?

Le 'OBJ' qui apparaît Dans le titre de publication dans WordPress est généralement le résultat d'un conflit avec un plugin ou un thème. Ce n'est pas une partie standard de WordPress, et il peut être supprimé en identifiant et en résolvant le conflit.

Comment puis-je apprendre la programmation orientée objet pour WordPress?

Il existe de nombreuses ressources disponibles pour apprendre Programmation orientée objet pour WordPress. Cela comprend des tutoriels, des cours et des livres en ligne. Vous pouvez également apprendre en examinant le code de base WordPress, car il est écrit en utilisant les principes OOP.

est la programmation orientée objet nécessaire pour le développement WordPress?

Alors que la programmation orientée objet n'est pas strictement nécessaire pour Développement WordPress, il est fortement recommandé. L'utilisation de principes OOP peut aider à rendre votre code plus lisible, réutilisable et plus facile à entretenir. Cela peut également vous aider à mieux comprendre le code de base WordPress.

Puis-je utiliser une programmation orientée objet avec des plugins WordPress?

Oui, vous pouvez utiliser une programmation orientée objet avec des plugins WordPress. En fait, de nombreux plugins WordPress sont écrits à l'aide de principes OOP. Cela permet des fonctionnalités plus complexes et peut rendre le code du plugin plus facile à gérer et à maintenir.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!