Tek işlevler.php veya birçok küçük dosyaya bölünmüş?

Tema seçenekleriyle basit bir çerçeve oluşturuyorum. İçindeki kod parçalarını böldüm functions.phpve belirli bir klasör yapısına yerleştirdim.

Şimdi ana functions.phpdosyamda sadece require_oncebu dosyalara çağrı var .

Ama tartışma uğruna - diyelim ki dahil etmek için 20 dosya alacağım.

SORULAR:

1. Bunun WP performansı üzerinde görünür bir etkisi var mı?
2. Hepsini 1 dosyada tutmak daha mı iyidir (function.php)
3. bunun için en iyi yol nedir?

Teşekkürler.

1. Bunun WP performansı üzerinde görünür bir etkisi var mı?

IF PHP ve sunucu performansı: Gerçek bir bazı küçük dosyalar için etkileyecektir olurdu, o zaman bir o alt WP daha bir etkisi vardır etkileyen olurdu. Gerçekten bir etkisi var mı? Pek sayılmaz. Ancak yine de performans testlerini kendiniz yapmaya başlayabilirsiniz.

2. Hepsini 1 dosyada tutmak daha iyidir (function.php)

Şimdi soru "Daha iyi olan nedir?" Toplam dosya yükleme süresinden mi? Dosya organizasyonu açısından mı? Her neyse, fark etmez. Genel bakışı kaybetmemeniz ve sonucu sizin için hoş bir şekilde tutabilmeniz için bir şekilde yapın.

3. bu konuda en iyi yolu nedir?

Ne Normalde basitçe bir yere asılıyorsa yapmak ( plugins_loaded, after_setup_themevb - Ne gerek bağlıdır) ve sonra sadece hepsini gerektirir:

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

Her neyse, biraz daha karmaşık ve esnek hale getirebilirsiniz. Şu örneğe bir göz atın:

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

Temelde aynı şeyi yapan bir sınıftır (PHP 5.3 ve üstü sürümlere ihtiyaç duyar). Avantajı, biraz daha ince taneli olması, böylece belirli bir görevi gerçekleştirmek için gereken klasörlerden dosyaları kolayca yükleyebilirsiniz:

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

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

Güncelleme

Biz yeni, post PHP v5.2 dünyasında yaşadıkça, biz de yararlanabilirsiniz \FilterIterator. En kısa varyant örneği:

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

PHP v5.2 ile uğraşmak zorunda kalırsanız, yine de \DirectoryIteratorve hemen hemen aynı kodla gidebilirsiniz .

@Kaiser'ın ihtiyaçlarına biraz cevap verdim - paylaştığımı düşündüm. Daha fazla seçenek istedim, bunlar kodun içinde ve aşağıdaki kullanım örneğinde açıklandı.

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

Kullanım örneği:

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