Documentation continue du plugin WordPress : Programmation orientée objet II

À ce stade de la série, nous sommes prêts à compléter notre plugin en documentant nos fichiers, classes, fonctions, variables, etc.

Bien qu'il s'agisse de la dernière étape où nous devons réellement terminer le plugin, ce n'est pas le dernier article de la série car nous continuerons à examiner certains sujets avancés en programmation orientée objet.

Mais avant cela, mettons en pratique tout ce que nous avons appris dans l’article précédent et mettons à jour notre plugin vers la version 1.0.

Bien sûr, comme pour tous les articles all précédents, je vous recommande de rester au courant de tout ce que nous avons couvert jusqu'à présent, afin que vous puissiez pleinement comprendre non seulement ce que nous avons fait dans l'article précédent, mais aussi comment nous le faisons réellement. j'y suis arrivé Le dernier point abordé dans cet article.

1. Présentation
2. Cours
3. Type
4. Structure de contrôle : instruction conditionnelle
5. Structure de contrôle : boucle
6. Fonctions et propriétés
7. Portée
8. Builder le plugin I
9. Construire le plugin II
10. Plugin d'enregistrement I

Après avoir compris et examiné tout cela, commençons à documenter chaque fichier.

Plugin d'enregistrement

Nous pouvons enregistrer ce plugin de différentes manières :

• Nous pouvons d'abord enregistrer tous les en-têtes de fichiers, puis revenir et enregistrer les classes, puis revenir et enregistrer les variables, puis enregistrer les fonctions.
• Nous pouvons enregistrer chaque fichier en même temps et avoir une brève discussion de tout ce qu'il contient.

Évidemment, cette option générera plus de documentation pour chaque partie, mais devrait donner lieu à un article moins ennuyeux et plus facile à comprendre le flux de contrôle de l'ensemble du plugin.

Pour ce faire, nous examinerons le plugin fichier par fichier, en introduisant la documentation pour chaque morceau de code dont nous disposons, puis nous discuterons de tous les points d'intérêt derrière le code.

Enfin, nous veillerons à référencer la version finale du plugin en fin d’article. Ceci étant dit, commençons.

Méta-gestionnaire de publication unique

Rappelons que le fichier principal qui démarre le plugin est le fichier single-post-meta-manager.php situé à la racine du répertoire du plugin.

Ce qui suit est la version entièrement documentée du fichier. Lisez attentivement chaque critique, en prêtant attention non seulement au format qu'elle suit, mais également au contenu qu'elle propose.

<?php
/**
 * The file responsible for starting the Single Post Meta Manager plugin
 *
 * The Single Post Meta Manager is a plugin that displays the post meta data
 * associated with a given post. This particular file is responsible for
 * including the necessary dependencies and starting the plugin.
 *
 * @package SPPM
 *
 * @wordpress-plugin
 * Plugin Name:       Single Post Meta Manager
 * Plugin URI:        https://github.com/tommcfarlin/post-meta-manager
 * Description:       Single Post Meta Manager displays the post meta data associated with a given post.
 * Version:           1.0.0
 * Author:            Tom McFarlin
 * Author URI:        http://tommcfarlin.com
 * Text Domain:       single-post-meta-manager-locale
 * License:           GPL-2.0+
 * License URI:       http://www.gnu.org/licenses/gpl-2.0.txt
 * Domain Path:       /languages
 */

// If this file is called directly, then about execution.
if ( ! defined( 'WPINC' ) ) {
    die;
}

/**
 * Include the core class responsible for loading all necessary components of the plugin.
 */
require_once plugin_dir_path( __FILE__ ) . 'includes/class-single-post-meta-manager.php';

/**
 * Instantiates the Single Post Meta Manager class and then
 * calls its run method officially starting up the plugin.
 */
function run_single_post_meta_manager() {

	$spmm = new Single_Post_Meta_Manager();
	$spmm->run();

}

// Call the above function to begin execution of the plugin.
run_single_post_meta_manager();

Dans le code ci-dessus, veuillez noter que nous avons défini l'en-tête du fichier selon la convention décrite dans l'article précédent. Nous maintenons également les balises d’en-tête du plugin requises afin que WordPress les lise correctement.

Notez que dans cet exemple, nous les avons inclus sous une balise @wordpress-plugin personnalisée. Ceci n'est pas obligatoire, mais permet de séparer les commentaires d'en-tête de fichier des commentaires requis du plugin.

Enfin, veuillez noter que nous avons mis à niveau la version de ce plugin vers 1.0，并且我们还为该插件指定了 @package 值="inline">SPMM il manque le Single Post Meta Manager. Nous l'utiliserons tout au long du plugin.

包含Table des matières

Ensuite, tournons notre attention vers tous les fichiers du répertoire include.

Étant donné que ces fichiers sont requis avant que quoi que ce soit puisse être géré dans le répertoire, il est logique d'examiner chacun de ces fichiers individuellement, puis de compléter notre discussion avec les fichiers restants dans le répertoire géré.

Méta-gestionnaire de publication unique

<?php

/**
 * The Single Post Meta Manager is the core plugin responsible for including and
 * instantiating all of the code that composes the plugin
 *
 * @package SPMM
 */

/**
 * The Single Post Meta Manager is the core plugin responsible for including and
 * instantiating all of the code that composes the plugin.
 *
 * The Single Post Meta Manager includes an instance to the Single Post Manager
 * Loader which is responsible for coordinating the hooks that exist within the
 * plugin.
 *
 * It also maintains a reference to the plugin slug which can be used in
 * internationalization, and a reference to the current version of the plugin
 * so that we can easily update the version in a single place to provide
 * cache busting functionality when including scripts and styles.
 *
 * @since    1.0.0
 */
class Single_Post_Meta_Manager {

    /**
	 * A reference to the loader class that coordinates the hooks and callbacks
	 * throughout the plugin.
	 *
	 * @access protected
	 * @var    Single_Post_Meta_Manager_Loader   $loader    Manages hooks between the WordPress hooks and the callback functions.
	 */
	protected $loader;

	/**
	 * Represents the slug of hte plugin that can be used throughout the plugin
	 * for internationalization and other purposes.
	 *
	 * @access protected
	 * @var    string   $plugin_slug    The single, hyphenated string used to identify this plugin.
	 */
	protected $plugin_slug;

	/**
	 * Maintains the current version of the plugin so that we can use it throughout
	 * the plugin.
	 *
	 * @access protected
	 * @var    string   $version    The current version of the plugin.
	 */
	protected $version;

	/**
	 * Instantiates the plugin by setting up the core properties and loading
	 * all necessary dependencies and defining the hooks.
	 *
	 * The constructor will define both the plugin slug and the verison
	 * attributes, but will also use internal functions to import all the
	 * plugin dependencies, and will leverage the Single_Post_Meta_Loader for
	 * registering the hooks and the callback functions used throughout the
	 * plugin.
	 */
	public function __construct() {

		$this->plugin_slug = 'single-post-meta-manager-slug';
		$this->version = '1.0.0';

		$this->load_dependencies();
		$this->define_admin_hooks();

	}



	/**
	 * Imports the Single Post Meta administration classes, and the Single Post Meta Loader.
	 *
	 * The Single Post Meta Manager administration class defines all unique functionality for
	 * introducing custom functionality into the WordPress dashboard.
	 *
	 * The Single Post Meta Manager Loader is the class that will coordinate the hooks and callbacks
	 * from WordPress and the plugin. This function instantiates and sets the reference to the
	 * $loader class property.
	 *
	 * @access    private
	 */
	private function load_dependencies() {

		require_once plugin_dir_path( dirname( __FILE__ ) ) . 'admin/class-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();

	}

	/**
	 * Defines the hooks and callback functions that are used for setting up the plugin stylesheets
	 * and the plugin's meta box.
	 *
	 * This function relies on the Single Post Meta Manager Admin class and the Single Post Meta Manager
	 * Loader class property.
	 *
	 * @access    private
	 */
	private function 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' );

	}

	/**
	 * Sets this class into motion.
	 *
	 * Executes the plugin by calling the run method of the loader class which will
	 * register all of the hooks and callback functions used throughout the plugin
	 * with WordPress.
	 */
	public function run() {
		$this->loader->run();
	}

	/**
	 * Returns the current version of the plugin to the caller.
	 *
	 * @return    string    $this->version    The current version of the plugin.
	 */
	public function get_version() {
		return $this->version;
	}

}

Évidemment, beaucoup de nouveaux commentaires ont été introduits dans ce fichier particulier ; cependant, le rôle de chaque attribut de classe, constructeur et fonction interne devrait être assez explicite.

Outre la manière dont les informations sont coordonnées via les plugins, l'élément clé à noter est la manière dont nous adhérons aux normes définies dans l'article précédent.

Mais veuillez noter que si certaines balises et/ou fonctionnalités de la documentation ne sont pas utilisées alors qu'elles ne sont pas pertinentes, nous nous permettons de les utiliser. Nous continuerons à le faire dans la suite de cet article.

Chargeur de méta-gestionnaire de publication unique

<?php

/**
 * The Single Post Meta Manager Loader is a class that is responsible for
 * coordinating all actions and filters used throughout the plugin
 *
 * @package    SPMM
 */

/**
 * The Single Post Meta Manager Loader is a class that is responsible for
 * coordinating all actions and filters used throughout the plugin.
 *
 * This class maintains two internal collections - one for actions, one for
 * hooks - each of which are coordinated through external classes that
 * register the various hooks through this class.
 *
 * @since    1.0.0
 */
class Single_Post_Meta_Manager_Loader {

    /**
	 * A reference to the collection of actions used throughout the plugin.
	 *
	 * @access protected
	 * @var    array    $actions    The array of actions that are defined throughout the plugin.
	 */
	protected $actions;

	/**
	 * A reference to the collection of filters used throughout the plugin.
	 *
	 * @access protected
	 * @var    array    $actions    The array of filters that are defined throughout the plugin.
	 */
	protected $filters;

	/**
	 * Instantiates the plugin by setting up the data structures that will
	 * be used to maintain the actions and the filters.
	 */
	public function __construct() {

		$this->actions = array();
		$this->filters = array();

	}

	/**
	 * Registers the actions with WordPress and the respective objects and
	 * their methods.
	 *
	 * @param  string    $hook        The name of the WordPress hook to which we're registering a callback.
	 * @param  object    $component   The object that contains the method to be called when the hook is fired.
	 * @param  string    $callback    The function that resides on the specified component.
	 */
	public function add_action( $hook, $component, $callback ) {
		$this->actions = $this->add( $this->actions, $hook, $component, $callback );
	}

	/**
	 * Registers the filters with WordPress and the respective objects and
	 * their methods.
	 *
	 * @param  string    $hook        The name of the WordPress hook to which we're registering a callback.
	 * @param  object    $component   The object that contains the method to be called when the hook is fired.
	 * @param  string    $callback    The function that resides on the specified component.
	 */
	public function add_filter( $hook, $component, $callback ) {
		$this->filters = $this->add( $this->filters, $hook, $component, $callback );
	}

	/**
	 * Registers the filters with WordPress and the respective objects and
	 * their methods.
	 *
	 * @access private
	 *
	 * @param  array     $hooks       The collection of existing hooks to add to the collection of hooks.
	 * @param  string    $hook        The name of the WordPress hook to which we're registering a callback.
	 * @param  object    $component   The object that contains the method to be called when the hook is fired.
	 * @param  string    $callback    The function that resides on the specified component.
	 *
	 * @return array                  The collection of hooks that are registered with WordPress via this class.
	 */
	private function add( $hooks, $hook, $component, $callback ) {

		$hooks[] = array(
			'hook'      => $hook,
			'component' => $component,
			'callback'  => $callback
		);

		return $hooks;

	}

	/**
	 * Registers all of the defined filters and actions with WordPress.
	 */
	public function run() {

		 foreach ( $this->filters as $hook ) {
			 add_filter( $hook['hook'], array( $hook['component'], $hook['callback'] ) );
		 }

		 foreach ( $this->actions as $hook ) {
			 add_action( $hook['hook'], array( $hook['component'], $hook['callback'] ) );
		 }

	}

}

Veuillez noter que cette classe est plus ou moins le composant principal du plugin, car elle coordonne toutes les actions et filtres utilisés dans tout le plugin. Ce plugin centralise tous les enregistrements et coordinations des hooks utilisés dans tout le plugin.

Enfin, lorsque run est appelé, tous les hooks sont enregistrés auprès de WordPress, donc lorsque le plugin démarre, il appellera chaque action et filtre enregistré.

admin Table des matières

À ce stade, nous sommes prêts à porter notre attention sur les fichiers situés dans le répertoire de gestion des plugins.

Bien que le fichier soit composé de plusieurs fichiers PHP, il contient également un fichier CSS. Pour les besoins de cet article, nous ne documenterons pas les fichiers CSS ; nous écrireons des fichiers CSS. Cependant, le Codex WordPress définit une documentation à cet effet.

Maintenant, passons à la documentation des classes et fichiers présents dans le répertoire admin.

Administrateur du méta-gestionnaire de publication unique

La classe d'administrateur Single Post Meta Manager a une seule responsabilité : définir la fonctionnalité pour afficher les méta-boîtes et leurs styles pour le tableau de bord.

<?php

/**
 * The Single Post Meta Manager Admin defines all functionality for the dashboard
 * of the plugin
 *
 * @package SPMM
 */

/**
 * The Single Post Meta Manager Admin defines all functionality for the dashboard
 * of the plugin.
 *
 * This class defines the meta box used to display the post meta data and registers
 * the style sheet responsible for styling the content of the meta box.
 *
 * @since    1.0.0
 */
class Single_Post_Meta_Manager_Admin {

    /**
	 * A reference to the version of the plugin that is passed to this class from the caller.
	 *
	 * @access private
	 * @var    string    $version    The current version of the plugin.
	 */
	private $version;

	/**
	 * Initializes this class and stores the current version of this plugin.
	 *
	 * @param    string    $version    The current version of this plugin.
	 */
	public function __construct( $version ) {
		$this->version = $version;
	}

	/**
	 * Enqueues the style sheet responsible for styling the contents of this
	 * 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->version,
			FALSE
		);

	}

	/**
	 * Registers the meta box that will be used to display all of the post meta data
	 * associated with the current post.
	 */
	public function add_meta_box() {

		add_meta_box(
			'single-post-meta-manager-admin',
			'Single Post Meta Manager',
			array( $this, 'render_meta_box' ),
			'post',
			'normal',
			'core'
		);

	}

	/**
	 * Requires the file that is used to display the user interface of the post meta box.
	 */
	public function render_meta_box() {
		require_once plugin_dir_path( __FILE__ ) . 'partials/single-post-meta-manager.php';
	}

}

请注意，上面的类只有很少的功能细节。主要是，该类维护对插件版本的引用、用于设置元框样式的样式表以及实际渲染元框所需的函数。

回想一下，所有这些都是在核心插件文件和加载器中设置的。这有助于解耦插件中存在的逻辑，以便每个类都可以专注于其主要目的。

当然，插件的最后一部分依赖于包含显示元框所需标记的实际部分文件。

单个帖子元管理器部分

<?php
/**
 * Displays the user interface for the Single Post Meta Manager meta box.
 *
 * This is a partial template that is included by the Single Post Meta Manager
 * Admin class that is used to display all of the information that is related
 * to the post meta data for the given post.
 *
 * @package    SPMM
 */
?>
<div id="single-post-meta-manager">

    <?php $post_meta = get_post_meta( get_the_ID() ); ?>
	<table id="single-post-meta-manager-data">
	<?php foreach ( $post_meta as $post_meta_key => $post_meta_value ) { ?>
		<tr>
			<td class="key"><?php echo $post_meta_key; ?></td>
			<td class="value"><?php print_r( $post_meta_value[0] ); ?></td>
		</tr>
	<?php } ?>
	</table>

</div><!-- #single-post-meta-manager -->

这应该是相对不言自明的；但是，为了完整起见，请注意此文件获取当前帖子 ID（通过使用 get_the_ID() 函数），读取帖子元数据，然后迭代它构建一个表显示键和值。

完成插件

至此，我们已经完成了插件的实现。从实施面向对象的编程实践，到记录代码。

您可以在 GitHub 上获取该插件的最终版本；但是，我们将在更多帖子中继续进行面向对象的讨论，以便我们可以探索一些更高级的主题，例如继承、抽象和其他主题。

同时，如果您对该插件有疑问或意见，请随时在评论中留下！

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!