fonctions Auto-chargement des meilleures pratiques

Question

Lorsque vous travaillez sur un projet PHP qui profite du paradigme OOP avec la fonction PHP __autoload(), ce qui ce qui suit est considéré comme la meilleure pratique pour la gestion des fonctions autonomes:

(exemples fournis simplifié par souci de concision)

tl; dr: Comment se charge de la fonction autonome couramment traitée:

• pseudo-autoloading (via __callStatic magique par exemple) [Option 1]
• classe d'aide abstraite regroupées méthodes statiques [Option 2]
• une alternative

A noter également, J'ai posté une question connexe concernant un problème de paramètre/référence avec option 1, qui peut être trouvé ici: __callStatic(), call_user_func_array(), references, and PHP 5.3.1

fournies dans index.php:

function __autoload($class){ 
    require $class . '.class.php'; 
} 

Option 1; Une classe abstraite Core (ou Library, ou autre) que les fonctions "de" charge automatiquement:

## Core.class.php 
abstract class Core{ 
    public static function __callStatic($function, $arguments){ 
     if(!function_exists($function)){ 
      require $function . '.function.php'; 
     } 
     return call_user_func_array($function, $arguments); 
    } 
} 

## SayHello.function.php 
function sayHello(){ 
    echo 'Hello'; 
} 

## SayGoodbye.function.php 
function sayGoodbye(){ 
    echo 'Goodbye'; 
} 

## index.php 
Core::sayHello(); // Hello 
Core::sayGoodbye(); // Goodbye 

Option 2; Le regroupement des fonctions connexes dans « aide » abstraites des classes à appeler statiquement:

## SayStuff.class.php 
abstract class SayStuff{ 
    public static function sayHello(){ 
     echo 'Hello'; 
    } 
    public static function sayGoodbye(){ 
     echo 'Goodbye'; 
    } 
} 

## index.php 
SayStuff::sayHello(); // Hello 
SayStuff::sayGoodbye(); // Goodbye 

Answer 1

Je ne voudrais pas utiliser « Option 1 » surtout parce qu'il utilise call_user_func * qui sera plus lent que l'appel fonction directement. Si vous avez seulement besoin de fonctions d'aide qui ne sont pas vraiment liées, j'inclurais probablement un fichier helpers.php qui aurait juste une liste de toutes mes fonctions auxiliaires qui ne sont pas encapsulées dans une classe statique depuis l'encapsulation n'atteint vraiment rien dans ce cas. La plupart du temps, les fonctions d'assistance seront utilisées pour chaque requête, donc l'inclusion de ce fichier sur chaque requête ne causera aucun dommage ...

Answer 2

je ne vois pas une question précise, mais puisque le titre contient « meilleures pratiques », voici un conseil que je a récemment découvert:

Il seems to be preferable to use PHP's SPL autoload functions instead of __autoload() (bel exemple sur le blog "Dissection by David").

Citant le blog lié:

Les plus grands avantages d'utiliser la version SPL (que je peux voir à jour) sont:

• plus d'une fonction peut être utilisée/les fonctions enregistrées sont enchaînées ensemble et utilisées séquentiellement jusqu'au point d'une fonction en chargeant le fichier de classe. Les fonctions + peuvent également être désenregistrées à la volée.
• Il y a quelques erreurs de gestion des erreurs qui peuvent être implémentées (voir exemple 3), bien que certains obtiennent try/catch, ce qui peut ne pas convenir à votre style de codage .
• en utilisant une extension différente (c'est-à-dire pas .php ou .php.inc ou.inc) si vous choisissez ainsi avec spl_autoload_extensions()
• s'assure que 'ma' classe de chargement automatique n'est pas écrasée! Si __autoload() est exécuté plus tard, mes fonctions spl_autoload_register() ne seront pas remplacées.