PHP - obtenir tous les noms de classe à l'intérieur d'un espace de nom particulier

Mise à jour: Depuis cette réponse, c'est devenu assez populaire, j'ai créé un packagist paquet de simplifier les choses. Il contient en fait ce que j'ai décrit ici, sans la nécessité d'ajouter la classe vous-même ou de configurer les $appRoot manuellement. Il peut éventuellement prendre en charge plus que juste le PSR-4.

Que le paquet peut être trouvé ici: haydenpierce/classe-finder.

$ composer require haydenpierce/class-finder

Voir plus d'infos dans le fichier README.

---

Je n'étais pas heureux avec toutes les solutions ici, donc j'ai fini la construction de ma classe pour gérer cela. Cette solution nécessite que vous:

• À L'Aide De Compositeur
• En utilisant le PSR-4

---

En un mot, cette classe tente de comprendre où les classes vivent sur votre système de fichiers basé sur les espaces de noms que vous avez définies dans composer.json. Par exemple, les classes définies dans l'espace de noms Backup\Test sont trouvés dans /home/hpierce/BackupApplicationRoot/src/Test. Cela peut être de confiance en raison de cartographie de la structure de répertoire de l'espace de noms est requis par le PSR-4:

La zone contiguë des sous-espaces de noms après le "préfixe d'espace de noms"
correspondent à un sous-répertoire dans un "répertoire de base", dans lequel l'
espace de noms séparateurs de représenter des séparateurs de répertoire. Le sous-répertoire
le nom DOIT correspondre au cas de la sous-espaces de noms.

Vous devrez peut-être ajuster appRoot pour pointer vers le répertoire qui contient composer.json.

<?php    
namespace Backup\Util;

class ClassFinder
{
    //This value should be the directory that contains composer.json
    const appRoot = __DIR__ . "/../../";

    public static function getClassesInNamespace($namespace)
    {
        $files = scandir(self::getNamespaceDirectory($namespace));

        $classes = array_map(function($file) use ($namespace){
            return $namespace . '\\' . str_replace('.php', '', $file);
        }, $files);

        return array_filter($classes, function($possibleClass){
            return class_exists($possibleClass);
        });
    }

    private static function getDefinedNamespaces()
    {
        $composerJsonPath = self::appRoot . 'composer.json';
        $composerConfig = json_decode(file_get_contents($composerJsonPath));

        //Apparently PHP doesn't like hyphens, so we use variable variables instead.
        $psr4 = "psr-4";
        return (array) $composerConfig->autoload->$psr4;
    }

    private static function getNamespaceDirectory($namespace)
    {
        $composerNamespaces = self::getDefinedNamespaces();

        $namespaceFragments = explode('\\', $namespace);
        $undefinedNamespaceFragments = [];

        while($namespaceFragments) {
            $possibleNamespace = implode('\\', $namespaceFragments) . '\\';

            if(array_key_exists($possibleNamespace, $composerNamespaces)){
                return realpath(self::appRoot . $composerNamespaces[$possibleNamespace] . implode('/', $undefinedNamespaceFragments));
            }

            array_unshift($undefinedNamespaceFragments, array_pop($namespaceFragments));            
        }

        return false;
    }
}

Je pense que beaucoup de gens ont peut-être un problème de ce genre, donc je me suis appuyé sur les réponses de @hpierce et @loïc-faugeron pour résoudre ce problème.

Avec la catégorie décrite ci-dessous, vous pouvez avoir toutes les classes dans un espace de noms ou qu'ils respectent un certain terme.

<?php
namespace Backup\Util;
final class ClassFinder
{
private static $composer = null;
private static $classes  = [];
public function __construct()
{
self::$composer = null;
self::$classes  = [];
self::$composer = require APP_PATH . '/vendor/autoload.php';
if (false === empty(self::$composer)) {
self::$classes  = array_keys(self::$composer->getClassMap());
}
}
public function getClasses()
{
$allClasses = [];
if (false === empty(self::$classes)) {
foreach (self::$classes as $class) {
$allClasses[] = '\\' . $class;
}
}
return $allClasses;
}
public function getClassesByNamespace($namespace)
{
if (0 !== strpos($namespace, '\\')) {
$namespace = '\\' . $namespace;
}
$termUpper = strtoupper($namespace);
return array_filter($this->getClasses(), function($class) use ($termUpper) {
$className = strtoupper($class);
if (
0 === strpos($className, $termUpper) and
false === strpos($className, strtoupper('Abstract')) and
false === strpos($className, strtoupper('Interface'))
){
return $class;
}
return false;
});
}
public function getClassesWithTerm($term)
{
$termUpper = strtoupper($term);
return array_filter($this->getClasses(), function($class) use ($termUpper) {
$className = strtoupper($class);
if (
false !== strpos($className, $termUpper) and
false === strpos($className, strtoupper('Abstract')) and
false === strpos($className, strtoupper('Interface'))
){
return $class;
}
return false;
});
}
}

Dans ce cas, vous devez utiliser Composer pour effectuer l'auto-chargement de classes. À l'aide de la ClassMap disponibles sur elle, la solution est simplifiée.

Je vais donner un exemple qui est effectivement utilisée dans notre Laravel 5 application, mais il peut être utilisé presque partout. L'exemple suivant renvoie les noms de classe avec l'espace de noms, qui peuvent facilement être prises, si ce n'est pas requise.

Légende

• {{1}} - Chemin d'accès à retirer à partir du fichier chemin d'accès pour obtenir de dossier app
• {{2}} - Le chemin d'accès au dossier de dossier app où les classes existent
• {{3}} de l'espace de Noms de chemin d'accès

Code

$classPaths = glob(str_replace('{{1}}', '',__DIR__) .'{{2}}/*.php');
$classes = array();
$namespace = '{{3}}';
foreach ($classPaths as $classPath) {
$segments = explode('/', $classPath);
$segments = explode('\\', $segments[count($segments) - 1]);
$classes[] = $namespace . $segments[count($segments) - 1];
}

Laravel les gens peuvent utiliser app_path() . '/{{2}}/*.php' à glob().

Vous pouvez utiliser get_declared_classes mais avec un peu de travail supplémentaire.

$needleNamespace = 'MyNamespace';
$classes = get_declared_classes();
$neededClasses = array_filter($classes, function($i) use ($needleNamespace) {
return strpos($i, $needleNamespace) === 0;
});

Alors d'abord vous obtenez toutes les classes déclarées et puis vérifier lequel d'entre eux commence avec votre espace de noms.

Note: vous obtiendrez tableau où les touches ne commence pas par 0. Pour arriver à cela, vous pouvez essayer: array_values($neededClasses);.

pour symfony, vous pouvez utiliser le Finder Composant:

http://symfony.com/doc/current/components/finder.html

Quelques réponses intéressantes ci-dessus, certaines sont en fait particulièrement complexe pour la tâche proposée.

Pour ajouter un goût différent de ses possibilités, voici un moyen rapide et facile de la non-optimisé en fonction pour faire ce que vous demandez l'aide de la plupart des techniques de base et des déclarations communes, je pense:

function classes_in_namespace($namespace) {
$namespace .= '\\';
$myClasses  = array_filter(get_declared_classes(), function($item) use ($namespace) { return substr($item, 0, strlen($namespace)) === $namespace; });
$theClasses = [];
foreach ($myClasses AS $class):
$theParts = explode('\\', $class);
$theClasses[] = end($theParts);
endforeach;
return $theClasses;
}

Utiliser simplement comme:

$MyClasses = classes_in_namespace('namespace\sub\deep');
var_dump($MyClasses);

J'ai écrit cette fonction suppose que vous êtes pas l'ajout de la dernier "slash" (\) sur l'espace de noms, de sorte que vous n'aurez pas à le doubler pour lui échapper. 😉

Veuillez noter que cette fonction n'est qu'un exemple et a de nombreux défauts. Basé sur l'exemple ci-dessus, si vous utilisez la " namespace\sub " et " namespace\sub\deep ' existe, la fonction retournera toutes les classes de découverte dans les deux espaces (à se comporter comme si elle était récursive). Cependant, il serait simple de s'ajuster et de développer cette fonction pour beaucoup plus que cela, la plupart nécessitant un couple de réglages dans le foreach bloc.

Il peut ne pas être le summum de la code-art nouveau, mais au moins il fait ce qui a été proposé et devrait être assez simple pour être auto-explicatif.

J'espère qu'il contribue à ouvrir la voie pour vous d'obtenir ce que vous cherchez.

Remarque: PHP 5 et 7 convivial.