Single functions.php ou dividido em vários arquivos pequenos?

13

Estou criando uma estrutura simples com opções de tema. Eu dividi pedaços de código dentro de functions.php e coloquei dentro de uma estrutura de pastas específica.

Agora, no meu arquivo functions.php principal, só tenho require_once chamadas para esses arquivos.

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

PERGUNTAS:

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

Obrigado.

    
por MegaMan 28.08.2013 / 15:03

2 respostas

11
  

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

SE teria um efeito real para alguns arquivos pequenos, então teria um efeito que teria um impacto menor do que o WP: PHP e desempenho do servidor. Isso realmente tem um efeito? Na verdade não. Mas você ainda pode simplesmente começar a fazer testes de desempenho.

  

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

Agora a pergunta é "O que é melhor"? De arquivo (s) total (is) tempo de carregamento? Do ponto de vista da organização de arquivos? De qualquer forma, não faz diferença. Faça isso de uma forma que você não perca a visão geral e possa manter o resultado de uma forma agradável para você.

  

3. qual é a melhor maneira de fazer isso?

O que eu normalmente faço é simplesmente ligar em algum lugar ( plugins_loaded , after_setup_theme , etc. - depende do que você precisa) e, em seguida, exigir todos eles:

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

De qualquer forma, você pode torná-lo um pouco mais complicado e flexível também. Dê uma olhada nesse 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+). O benefício é que ele é um pouco mais refinado, para que você possa facilmente carregar arquivos 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 usar o \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ê tem que ficar com o PHP v5.2, então você ainda pode ir com o \DirectoryIterator e praticamente o mesmo código.

    
por kaiser 28.08.2013 / 16:47
1

Eu retrabalhei o @kaiser para responder um pouco às minhas necessidades - pensei em compartilhá-lo. 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 );
}
    
por Nicolai 20.04.2014 / 23:35