Bonjour,

Dans le but de rendre mes sites modulaires je souhaiterai développer un système de gestion de plugin. Auriez vous des idées, conseils, pistes a me donner ?
J'ai commencé à développer quelque chose et voici un descriptif de ce gestionnaire :
La ou je souhaite utiliser le plugin je faisait appele a une fonction ( use_plugin() ), celle-ci prend en parametres d'entre 2 variables, le nom du plugin a utiliser, la fonction d'entrée du plugin et les parametres de cette fonction rangés dans un tableau. La fonction use_plugin va vérifier si le plugin existe (verification de l'existance du nom du plugin dans un tableau les regroupant tous et verification de l'existance du fichier du plugin) puis va appeler la fonction du plugin en lui passant le tableau de parametres via la fonction call_user_func_array().
Seulement voila plusieures choses ne me vont pas :
- premierement, dans le passage des parametres a la fonction du plugin. Existe-t-il un moyen de savoir combien de parametres peut recevoir une fonction ? La fonction func_num_arg le fait mais uniquement pour la fonction dans laquelle elle est appelée. Ceci dans un soucis de vérifier si le tableau contenant les parametres contient la bonne quantité de parametres.
- secondo, que pensez vous de la méthode utilisée ? N'est elle pas trop lourde ? Comment l'améliorer ? etc ..

J'espere que j'ai reussi à me faire comprendre :p

Merci a ceux qui liront et prendront le soin de m'aider :)

Salut,

je trouve ta méthode pas mal, pour connaître le nombre d'arguments d'une fonction tu peux que faire ça à l'intérieur de la fonction, pas à l'extérieur. Tu peux de toute façon faire une fonction qui accepte une infinité de paramètres, que tu pourras ensuite traiter dans ton plugin. Je trouve la méthode pas vilaine ;)

Bonsoir,
Merci pour la réponse :)
Sinon puisque des lignes de codes sont plus parlante qu'un discours voila a quoi cela ressemble


<?php
define(ABSPATH, dirname(__FILE__) . '/');

function use_plugin($plugin_name, $function_to_execute, $args = NULL){
    
     $plugin_list = array('compteur');     //Tableau contenant la liste des plugins
    
     $plugin_file = ABSPATH . $plugin_name . '.php';          //Chaine contenant le chemin et le nom du plugin
    
     //On vérifie que le fichier du plugin existe
     if (in_array($plugin_name, $plugin_list) && file_exists($plugin_file)) {
          //On inclu le plugin
          include_once($plugin_file);
          //On verifie si la variable $function_to_execute est une fonction et si elle peut être appelee
          if (is_callable($function_to_execute)){
               if (!is_null($args)){
                    if (!is_array($args)) {
                         $args_in_array = array($args);
                    } else {
                         $args_in_array = $args;
                    }
                    return call_user_func_array($function_to_execute, $args_in_array);
               } else {
                    return call_user_func($function_to_execute);
               }
          }
     }
}
?>

Et j'utilise la fonction use_plugin de cette façon (bien entendu un include_once du fichier contenant la fonction use_plugin est fait avant ^^ )

<?php
use_plugin('nom_du_plugin', 'nom_de_la_fonction', $parametres)
?>
$parametres peut soit etre une simple variable soit un tableau contenant tous les parametres

Mais il n'y a la pour le moment aucune vérification des parametres :/

En prog procédurale (non orientée objet) je trouve ça pas vilain ;)

"pas vilain" :) Il manque quoi pour que ce soit "joli" ? ^^

Heu, une fille qui le fait ?

arf merde