Autochargeur de fonctions

si vous utilisez Composer dans votre projet, vous pouvez ajouter une directive files à la section autoload.

cela va générer une require_once dans l'autoloader, mais cela ressemble à un vrai autoloading, parce que vous n'avez pas à vous en occuper.

Ses pas le chargement paresseux.

exemple tiré de Assetic :

"autoload": {
        "psr-0": { "Assetic": "src/" },
        "files": [ "src/functions.php" ]
    }

j'ai lu quelque chose il y a quelque temps au sujet d'un hack laid qui a attrapé des erreurs fatales et a essayé d'inclure et d'exécuter la fonction manquante(s), mais je ne voudrais certainement pas prendre cette route.

la chose la plus proche que vous avez est le __call() méthode magique , qui est une sorte de __autoload() pour les méthodes, pas les fonctions. Il pourrait être assez bon pour vos besoins; si vous pouvez vous permettre d'appeler une classe et demander à chaque fonction séparément. Depuis PHP 5.3.0, vous avez aussi __callStatic() .

exemple utilisant __callStatic() :

class Test
{
    public function __callStatic($m, $args)
    {
        if (function_exists($m) !== true)
        {
            if (is_file('./path/to/functions/' . $m . '.php') !== true)
            {
                return false;
            }

            require('./path/to/functions/' . $m . '.php');
        }

        return call_user_func_array($m, $args);
    }
}

Test::functionToLoad(1, 2, 3);

cela appellerait la fonction functionToLoad() définie dans ./chemin/vers/fonctions/functionToLoad.php.

Eh bien, comme d'habitude il y a une extension PECL pour cela:

• automap ^PECL

(via: http://phk.tekwire.net/joomla/support/doc/automap.htm )

il est censé autoload fonctions ainsi que les classes. Qui cependant ne fonctionne pas encore avec L'interpréteur PHP actuel.

(Une option alternative, btw, est de générer des fonctions de BUB qui chargent et exécutent des contreparties namespaced.)

cela dit. Chargement automatique n'est pas universellement considérée comme une bonne pratique. Cela conduit à des hiérarchies de classe trop fracturées et au bonheur de l'objet. Et la vraie raison pour laquelle PHP a l'autoloading est parce que les systèmes de gestion des inclusions et des dépendances sont en nature.

namespace MyNamespace;

class Fn {

    private function __construct() {}
    private function __wakeup() {}
    private function __clone() {}

    public static function __callStatic($fn, $args) {
        if (!function_exists($fn)) {
            $fn = "YOUR_FUNCTIONS_NAMESPACE\$fn";
            require str_replace('\', '/', $fn) . '.php';
        }
        return call_user_func_array($fn, $args);
    }

}

et en utilisant des espaces de noms, nous pouvons faire: Fn::myFunc() et spl_autoload_register() . J'ai utilisé ce code avec des exemples à: https://goo.gl/8dMIMj

voici un autre exemple assez complexe, basé sur les suggestions de cette discussion. Le code peut également être consulté ici: lib / btr.php

<?php
/**
 * A class that is used to autoload library functions.
 *
 * If the function btr::some_function_name() is called, this class
 * will convert it into a call to the function
 * 'BTranslator\some_function_name()'. If such a function is not
 * declared then it will try to load these files (in this order):
 *   - fn/some_function_name.php
 *   - fn/some_function.php
 *   - fn/some.php
 *   - fn/some/function_name.php
 *   - fn/some/function.php
 *   - fn/some/function/name.php
 * The first file that is found will be loaded (with require_once()).
 *
 * For the big functions it makes more sense to declare each one of them in a
 * separate file, and for the small functions it makes more sense to declare
 * several of them in the same file (which is named as the common prefix of
 * these files). If there is a big number of functions, it can be more
 * suitable to organize them in subdirectories.
 *
 * See: /q/autoloader-for-functions-9970/"Function $btr_function could not be found on $dir");
      }
    }
    return call_user_func_array($btr_function, $args);
  }

  /**
   * Try to load files from subdirectories
   * (by replacing '_' with '/' in the function name).
   */
  protected static function load_search_dirs($fname) {
    do {
      self::debug($fname);
      if (file_exists(self::file($fname))) {
        require_once(self::file($fname));
        return TRUE;
      }
      if (self::load_search_files($fname)) {
        return TRUE;
      }
      $fname1 = $fname;
      $fname = preg_replace('#_#', '/', $fname, 1);
    } while ($fname != $fname1);

    return FALSE;
  }

  /**
   * Try to load files from different file names
   * (by removing the part after the last undescore in the functin name).
   */
  protected static function load_search_files($fname) {
    $fname1 = $fname;
    $fname = preg_replace('/_[^_]*$/', '', $fname);
    while ($fname != $fname1) {
      self::debug($fname);
      if (file_exists(self::file($fname))) {
        require_once(self::file($fname));
        return TRUE;
      }
      $fname1 = $fname;
      $fname = preg_replace('/_[^_]*$/', '', $fname);
    }

    return FALSE;
  }

  /**
   * Debug the order in which the files are tried to be loaded.
   */
  public static function debug($fname) {
    if (!self::DEBUG) {
      return;
    }
    $file = self::file($fname);
    $file = str_replace(DRUPAL_ROOT, '', $file);
    self::log($file, 'Autoload');
  }

  /**
   * Output the given parameter to a log file (useful for debugging).
   */
  public static function log($var, $comment ='') {
    $file = '/tmp/btr.log';
    $content = "\n==> $comment: " . print_r($var, true);
    file_put_contents($file, $content, FILE_APPEND);
  }
}

bien que vous ne pouvez pas autoload fonctions et constantes, vous pouvez utiliser quelque chose comme jesseschalken/autoload-generator qui détectera automatiquement quels fichiers contiennent des choses qui ne peuvent pas être autoloadées et les charger avec empressement.

Inclure toutes les fonctions de fichier dans un fichier et de l'inclure

/ / File 1

db_fct.php

/ / File 2

util_fct.php

//dans une fonction .php comprennent tous les autres fichiers

<?php

require_once 'db_fct.php';
require_once 'util_fct.php';
?>

Inclure des fonctions.php chaque fois que vous avez besoin de fonctions ..

nouvelles fonctions\Debug () avec autoload chargera des fonctions dans l'espace de noms racine.

namespace Functions
{

    class Debug
    {
    }
}
namespace
{

    if (! function_exists('printr')) {

        /**
         *
         * @param mixed $expression
         */
        function printr()
        {
            foreach (func_get_args() as $v) {
                if (is_scalar($v)) {
                    echo $v . "\n";
                } else {
                    print_r($v);
                }
            }
            exit();
        }
    }
}

j'utilise une Classe et __invoquer . Le __invoke la méthode est appelée lorsqu'un script appelle une classe comme une fonction. Je fais souvent quelque chose comme ça:

<?php

namespace API\Config;

class Slim {
  function __invoke() {
    return [
      'settings' => [
        'displayErrorDetails' => true,
        'logger' => [
          'name' => 'api',
          'level' => Monolog\Logger\Logger::DEBUG,
          'path' => __DIR__ . '/../../logs/api.log',
        ],
      ]
    ];
  }
}

je peux alors appeler comme une fonction:

$config = API\Config\Slim;
$app = Slim\App($config())

essayez cette

if ($handle = opendir('functions')) {
    while (false !== ($entry = readdir($handle))) {
        if (strpos($entry, '.php') !== false) {
            include("functions/$entry");
        }
    }
    closedir($handle);
}