Un seul fichier functions.php ou fractionné en plusieurs petits fichiers?

13

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

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

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

QUESTIONS:

  1. Cela a-t-il un effet visible sur les performances de WP?
  2. Est-il préférable de tout conserver dans un fichier (functions.php)
  3. quelle est la meilleure façon de s'y prendre?

Merci.

    
posée MegaMan 28.08.2013 - 15:03

2 réponses

11
  

1. Cela a-t-il un effet visible sur les performances de WP?

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

  

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

Maintenant, la question est "Quel est le meilleur"? À 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. quel est le meilleur moyen de s'y prendre?

Ce que je fais habituellement, c'est simplement accrocher quelque part ( plugins_loaded , after_setup_theme , etc. - cela dépend de ce dont vous avez besoin), puis de les demander à 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. Jetez un coup d'œil à 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 fonctionne fondamentalement de la même manière (nécessite PHP 5.3+). L’avantage est qu’il 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 5.2, nous pouvons utiliser le \FilterIterator . Exemple de 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.

    
réponse donnée kaiser 28.08.2013 - 16:47
1

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 );
}
    
réponse donnée Nicolai 20.04.2014 - 23:35

Lire d'autres questions sur les étiquettes