wake-up-neo.net

Einzelfunktionen.php oder in viele kleine Dateien aufgeteilt?

Ich erstelle ein einfaches Framework mit Themenoptionen. Ich habe Codestücke in functions.php aufgeteilt und in eine bestimmte Ordnerstruktur eingefügt.

Jetzt habe ich in meiner Hauptdatei functions.php nur noch require_once-Aufrufe für diese Dateien.

Aber aus Gründen der Argumentation - lassen Sie uns sagen, dass ich am Ende 20 Dateien einschließen werde.

FRAGEN:

  1. Hat dies sichtbare Auswirkungen auf die Leistung von WP?
  2. Ist es besser, alles in einer Datei zu speichern (functions.php)?
  3. was ist der beste Weg, um dies zu tun?

Vielen Dank.

14
MegaMan

1. Hat dies sichtbare Auswirkungen auf die Leistung von WP?

WENNeine echte Auswirkung auf einige kleine Dateien haben würde, hätte dies eine Auswirkung, die geringer ist als WP: PHP und die Serverleistung. Hat es wirklich einen Einfluss? Nicht wirklich. Sie können aber trotzdem einfach anfangen, Leistungstests selbst durchzuführen.

2. Ist es besser, alles in einer Datei zu speichern (functions.php)

Nun ist die Frage "Was ist besser"? Von der gesamten Ladezeit der Datei (en)? Aus Sicht der Dateiorganisation? Auf jeden Fall macht es keinen Unterschied. Tun Sie dies so, dass Sie nicht den Überblick verlieren und das Ergebnis auf eine für Sie angenehme Weise erhalten können.

3. Was ist der beste Weg, dies zu tun?

Normalerweise hänge ich einfach irgendwo ein (plugins_loaded, after_setup_theme usw. - hängt davon ab, was Sie brauchen) und fordere dann einfach alle an:

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

Wie auch immer, Sie können es auch etwas komplizierter und flexibler gestalten. Schauen Sie sich dieses Beispiel an:

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

Es ist eine Klasse, die im Grunde dasselbe tut (benötigt PHP 5.3+). Der Vorteil ist, dass es etwas feiner strukturiert ist, sodass Sie ganz einfach Dateien aus Ordnern laden können, die Sie für eine bestimmte Aufgabe benötigen:

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

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

Aktualisieren

Da wir in einer neuen Welt nach PHP v5.2 leben, können wir den \FilterIterator verwenden. Beispiel der kürzesten Variante:

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

Wenn Sie sich an PHP v5.2 halten müssen, können Sie trotzdem mit dem \DirectoryIterator und so ziemlich dem gleichen Code weitermachen.

11
kaiser

Ich habe @kaiser überarbeitet und antworte ein wenig auf meine Bedürfnisse - dachte, ich teile es. Ich wollte mehr Optionen, die im Code und im folgenden Verwendungsbeispiel erklärt werden.

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


Anwendungsbeispiel:

$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