Function.php tunggal atau dibagi menjadi banyak file kecil?

Saya membuat kerangka kerja sederhana dengan opsi tema. Saya telah membagi potongan kode di dalamnya functions.phpdan menempatkannya di dalam struktur folder tertentu.

Sekarang di functions.phpfile utama saya , saya hanya memiliki require_oncepanggilan ke file-file ini.

Tetapi demi argumen - katakanlah saya akan memiliki 20 file untuk disertakan.

PERTANYAAN:

1. Apakah ini berpengaruh pada kinerja WP dengan cara yang terlihat?
2. Apakah lebih baik menyimpan semuanya dalam 1 file (functions.php)
3. Apa cara terbaik untuk masalah ini ?

Terima kasih.

1. Apakah ini berpengaruh pada kinerja WP dengan cara yang terlihat?

JIKA itu akan berdampak nyata untuk beberapa file kecil, maka itu akan memiliki dampak yang memiliki dampak lebih rendah dari WP: PHP dan kinerja server. Apakah itu benar-benar berpengaruh? Tidak juga. Tetapi Anda masih bisa mulai melakukan tes kinerja sendiri.

2. Apakah lebih baik menyimpannya dalam 1 file (functions.php)

Sekarang pertanyaannya adalah "Apa yang lebih baik"? Dari keseluruhan waktu pemuatan file? Dari sudut pandang organisasi file? Bagaimanapun, itu tidak ada bedanya. Lakukan dengan cara sehingga Anda tidak kehilangan gambaran umum dan dapat mempertahankan hasilnya dengan cara yang menyenangkan bagi Anda.

3. apa cara terbaik untuk melakukan ini?

Apa yang biasanya saya lakukan hanya mengaitkan suatu tempat di ( plugins_loaded, after_setup_theme, dll - tergantung pada apa yang Anda perlu) dan kemudian hanya meminta mereka semua:

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

Bagaimanapun, Anda dapat membuatnya sedikit lebih rumit dan fleksibel juga. Lihatlah contoh itu:

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

Ini adalah kelas yang pada dasarnya sama (membutuhkan PHP 5.3+). Keuntungannya adalah butirannya sedikit lebih halus, sehingga Anda dapat dengan mudah memuat file dari folder yang Anda perlukan untuk melakukan tugas tertentu:

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

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

Memperbarui

Karena kita hidup di dunia baru, memposting PHP v5.2 dunia, kita dapat memanfaatkan \FilterIterator. Contoh varian terpendek:

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

Jika Anda harus tetap menggunakan PHP v5.2, maka Anda masih bisa menggunakan \DirectoryIteratordan kode yang hampir sama.

Saya mengerjakan ulang @kaiser sedikit menjawab kebutuhan saya - pikir saya membagikannya. Saya ingin lebih banyak opsi, itu dijelaskan di dalam kode dan pada contoh penggunaan di bawah ini.

Kode:

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

Contoh penggunaan:

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