Entdecken Sie funktionale Programmierung: Ein Weg zur Entwicklung von WordPress-Plugins

Teil zwei dieser Serie befasst sich mit zwei verschiedenen Programmierstilen (manchmal auch Programmierparadigmen genannt), die Sie beim Schreiben von WordPress-Plugins verwenden können. Im ersten Teil stellt Tom McFarlin die objektorientierte Programmierung vor. In diesem Teil werden wir die funktionale Programmierung besprechen.

Da die Erfahrungsniveaus der Leser unterschiedlich sind, werden wir uns mit fortgeschrittener Programmierung befassen. Wenn Sie also ein Anfänger sind, sollten Sie keine Probleme haben. Wenn Sie jedoch ein erfahrener Entwickler sind, finden Sie möglicherweise später in diesem Artikel weitere nützliche Informationen.

Was ist funktionale Programmierung?

Funktionale Programmierung ist wahrscheinlich der Stil, mit dem Sie am besten vertraut sind. Er wird fast überall verwendet und ist der Stil, der von verschiedenen WordPress-Snippet-Sites im Internet verwendet wird. Daher kann es manchmal als „Einstiegsprogrammierung“ betrachtet werden: der Stil, den Anfänger annehmen, bevor sie lernen, die objektorientierte Programmierung zu beherrschen. Das ist unglaublich irreführend, denn obwohl die funktionale Programmierung viel einfacher ist, ist sie nicht grundsätzlich minderwertig.

Funktionale Programmierung legt den Schwerpunkt auf die Bewertung von Funktionen und vermeidet das Konzept von Zuständen oder Objekten, im Gegensatz zur objektorientierten Programmierung, die dazu anregt, sich Code so vorzustellen, als würde er auf Objekte einwirken und Methoden verwenden, um diese Objekte zu ändern oder mit ihnen zu interagieren. Schauen wir uns ein sehr einfaches Beispiel an, um diese beiden Stile zu vergleichen:

	// Functional method
	function add_two( $n ) {
		return $n +2;
	}

	$a = 2;
	$b = add_two( $a ); // $b = 4;


	// Object oriented method
	class Number {
		var $value = 0;

		function __construct( $a ) {
			$this->value = $a;
		}

		function add_two() {
			$this->value = $this->value +2;
		}
	}

	$a = new Number( 2 );
	echo $a->value; //Prints 2
	$a->add_two();
	echo $a->value; //Prints 4

Dieses sehr einfache Beispiel veranschaulicht den grundlegenden Stilunterschied zwischen den beiden Paradigmen: Die funktionale Programmierung konzentriert sich auf die Übergabe von Parametern an Funktionen und den Empfang von Werten von Funktionen. Es wird kein „Objekt“ bearbeitet, sondern nur Parameter und Rückgabewerte. Im Gegensatz dazu weist der objektorientierte Ansatz Objekten verschiedene Eigenschaften (in unserem Fall „Werte“) zu, und Methoden wirken auf diese Eigenschaften.

Funktionen: Grundlagen

Eine Funktion zu definieren ist sehr einfach:

	function add( $number, $number2 = 1 ) {
		// Perform code acting on passed variables
		$sum = $number + $number2;

		// Optional, if needed you can return a value
		return $sum;
	}

Nachdem Sie eine Funktion deklariert haben, kann sie überall im Plugin verwendet werden – mit anderen Worten, sie hat globalen Gültigkeitsbereich.

	$a = 4;
	$b = 7;
	echo add( $a, $b ); // Prints 11

Sie haben vielleicht bemerkt, dass das Festlegen eines Standardwerts in add 的定义中，第二个参数设置为等于 1。这为 $number2 (in diesem Fall 1) den Parameter optional macht. Wenn kein Argument angegeben wird, wird der Wert als Standardwert behandelt:

	echo add( 4 ); // Prints 5
	echo add( 4, 1 ); // Prints 5

Andererseits ist für den ersten Wert kein Standardwert angegeben, sodass das Weglassen dieses Parameters einen Fehler auslöst

	echo add(); // Throws an error as $number is not defined

Sie können auch eine variable Anzahl von Parametern haben. Innerhalb einer Funktion können wir func_num_args() 来获取收到的参数数量，而 func_get_arg() verwenden, um Ihnen den Zugriff auf bestimmte übergebene Variablen zu ermöglichen, die ab 0 indiziert sind.

function sum() {
	// Get the number of arguments given to sum()
	$number_args = func_num_args();

	$sum = 0;

	if ( ! $number_args )
		return $sum;

	for ( $i = 0; $i < $number_args; $i++ ) {
		$sum += func_get_arg( $i );
	}

	return $sum;
}

echo sum( 1, 2,  3, 4 ); //Prints 10
echo sum( 1, 2 ); //Prints 3
echo sum(); //Prints 0

Der obige Inhalt kann auch in Objektmethoden verwendet werden. Schließlich können Sie durch die Deklaration einer Variablen als „global“ aus der Funktion heraus auf sie zugreifen.

	$a = 'Hello';
	$b = 'World';
	function hello_world() {
		// This is necessary to access $a and $b 
		// declared outside of the function scope.
		global $a, $b;
		$b = $a . ' ' . $b;
	}
	hello_world();
	echo $b; // Prints 'Hello World'

Warum funktionale Programmierung verwenden?

Die Entscheidung, welcher Programmierstil verwendet werden soll, hängt vom Urteilsvermögen und – ja – den persönlichen Vorlieben ab. Es ist nicht richtiger oder falscher, funktionale Programmierung statt objektorientierter Programmierung zu verwenden, aber normalerweise gibt es einen Stil, der besser für das, was Sie erreichen möchten, geeignet ist.

Manchmal ist objektorientierte Programmierung einfach nicht notwendig und macht die Dinge einfach zu kompliziert oder führt redundanten Code ein. Ein Beispiel könnten die verschiedenen „Dienstprogramm“-Funktionen sein, die WordPress bietet. Dabei handelt es sich um allgemeine Funktionen, die einem bestimmten Zweck dienen. Beispielsweise ist wp_trim_words( $text, $num_words ) 只是将给定的字符串修剪到一定的大小（以单词为单位）。它不会添加任何内容来将 wp_trim_words() als eine zu einem Objekt gehörende Methode definiert und führt zu hässlicherem Code. Für die funktionale Programmierung ist nur eine Zeile erforderlich.

Einer der Vorteile der funktionalen Programmierung ist ihre Einfachheit, insbesondere für Anfänger. Sie müssen sich keine Gedanken über statische, private oder geschützte Funktionen machen – sie sind alle global. Das Konzept der statischen Variablen existiert ebenfalls nicht. Auf der einfachsten Ebene gibt Ihre Funktion eine Ausgabe zurück, die von dem abgeleitet wird, was Sie ihr geben. Beispielsweise gibt get_the_title( 7 ) den Titel des Beitrags mit der ID 7 zurück.

Ein weiterer Vorteil der funktionalen Programmierung besteht darin, dass auf Funktionen global zugegriffen werden kann. Bei objektorientierten Programmen müssen Sie dieses Objekt übergeben, um ein bestimmtes Objekt bearbeiten zu können. Das kann manchmal schwierig sein. Um dies zu veranschaulichen, nehmen wir das Beispiel aus Teil eins:

class DemoPlugin {
	public function __construct() {
		add_action( 'wp_enqueue_scripts', array( $this, 'register_plugin_scripts' ) );
	}

	public function register_plugin_scripts() {
		// Register plugin scripts
	}
}
$demo_plugin = new DemoPlugin();

当 WordPress 存储 register_plugin_scripts() 方法时，以便在触发 wp_enqueue_scripts 操作时调用它，它不仅通过引用该方法，而且还引用对象 $demo_plugin 来实现此目的。这是因为同一对象的不同实例的相同方法被视为不同的方法 - 即 $demo_plugin->register_plugin_scripts() 和 $copy_of_demo_plugin->register_plugin_scripts() 不是相同。这可能看起来很奇怪 - 但对于同一类的不同实例，方法的行为可能不同，因此我们需要引用方法和实例。

但是为什么这很重要呢？这使得第三方插件或主题很难取消该方法，因为为此他们需要调用：

	remove_action( 'wp_enqueue_scripts', array( $demo_plugin, 'register_plugin_scripts' ) );

但通常他们无法访问 $demo_plugin 变量。 （注意：如果该方法被声明为静态，那么您可以解决这个问题）。

WordPress 中的面向对象和函数式编程

当然，面向对象编程有其优点，如第一部分所述。正如 Tom 还提到的，使用 WordPress 的小部件 API 时这是不可避免的。另一个常见的例子是 WP_Query()。在这里，面向对象的方法显然是最好的：您有一个对象（在本例中是一个查询），它具有各种属性（即搜索条件、分页信息、匹配结果），并且您想要对该查询进行操作（解析它，生成并清理相应的SQL，并返回结果）。

WP_Query() 演示了正确使用时面向对象编程的强大功能。发起查询后：

$the_query = new WP_Query( array(...) );

您不仅可以访问结果，还可以访问其他信息，例如分页值：有多少页结果、正在查看哪个页面、结果总数以及查询的“类型”，例如$the_query->is_search()、$the_query->is_single() 等。还有整个“循环”基础设施；

	if ( $the_query->have_posts() ) {
		echo '<ul>';
		while( $the_query->have_posts() ): $the_query->the_post();
			// The Loop
			echo '<li>' . get_the_title( $the_post->ID ) . '</li>';
		endwhile;
		echo '</ul>';
	}
	wp_reset_postdata();

它将结果和全局变量的所有内部处理隐藏在人性化的 API 后面。

那么 get_posts() 呢？这只是作为 WP_Query() 的包装器，并简单地返回与查询匹配的帖子数组。因此，您不会得到 WP_Query() 的“花哨”功能，但它的效率稍高一些。因此，是否应该使用 get_posts() 还是 WP_Query() 取决于您的用例（例如，是否需要分页），但这也取决于个人喜好。

	$results = get_posts( array( ... ) );

	if ( $results ) {
		echo '<ul>';
		foreach( $results as $the_post ) {
			echo '<li>' . get_the_title( $the_post->ID ) . '</li>';
		}
		echo '</ul>';
	}

摘要

希望这两篇文章有助于突出这些编程风格的优点和缺点。要点是，这里没有对与错，每个程序员都有自己的个人偏好。但某些上下文更容易适应某种编程风格 - 因此您应该期望您的插件包含两者的混合。

Das obige ist der detaillierte Inhalt vonEntdecken Sie funktionale Programmierung: Ein Weg zur Entwicklung von WordPress-Plugins. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!