Single functions.php ou dividido em muitos arquivos pequenos?

14

Estou criando uma estrutura simples com opções de tema. Dividi trechos de código functions.phpe o coloquei em uma estrutura de pastas específica.

Agora, no meu functions.phparquivo principal , só tenho require_oncechamadas para esses arquivos.

Mas, por uma questão de argumento - digamos que vou acabar com 20 arquivos para incluir.

QUESTÕES:

  1. Isso afeta o desempenho do WP de maneira visível?
  2. É melhor manter tudo dentro de 1 arquivo (functions.php)
  3. qual é a melhor maneira de fazer isso?

Obrigado.

MegaMan
fonte

Respostas:

12

1. Isso afeta o desempenho do WP de maneira visível?

Se isso tivesse um efeito real em alguns arquivos pequenos, teria um efeito menor que o WP: PHP e desempenho do servidor. Isso realmente afeta? Na verdade não. Mas você ainda pode simplesmente começar a fazer testes de desempenho.

2. É melhor manter tudo dentro de 1 arquivo (functions.php)

Agora, a pergunta é "o que é melhor"? Do (s) arquivo (s) geral (s), carregando o tempo? Do ponto de vista da organização de arquivos? Enfim, isso não faz nenhuma diferença. Faça isso de maneira a não perder a visão geral e manter o resultado de uma maneira agradável para você.

3. qual é a melhor maneira de fazer isso?

O que normalmente faço é simplesmente conectar em algum lugar (( plugins_loaded, after_setup_themeetc.) - depende do que você precisa) e depois exigir apenas todos eles:

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

De qualquer forma, você também pode torná-lo um pouco mais complicado e flexível. Veja esse exemplo:

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

É uma classe que faz basicamente o mesmo (precisa do PHP 5.3 ou superior). O benefício é que ele é um pouco mais refinado, para que você possa carregar arquivos com facilidade das pastas necessárias para executar uma tarefa específica:

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

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

Atualizar

Como vivemos em um novo mundo pós-PHP v5.2, podemos fazer uso do \FilterIterator. Exemplo da variante mais curta:

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

Se você precisa seguir o PHP v5.2, ainda pode seguir \DirectoryIteratoro código e praticamente o mesmo.

kaiser
fonte
legal. Obrigado pela explicação :) A verificação de arquivos em uma pasta específica provavelmente não ajudará no que estou fazendo, embora seja uma boa idéia. Eu estou tentando fazer uma estrutura que é modular. Então todos os "módulos" estariam em arquivos separados, que seriam listados como entradas separadas (require_once) no functions.php. Dessa forma, se alguém não quiser incluir um dos módulos (por exemplo: personalizador de temas) - basta comentar isso etc. Esse é o plano de qualquer maneira :) Obrigado novamente.
MegaMan 29/08
@MegaMan Você também pode filtrar a saída antes de chamar loadFile()ou require_once. Portanto, basta oferecer algo como suporte ao tema, onde o próprio usuário pode usar add_theme_support()/remove_*()apenas os módulos que deseja. Em seguida, basta usar o resultado para $loadFile()ou glob(). Aliás, se essa foi sua solução, marque-a como tal. Obrigado.
Kaiser #
0

Eu reformulei a resposta do @kaiser um pouco para as minhas necessidades - pensei em compartilhar. Eu queria mais opções, essas são explicadas dentro do código e no exemplo de uso abaixo.

Código:

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


Exemplo de uso:

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