Pojedyncze funkcje. Php czy podzielone na wiele małych plików?

Tworzę prostą strukturę z opcjami motywu. Podzieliłem fragmenty kodu functions.phpi umieściłem je w określonej strukturze folderów.

Teraz w głównym functions.phppliku mam tylko require_oncewywołania tych plików.

Ale dla argumentu - powiedzmy, że skończę z 20 plikami do dołączenia.

PYTANIA:

1. Czy ma to widoczny wpływ na wydajność WP?
2. Czy lepiej trzymać to wszystko w 1 pliku (functions.php)
3. jaki jest najlepszy sposób, aby to zrobić?

Dzięki.

1. Czy ma to widoczny wpływ na wydajność WP?

JEŻELI miałoby to rzeczywisty wpływ na niektóre małe pliki, to miałoby to wpływ, który ma wpływ niższy niż WP: PHP i wydajność serwera. Czy to naprawdę ma wpływ? Nie całkiem. Ale nadal możesz po prostu samodzielnie rozpocząć testy wydajności.

2. Czy lepiej trzymać to wszystko w 1 pliku (functions.php)

Teraz pytanie brzmi „co jest lepsze”? Z ogólnego czasu ładowania plików? Z punktu widzenia organizacji plików? W każdym razie to nie robi różnicy. Zrób to w taki sposób, aby nie stracić widoku i zachować wynik w sposób, który jest dla Ciebie przyjemny.

3. Jak najlepiej to zrobić?

To, co zwykle robię, to po prostu zaczepienie gdzieś ( plugins_loaded, after_setup_themeitp. - zależy od tego, czego potrzebujesz), a następnie po prostu wymagam ich wszystkich:

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

W każdym razie możesz uczynić to trochę bardziej skomplikowanym i elastycznym. Spójrz na ten przykład:

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

Jest to klasa, która robi to samo (wymaga PHP 5.3+). Zaletą jest to, że jest nieco bardziej drobnoziarnisty, dzięki czemu można łatwo załadować pliki z folderów, które należy wykonać w celu wykonania określonego zadania:

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

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

Aktualizacja

Ponieważ żyjemy w nowym świecie po PHP v5.2, możemy skorzystać z \FilterIterator. Przykład najkrótszego wariantu:

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

Jeśli musisz trzymać się PHP wer. 5.2, nadal możesz używać \DirectoryIteratortego samego kodu.

Przerobiłem odpowiedź @kaiser trochę na moje potrzeby - pomyślałem, że ją podzielę. Chciałem więcej opcji, są one wyjaśnione w kodzie i na poniższym przykładzie użycia.

Kod:

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

Przykład użycia:

$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 );
}