Organizzare il Codice nel File functions.php del Tuo Tema WordPress

Risposta tardiva

Come includere i tuoi file nel modo giusto:

function wpse1403_bootstrap()
{
    // Qui carichiamo dalla nostra directory includes
    // Questo considera sia i temi genitori che i temi figli    
    locate_template( array( 'inc/foo.class.php' ), true, true );
}
add_action( 'after_setup_theme', 'wpse1403_bootstrap' );

Lo stesso funziona anche nei plugin.

Come ottenere il percorso o l'URI corretto

Dai anche un'occhiata alle funzioni dell'API del filesystem come:

• home_url()
• plugin_dir_url()
• plugin_dir_path()
• admin_url()
• get_template_directory()
• get_template_directory_uri()
• get_stylesheet_directory()
• get_stylesheet_directory_uri()
• ecc.

Come ridurre il numero di include/require

Se hai bisogno di recuperare tutti i file da una directory usa

foreach ( glob( 'path/to/folder/*.php' ) as $file )
    include $file;

Tieni presente che questo ignora i fallimenti (forse buono per l'uso in produzione)/file non caricabili.

Per modificare questo comportamento potresti voler usare una configurazione diversa durante lo sviluppo:

$files = ( defined( 'WP_DEBUG' ) AND WP_DEBUG )
    ? glob( 'path/to/folder/*.php', GLOB_ERR )
    : glob( 'path/to/folder/*.php' )

foreach ( $files as $file )
    include $file;

Modifica: approccio OOP/SPL

Dato che sono tornato e ho visto che questa risposta sta ricevendo sempre più voti, ho pensato di mostrare come lo faccio oggi - in un mondo PHP 5.3+. Il seguente esempio carica tutti i file da una sottocartella del tema chiamata src/. Qui è dove ho le mie librerie che gestiscono determinati compiti come menu, immagini, ecc. Non devi nemmeno preoccuparti del nome poiché ogni singolo file viene caricato. Se hai altre sottocartelle in questa directory, vengono ignorate.

Il \FilesystemIterator è il successore di PHP 5.3+ rispetto al \DirectoryIterator. Entrambi fanno parte della SPL di PHP. Mentre PHP 5.2 permetteva di disattivare l'estensione SPL integrata (meno dell'1% delle installazioni lo faceva), la SPL ora fa parte del core di PHP.

<?php

namespace Theme;

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

In precedenza, mentre supportavo ancora PHP 5.2.x, usavo la seguente soluzione: un \FilterIterator nella directory src/Filters per recuperare solo i file (e non i puntatori delle cartelle) e un \DirectoryIterator per fare il ciclo e il caricamento.

namespace Theme;

use Theme\Filters\IncludesFilter;

$files = new IncludesFilter( new \DirectoryIterator( __DIR__.'/src' ) );
foreach ( $files as $file )
{
    include_once $files->current()->getRealPath();
}

Il \FilterIterator era semplice così:

<?php

namespace Theme\Filters;

class IncludesFilter extends \FilterIterator
{
    public function accept()
    {
        return
            ! $this->current()->isDot()
            and $this->current()->isFile()
            and $this->current()->isReadable();
    }
}

Oltre al fatto che PHP 5.2 è morto/EOL da tempo (e anche 5.3), c'è il fatto che è più codice e un file in più in gioco, quindi non c'è motivo di usare il secondo e supportare PHP 5.2.x.

Riassunto

MODIFICA Il modo ovviamente corretto è usare codice con namespace, preparato per l'autoloading PSR-4 mettendo tutto nella directory appropriata già definita dal namespace. Poi basta usare Composer e un composer.json per gestire le tue dipendenze e lasciare che costruisca automaticamente il tuo autoloader PHP (che importa automaticamente un file semplicemente chiamando use \<namespace>\ClassName). Questo è lo standard de-facto nel mondo PHP, il modo più semplice per procedere e ancora più pre-automatizzato e semplificato da WP Starter.

Mi piace utilizzare una funzione per i file all'interno di una cartella. Questo approccio rende semplice aggiungere nuove funzionalità quando si aggiungono nuovi file. Ma scrivo sempre in classi o con namespace - questo dà più controllo sul Namespace di funzioni, metodi ecc.

Di seguito un piccolo esempio; mostra anche l'utilizzo con l'accordo riguardo ai file class*.php

public function __construct() {

    $this->load_classes();
}

/**
 * Restituisce un array di funzionalità,
 * Scansiona la sottocartella "/classes" del plugin
 *
 * @since   0.1
 * @return  void
 */
protected function load_classes() {

    // carica tutti i file con il pattern class-*.php dalla directory classes
    foreach( glob( dirname( __FILE__ ) . '/classes/class-*.php' ) as $class )
        require_once $class;

}

Nei temi uso spesso un altro scenario. Definisco la funzione del file esterno in un ID di supporto, vedi l'esempio. Questo è utile se voglio disattivare facilmente la funzionalità del file esterno. Uso la funzione core di WP require_if_theme_supports() che carica solo se l'ID di supporto è attivo. Nell'esempio seguente ho definito questo ID di supporto nella riga prima del caricamento del file.

    /**
     * Aggiungi supporto per il Personalizzatore del Tema
     * 
     * @since  09/06/2012
     */
    add_theme_support( 'documentation_customizer', array( 'all' ) );
    // Includi il personalizzatore del tema per le opzioni del tema, se supportato
    require_if_theme_supports( 
        'documentation_customizer',
        get_template_directory() . '/inc/theme-customize.php'
    );

Puoi vedere di più su questo nel repository di questo tema.

Per quanto riguarda la suddivisione, nel mio boilerplate utilizzo una funzione personalizzata per cercare una cartella chiamata "functions" nella directory del tema. Se non è presente, la crea. Poi crea un array di tutti i file .php che trova in quella cartella (se presenti) ed esegue un include(); per ciascuno di essi.

In questo modo, ogni volta che devo scrivere una nuova funzionalità, aggiungo semplicemente un file PHP alla cartella functions, senza dovermi preoccupare di integrarlo manualmente nel sito.

<?php
/* 
FUNZIONI per includere automaticamente i documenti PHP dalla cartella functions.
*/
//se si utilizza php4, crea una funzione scandir
if (!function_exists('scandir')) {
  function scandir($directory, $sorting_order = 0) {
    $dh = opendir($directory);
    while (false !== ($filename = readdir($dh))) {
      $files[] = $filename;
    }
    if ($sorting_order == 0) {
      sort($files);
    } else {
      rsort($files);
    }
    return ($files);
  }
}
/*
* Questa funzione restituisce il percorso della cartella functions.
* Se la cartella non esiste, la crea.
*/
function get_function_directory_extension($template_url = FALSE) {
  //ottieni l'URL del template se non è passato
  if (!$template_url)$template_url = get_bloginfo('template_directory');


  //sostituisce gli slash con trattini per l'explode
  $template_url_no_slash = str_replace('/', '.', $template_url);

  //crea un array dall'URL
  $template_url_array = explode('.', $template_url_no_slash);

  //--scompone l'array

  //Calcola l'offset (ci servono solo gli ultimi tre livelli)
  //Necessario per ottenere la directory corretta, non quella passata dal server, poiché scandir non funziona con gli alias.
  $offset = count($template_url_array) - 3;

  //scompone l'array, mantenendo solo fino alla cartella radice di WP (dove si trova wp-config.php, da cui viene eseguito il front-end)
  $template_url_array = array_splice($template_url_array, $offset, 3);
  //ricompone in stringa
  $template_url_return_string = implode('/', $template_url_array);
  fb::log($template_url_return_string, 'Template'); //firephp

  //crea la directory di lavoro corrente con l'estensione del template e la directory functions    
  //se in admin, cambia dalla cartella admin prima di salvare la directory di lavoro, poi torna indietro.
  if (is_admin()) {
    $admin_directory = getcwd();
    chdir("..");
    $current_working_directory = getcwd();
    chdir($admin_directory);
  } else {
    $current_working_directory = getcwd();
  }
  fb::log($current_working_directory, 'Directory'); //firephp

  //metodo alternativo se chdir non funziona sul tuo server (alcuni server Windows potrebbero non supportarlo)
  //if (is_admin()) $current_working_directory = str_replace('/wp-admin','',$current_working_directory);

  $function_folder = $current_working_directory . '/' . $template_url_return_string . '/functions';


  if (!is_dir($function_folder)) mkdir($function_folder); //crea la cartella se non esiste già (pigro, ma utile... più o meno)
  //restituisce il percorso
  return $function_folder;

}

//rimuove gli elementi dell'array che non hanno estensione .php
function only_php_files($scan_dir_list = false) {
  if (!$scan_dir_list || !is_array($scan_dir_list)) return false; //se l'elemento non è fornito o non è un array, esci dalla funzione.
  foreach ($scan_dir_list as $key => $value) {
    if (!strpos($value, '.php')) {

      unset($scan_dir_list[$key]);
    }
  }
  return $scan_dir_list;
}
//esegue le funzioni per creare la cartella functions, selezionarla,
//scansionarla, filtrare solo i documenti PHP e includerli nelle funzioni

add_action('wp_head', fetch_php_docs_from_functions_folder(), 1);
function fetch_php_docs_from_functions_folder() {

  //ottieni la directory functions
  $functions_dir = get_function_directory_extension();
  //scansiona la directory e rimuovi i documenti non PHP
  $all_php_docs = only_php_files(scandir($functions_dir));

  //includi i documenti PHP
  if (is_array($all_php_docs)) {
    foreach ($all_php_docs as $include) {
      include($functions_dir . '/' . $include);
    }
  }

}

Gestisco un sito con circa 50 tipi di pagine personalizzate uniche in diverse lingue su un'installazione multisito. Insieme a una MONTAGNA di plugin.

Ad un certo punto siamo stati costretti a dividere tutto. Un file functions con 20-30 mila righe di codice non è affatto divertente.

Abbiamo deciso di rifattorizzare completamente tutto il codice per gestire meglio la codebase. La struttura predefinita dei temi WordPress va bene per siti piccoli, ma non per siti più grandi.

Il nostro nuovo functions.php contiene solo ciò che è necessario per avviare il sito, ma niente che appartenga a una pagina specifica.

Il layout del tema che usiamo ora è simile al pattern di design MVC, ma in uno stile di codifica procedurale.

Per esempio la nostra pagina membri:

page-member.php. Responsabile dell'inizializzazione della pagina. Chiama le corrette funzioni AJAX o simili. Potrebbe essere equivalente alla parte Controller nello stile MVC.

functions-member.php. Contiene tutte le funzioni relative a questa pagina. È incluso anche in diverse altre pagine che necessitano di funzioni per i nostri membri.

content-member.php. Prepara i dati per l'HTML. Potrebbe essere equivalente al Model in MVC.

layout-member.php. La parte HTML.

Dopo aver apportato questi cambiamenti, il tempo di sviluppo è diminuito facilmente del 50% e ora il product owner ha difficoltà ad assegnarci nuovi compiti. :)

Dal file functions.php del tema figlio:

    require_once( get_stylesheet_directory() . '/inc/custom.php' );

Nel file functions.php, un modo più elegante per richiamare un file richiesto sarebbe:

require_once locate_template('/inc/functions/shortcodes.php');

Ho combinato le risposte di @kaiser e @mikeschinkel.

Tengo tutte le personalizzazioni del mio tema in una cartella /includes e all'interno di questa cartella ho tutto suddiviso in sottocartelle.

Voglio che solo /includes/admin e i suoi contenuti vengano inclusi quando true === is_admin()

Se una cartella viene esclusa in iterator_check_traversal_callback restituendo false, allora le sue sottodirectory non verranno iterate (né passate a iterator_check_traversal_callback)

/**
 *  Richiede tutte le personalizzazioni sotto /includes
 */
$includes_import_root = 
    new \RecursiveDirectoryIterator( __DIR__ . '/includes', \FilesystemIterator::SKIP_DOTS );

function iterator_check_traversal_callback( $current, $key, $iterator ) {
    $file_name = $current->getFilename();

    // Includi solo file *.php
    if ( ! $current->isDir() ) {
        return preg_match( '/^.+\.php$/i', $file_name );
    }

    // Non includere la cartella /includes/admin quando sei nel sito pubblico
    return 'admin' === $file_name
        ? is_admin()
        : true;
}

$iterator_filter = new \RecursiveCallbackFilterIterator(
    $includes_import_root, 'iterator_check_traversal_callback'
);

foreach ( new \RecursiveIteratorIterator( $iterator_filter ) as $file ) {
    include $file->getRealPath();
}