web-dev-qa-db-fra.com

Une seule fonction.php ou divisée en plusieurs petits fichiers?

Je crée un cadre simple avec des options de thème. J'ai divisé des morceaux de code dans functions.php et l'ai placé dans une structure de dossiers spécifique.

Maintenant, dans mon fichier functions.php principal, je n'ai que des appels require_once à ces fichiers.

Mais pour les besoins de l’argumentation, disons que je vais me retrouver avec 20 fichiers à inclure.

DES QUESTIONS:

  1. Cela a-t-il un effet sur les performances de WP de manière visible?
  2. Est-il préférable de tout garder dans 1 fichier (functions.php)
  3. quelle est la meilleure manière de s'occuper de ça ?

Merci.

plugin-developmenttheme-development
14
MegaMan

1. Est-ce que cela a un effet visible sur WP performances?

SIcela aurait un impact réel sur certains petits fichiers, il aurait un impact inférieur à WP: PHP et aux performances du serveur. At-il vraiment un effet? Pas vraiment. Mais vous pouvez toujours simplement commencer à faire des tests de performance vous-même.

2. Est-il préférable de tout garder dans un fichier (functions.php)

Maintenant la question est "Quoi de mieux"? À partir du temps de chargement global des fichiers? Du point de vue de l'organisation des fichiers? Quoi qu'il en soit, cela ne fait aucune différence. Faites-le de manière à ne pas perdre la vue d'ensemble et à conserver le résultat de manière agréable.

3. quelle est la meilleure façon de s'y prendre?

Ce que je fais habituellement, c'est simplement accrocher quelque part (plugins_loaded, after_setup_theme, etc. - dépend de ce dont vous avez besoin) et de simplement les exiger tous:

foreach ( glob( plugin_dir_path( __FILE__ ) ) as $file )
    require_once $file;

Quoi qu'il en soit, vous pouvez aussi rendre les choses un peu plus compliquées et flexibles. Regardez cet exemple:

<?php

namespace WCM;

defined( 'ABSPATH' ) OR exit;

class FilesLoader implements \IteratorAggregate
{
    private $path = '';

    private $files = array();

    public function __construct( $path )
    {
        $this->setPath( $path );
        $this->setFiles();
    }

    public function setPath( $path )
    {
        if ( empty( $this->path ) )
            $this->path = \plugin_dir_path( __FILE__ ).$path;
    }

    public function setFiles()
    {
        return $this->files = glob( "{$this->getPath()}/*.php" );
    }

    public function getPath()
    {
        return $this->path;
    }

    public function getFiles()
    {
        return $this->files;
    }

    public function getIterator()
    {
        $iterator = new \ArrayIterator( $this->getFiles() );
        return $iterator;
    }

    public function loadFile( $file )
    {
        include_once $file;
    }
}

C'est une classe qui fait fondamentalement la même chose (nécessite PHP 5.3+). L'avantage est que c'est un peu plus fin, vous pouvez donc simplement charger des fichiers à partir de dossiers dont vous avez besoin pour effectuer une tâche spécifique:

$fileLoader = new WCM\FilesLoader( 'assets/php' );

foreach ( $fileLoader as $file )
    $fileLoader->loadFile( $file );

Mettre à jour

Comme nous vivons dans un nouveau monde post PHP v5.2, nous pouvons utiliser le \FilterIterator. Exemple de la variante la plus courte:

$files = new \FilesystemIterator( __DIR__.'/src', \FilesystemIterator::SKIP_DOTS );
foreach ( $files as $file )
{
    /** @noinspection PhpIncludeInspection */
    ! $files->isDir() and include $files->getRealPath();
}

Si vous devez vous en tenir à PHP v5.2, vous pouvez toujours utiliser le \DirectoryIterator et à peu près le même code.

11
kaiser

J'ai retravaillé @kaiser pour répondre un peu à mes besoins - je pensais le partager. Je voulais plus d'options, celles-ci sont expliquées dans le code et dans l'exemple d'utilisation ci-dessous.

Code: 

<?php

defined( 'ABSPATH' ) OR exit;

/**
 * Functions_File_Loader
 * 
 * Makes it possible to clutter the functions.php into single files.
 * 
 * @author kaiser
 * @author ialocin
 * @link http://wordpress.stackexchange.com/q/111970/22534
 *
 */

class Functions_File_Loader implements IteratorAggregate {

    /**
     * @var array
     */
    private $parameter = array();

    /**
     * @var string
     */
    private $path;

    /**
     * @var string
     */
    private $pattern;

    /**
     * @var integer
     */
    private $flags;

    /**
     * @var array
     */
    private $files = array();

    /**
     * __construct
     *
     * @access public 
     * @param array $parameter
     */
    public function __construct( $parameter ) {
        $this->set_parameter( $parameter );
        $this->set_path( $this->parameter[ 'path' ] );
        $this->set_pattern( $this->parameter[ 'pattern' ] );
        $this->set_flags( $this->parameter[ 'flags' ] );
        $this->set_files();
    }

    /**
     * set_parameter
     *
     * @access public 
     * @param array $parameter
     */
    public function set_parameter( $parameter ) {
        if ( empty( $parameter ) )
            $this->parameter = array('','','');
        else
            $this->parameter = $parameter;
    }

    /**
     * get_parameter
     *
     * @access public 
     * @return array
     */
    public function get_parameter() {
        return $this->parameter;
    }

    /**
     * set_path
     *
     * defaults to get_stylesheet_directory()
     * 
     * @access public 
     * @param string $path
     */
    public function set_path( $path ) {
        if ( empty( $path ) )
            $this->path = get_stylesheet_directory().'/';
        else
            $this->path = get_stylesheet_directory().'/'.$path.'/';
    }

    /**
     * get_path
     *
     * @access public 
     * @return string
     */
    public function get_path() {
        return $this->path;
    }

    /**
     * set_pattern
     *
     * defaults to path plus asterisk »*«
     * 
     * @access public 
     * @param string $pattern
     */
    public function set_pattern( $pattern ) {
        if ( empty( $pattern ) )
            $this->pattern = $this->get_path() . '*';
        else
            $this->pattern = $this->get_path() . $pattern;
    }

    /**
     * get_pattern
     *
     * @access public 
     * @return string
     */
    public function get_pattern() {
        return $this->pattern;
    }

    /**
     * set_flags
     *
     * @access public 
     * @param integer $flags
     */
    public function set_flags( $flags ) {
        if ( empty( $flags ) )
            $this->flags = '0';
        else
            $this->flags = $flags;
    }

    /**
     * get_flags
     *
     * @access public 
     * @return integer
     */
    public function get_flags() {
        return $this->flags;
    }


    /**
     * set_files
     *
     * @access public 
     */
    public function set_files() {
        $pattern = $this->get_pattern();
        $flags = $this->get_flags();
        $files = glob( $pattern, $flags );
        $this->files = $files;
    }


    /**
     * get_files
     *
     * @access public 
     * @return array
     */
    public function get_files() {
        return $this->files;
    }

    /**
     * getIterator
     * 
     * This function name has to be kept
     * 
     * @access public 
     * @return void
     */
    public function getIterator() {
        $iterator = new ArrayIterator( $this->get_files() );
        return $iterator;
    }

    /**
     * load_file
     *
     * @access public 
     * @param string $file
     */
    public function load_file( $file ) {
        include_once $file;
    }
}


Exemple d'utilisation: 

$parameter = array(
        // define path relative to get_stylesheet_directory()
        // optional, defaults to get_stylesheet_directory()
        'path' => 'includes/plugins',
        // optional, defaults to asterisk »*«
        // matches all files ending with ».php« 
        // and not beginning with »_«, good for quickly deactivating 
        // directories searched are »path« and »subfolders«
        // Additional examples:
        // '{*/,}{[!_],}func-*.php' same as above but for files with a prefix
        // '[!_]*.php' php files in defined »path«, not beginning with »_« 
        'pattern' => '{*/,}[!_]*.php',
        // optional, defaults to 0
        // needed if for example brackets are used
        // more information: http://www.php.net/manual/en/function.glob.php
        'flags' => GLOB_BRACE
    );
// create object
$functionsfileloader = new Functions_File_Loader( $parameter );
// load the files
foreach ( $functionsfileloader as $file ) {
    $functionsfileloader->load_file( $file );
}
1
Nicolai