Découvrez la programmation fonctionnelle : un chemin vers le développement de plugins WordPress

La deuxième partie de cette série examine deux styles de programmation différents (parfois appelés paradigmes de programmation) que vous pouvez utiliser lors de l'écriture de plugins WordPress. Dans la première partie, Tom McFarlin présente la programmation orientée objet. Dans cette partie, nous discuterons de la programmation fonctionnelle.

Étant donné que les niveaux d'expérience des lecteurs varient, nous discuterons de la programmation avancée, donc si vous êtes débutant, vous ne devriez avoir aucun problème. Toutefois, si vous êtes un développeur expérimenté, vous trouverez peut-être des informations plus utiles plus loin dans cet article.

Qu'est-ce que la programmation fonctionnelle ?

La programmation fonctionnelle est probablement le style que vous connaissez le mieux, et est presque universellement utilisé et c'est le style utilisé par divers sites d'extraits de code WordPress sur Internet. On peut donc parfois la considérer comme une programmation « d’entrée de gamme » : le style que les débutants adoptent avant d’apprendre à maîtriser la programmation orientée objet. C'est incroyablement trompeur, car même si la programmation fonctionnelle est beaucoup plus simple, elle n'est pas intrinsèquement inférieure.

La programmation fonctionnelle met l'accent sur l'évaluation des fonctions et évite le concept d'état ou d'objets, par opposition à la programmation orientée objet, qui encourage à penser que le code agit sur des objets, en utilisant des méthodes pour modifier ces objets ou interagir avec eux. Regardons un exemple très simple pour comparer ces deux styles :

	// 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

Cet exemple très simple illustre la différence fondamentale de style entre les deux paradigmes : la programmation fonctionnelle se concentre sur la transmission de paramètres aux fonctions et la réception de valeurs des fonctions. Il n’y a pas d’« objet » sur lequel on agit, seulement des paramètres et des valeurs de retour. En revanche, l’approche orientée objet attribue diverses propriétés (« valeurs » dans notre cas) aux objets, et les méthodes agissent sur ces propriétés.

Fonctions : bases

Définir une fonction est très simple :

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

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

Après avoir déclaré une fonction, elle peut être utilisée n'importe où dans le plugin - en d'autres termes, elle a une portée globale.

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

Vous avez peut-être remarqué que définir une valeur par défaut dans add 的定义中，第二个参数设置为等于 1。这为 $number2 (1 dans ce cas) rend le paramètre facultatif. Si aucun argument n'est fourni, la valeur sera traitée par défaut :

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

D'un autre côté, aucune valeur par défaut n'est fournie pour la première valeur, donc omettre ce paramètre générera une erreur

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

Vous pouvez également avoir un nombre variable de paramètres. À l'intérieur d'une fonction, nous pouvons utiliser func_num_args() 来获取收到的参数数量，而 func_get_arg() pour vous permettre d'accéder à des variables transmises spécifiques, indexées à partir de 0.

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

Le contenu ci-dessus peut également être utilisé dans les méthodes objet. Enfin, en déclarant une variable comme "globale", vous pouvez y accéder depuis l'intérieur de la fonction.

	$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'

Pourquoi utiliser la programmation fonctionnelle ?

Décider du style de programmation à utiliser dépend du jugement et – oui – de la préférence personnelle. Il n'est ni plus correct ni mauvais d'utiliser la programmation fonctionnelle plutôt que la programmation orientée objet, mais il existe généralement un style mieux adapté à ce que vous souhaitez réaliser.

Parfois, la programmation orientée objet n'est tout simplement pas nécessaire et complique simplement les choses ou introduit du code redondant. Un exemple pourrait être les différentes fonctionnalités « utilitaires » fournies par WordPress. Ce sont des fonctions générales utilisées pour atteindre un objectif spécifique. Par exemple wp_trim_words( $text, $num_words ) 只是将给定的字符串修剪到一定的大小（以单词为单位）。它不会添加任何内容来将 wp_trim_words() est défini comme une méthode appartenant à un objet et donne un code plus laid. Pour la programmation fonctionnelle, une seule ligne suffit.

L'un des avantages de la programmation fonctionnelle est sa simplicité, notamment pour les débutants. Vous n'avez pas à vous soucier des fonctions statiques, privées ou protégées : elles sont toutes globales. La notion de variables statiques n'existe pas non plus. Au niveau le plus élémentaire, votre fonction renvoie une sortie dérivée de ce que vous lui donnez. Par exemple, get_the_title( 7 ) renverra le titre du message avec l'ID 7.

Un autre avantage de la programmation fonctionnelle est que les fonctions sont accessibles globalement. Pour les programmes orientés objet, afin d'opérer sur un objet spécifique, vous devez transmettre cet objet. Cela peut parfois être délicat. Pour illustrer cela, prenons l’exemple de la première partie :

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

摘要

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

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!