WordPress-Plugin Dokumentation fortsetzen: Objektorientierte Programmierung II

An diesem Punkt der Serie sind wir bereit, unser Plugin zu vervollständigen, indem wir unsere Dateien, Klassen, Funktionen, Variablen usw. dokumentieren.

Obwohl dies der letzte Schritt ist, bei dem wir das Plugin tatsächlich fertigstellen müssen, ist dies nicht der letzte Artikel in der Reihe, da wir uns weiterhin mit einigen fortgeschrittenen Themen der objektorientierten Programmierung befassen werden.

Aber vorher wollen wir alles, was wir im vorherigen Artikel gelernt haben, in die Praxis umsetzen und unser Plugin auf Version 1.0 aktualisieren.

Natürlich empfehle ich Ihnen, wie bei allen vorherigen allen Artikeln, dass Sie über alles, was wir bisher behandelt haben, auf dem Laufenden bleiben, damit Sie nicht nur vollständig verstehen, was wir im vorherigen Artikel getan haben, sondern auch, wie wir es tatsächlich tun dort angekommen Der letzte Punkt, der in diesem Artikel besprochen wird.

1. Einführung
2. Kurse
3. Typ
4. Kontrollstruktur: bedingte Anweisung
5. Kontrollstruktur: Schleife
6. Funktionen und Eigenschaften
7. Umfang
8. Build-Plugin I
9. Build Plugin II
10. Aufnahme-Plugin I

Nachdem wir das alles verstanden und überprüft haben, beginnen wir mit der Dokumentation jeder Datei.

Aufnahme-Plugin

Wir können dieses Plugin auf verschiedene Arten protokollieren:

• Wir können zuerst alle Dateiheader protokollieren, dann können wir zurückkommen und die Klassen protokollieren, dann können wir zurückkommen und die Variablen protokollieren und dann können wir die Funktionen protokollieren.
• Wir können jede Datei auf einmal aufzeichnen und kurz alles besprechen, was in jeder Datei enthalten ist.

Natürlich generiert diese Option mehr Dokumentation für jeden Teil, sollte aber zu einem weniger langweiligen Artikel und einem leichter verständlichen Kontrollfluss des gesamten Plugins führen.

Dazu schauen wir uns das Plugin Datei für Datei an, stellen die Dokumentation für jeden Code vor, den wir haben, und besprechen dann alle interessanten Punkte hinter dem Code.

Abschließend stellen wir sicher, dass wir am Ende des Artikels auf die endgültige Version des Plugins verweisen. Nachdem dies gesagt ist, fangen wir an.

Single Post Meta Manager

Denken Sie daran, dass die Hauptdatei, die das Plugin startet, die Datei single-post-meta-manager.php ist, die sich im Stammverzeichnis des Plugin-Verzeichnisses befindet.

Das Folgende ist die vollständig dokumentierte Version der Datei. Lesen Sie jede Rezension sorgfältig durch und achten Sie dabei nicht nur auf das Format, sondern auch auf den Inhalt, den sie bietet.

<?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();

Bitte beachten Sie im obigen Code, dass wir den Dateiheader gemäß der im vorherigen Artikel beschriebenen Konvention definiert haben. Wir pflegen auch die erforderlichen Plugin-Header-Tags, damit WordPress sie korrekt liest.

Beachten Sie, dass wir sie in diesem Beispiel unter einem benutzerdefinierten @wordpress-plugin-Tag eingefügt haben. Dies ist nicht erforderlich, hilft aber dabei, Datei-Header-Kommentare von erforderlichen Plugin-Kommentaren zu trennen.

Bitte beachten Sie abschließend, dass wir dieses Plugin auf einen 1.0，并且我们还为该插件指定了 @package 值="inline">SPMM fehlenden Single Post Meta Manager aktualisiert haben. Wir werden dies im gesamten Plugin verwenden.

包含Inhaltsverzeichnis

Als nächstes richten wir unsere Aufmerksamkeit auf alle Dateien im Include-Verzeichnis.

Da diese Dateien erforderlich sind, bevor irgendetwas im Verzeichnis verwaltet werden kann, ist es sinnvoll, jede dieser Dateien einzeln zu betrachten und unsere Diskussion dann mit den verbleibenden Dateien im verwalteten Verzeichnis abzurunden.

Single Post Meta Manager

<?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;
	}

}

Natürlich wurden viele neue Kommentare in diese spezielle Datei eingeführt, die Rolle jedes Klassenattributs, Konstruktors und jeder internen Funktion sollte jedoch ziemlich selbsterklärend sein.

Neben der Art und Weise, wie Informationen über Plugins koordiniert werden, ist es wichtig zu beachten, wie wir uns an die im vorherigen Artikel definierten Standards halten.

Bitte beachten Sie jedoch, dass wir uns die Freiheit nehmen, sie zu verwenden, wenn bestimmte Tags und/oder Funktionen in der Dokumentation nicht verwendet werden, obwohl sie nicht relevant sind. Wir werden dies auch im weiteren Verlauf dieses Artikels tun. Single-Post-Meta-Manager-Loader

<?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'] ) );
		 }

	}

}

Bitte beachten Sie, dass diese Klasse mehr oder weniger die Kernkomponente des Plugins ist, da sie alle im Plugin verwendeten Aktionen und Filter koordiniert. Dieses Plugin zentralisiert die gesamte Registrierung und Koordination der im gesamten Plugin verwendeten Hooks.

Wenn

schließlich aufgerufen wird, werden alle Hooks bei WordPress registriert, sodass das Plugin beim Start alle registrierten Aktionen und Filter aufruft.

run

Inhaltsverzeichnis

adminAn diesem Punkt sind wir bereit, unsere Aufmerksamkeit auf die Dateien zu richten, die sich im Plugin-Verwaltungsverzeichnis befinden.

Während die Datei aus mehreren PHP-Dateien besteht, enthält sie auch eine CSS-Datei. Für die Zwecke dieses Artikels werden wir keine CSS-Dateien dokumentieren; wir werden CSS-Dateien schreiben. Der WordPress-Codex

definiert

jedoch die Dokumentation hierfür. Lassen Sie uns nun mit der Dokumentation der im

-Verzeichnis vorhandenen Klassen und Dateien fortfahren.

adminSingle-Post-Meta-Manager-Administrator

Die Single Post Meta Manager Admin-Klasse hat eine einzige Verantwortung: definierte Funktionalität zum Rendern von Meta-Boxen und deren Stile für das Dashboard.

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

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

Das obige ist der detaillierte Inhalt vonWordPress-Plugin Dokumentation fortsetzen: Objektorientierte Programmierung II. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!