es posible obtener la lista de espacios de nombres definidos

Question

Hola,

Me preguntaba si hay una manera en PHP 5.3+ para obtener una lista de espacios de nombres definidos dentro de una aplicación. por lo

si file 1 has namespace FOO y file 2 has namespace BAR

Ahora si incluyo archivo 1 y archivo en el archivo 2 3 Identificación gustaría saber con algún tipo de llamada a la función que FOO BAR espacio de nombres y se cargan.

Quiero lograr esto para asegurarme de que un módulo en mi aplicación esté cargado antes de verificar si la clase existe (con is_callable).

Si esto no es posible, me gustaría saber si hay una función para verificar si se define un espacio de nombre específico, algo así como is_namespace().

Espero que entiendas la idea. y lo que estoy tratando de lograr

Answer 1

En primer lugar, para ver si existe una clase, se usa class_exists. En segundo lugar, puede obtener una lista de las clases con el espacio de nombres usando get_declared_classes.

En el caso más simple, se puede usar esto para encontrar un espacio de nombre coincidente de todos los nombres de las clases declaradas:

function namespaceExists($namespace) { 
    $namespace .= "\\"; 
    foreach(get_declared_classes() as $name) 
     if(strpos($name, $namespace) === 0) return true; 
    return false; 
} 

Otro ejemplo, la siguiente secuencia de comandos genera una estructura de matriz jerárquica de los espacios de nombres declarados:

<?php 
namespace FirstNamespace; 
class Bar {} 

namespace SecondNamespace; 
class Bar {} 

namespace ThirdNamespace\FirstSubNamespace; 
class Bar {} 

namespace ThirdNamespace\SecondSubNamespace; 
class Bar {} 

namespace SecondNamespace\FirstSubNamespace; 
class Bar {} 

$namespaces=array(); 
foreach(get_declared_classes() as $name) { 
    if(preg_match_all("@[^\\\]+(?=\\\)@iU", $name, $matches)) { 
     $matches = $matches[0]; 
     $parent =&$namespaces; 
     while(count($matches)) { 
      $match = array_shift($matches); 
      if(!isset($parent[$match]) && count($matches)) 
       $parent[$match] = array(); 
      $parent =&$parent[$match]; 

     } 
    } 
} 

print_r($namespaces); 

Da:

Array 
(
    [FirstNamespace] => 
    [SecondNamespace] => Array 
     (
      [FirstSubNamespace] => 
     ) 
    [ThirdNamespace] => Array 
     (
      [FirstSubNamespace] => 
      [SecondSubNamespace] => 

     ) 
) 

Answer 2

sé que esta pregunta ya tiene una respuesta, pero quería brindar una solución más realista a lo que creo que es su problema. Si hubiera tenido más tiempo ayer cuando hice mi comentario, habría publicado esto. Perdón por no haberlo hecho

Parece que OP tiene un sistema de módulo que necesita saber si un módulo en particular está cargado antes de permitir una llamada.

En primer lugar, me gustaría decir que el uso de espacios de nombres simplemente para declarar módulos activos es, IMO, abusar de lo que son. Si sigue el objetivo del espacio de nombres al pie de la letra, su estructura puede parecerse más a esto:

Todo su sistema debe estar en su propio espacio de nombres. Llamemos a ese espacio de nombres System. Entonces, los módulos probablemente estarían debajo del espacio de nombre System\Module. Luego, dependiendo de la complejidad, es posible que cada módulo tenga un espacio de nombres bajo System\Module. Tomando sus ejemplos, System\Module\FOO y System\Module\BAR.

Ahora, entremos en un sistema de módulo que se registre en carga.

Primero, necesitamos un lugar para registrarse. Llamemos a eso System\Module\Registry y, dado que es probable que haya muchos registros diferentes, implementará el System\iRegistry.Para abreviar, solo estoy publicando System\Module\Registry. Con toda probabilidad, también implementará algún tipo de modelo de coherencia global, como un singleton, pero tampoco lo estoy mostrando. Aquí está:

<?php 
namespace System\Module 
{ 
    class Registry extends System\Registry 
    { 
     protected $registered = array(); 

     public function register($name=null) 
     { 
      $this->registered[] = $name; 
     } 

     public function isRegistered($module) 
     { 
      // Code to find module 
     } 

     public function getModule($module) 
     { 
      // Code to find module 

      // OR, if you can't find it... 
      throw new ModuleNotRegisteredException("Module named \"{$module}\" could not be found in the registry."); 
     } 
    } 
} 
?> 

Ahora, en cada módulo debe llamar a esta función de registro cuando se carga el archivo. Hay un par de maneras de hacer esto. La primera es tener algo de código en el espacio de nombres del módulo que se ejecuta en carga similar al código proceedural típica:

namespace System\Module\FOO 
{ 
    // Load this module 
    $system->module->register("FOO"); 
} 

Lo anterior significaría la duplicación de código sin embargo. También puede usar autocarga para esto, de esa manera el código de "registro" está en un solo lugar. Aquí hay un concepto muy básico de hacer eso:

spl_autoload_register(
    function ($className) 
    { 
     // Code to load files. 
     // Once loaded register our modules. 
     if($namespace = "System\\Module") 
     { 
      $system->module->register($classname); 
     } 
    } 
); 

Otra posible forma de hacer esto sería definir una interfaz para módulos con una función específica para el registro cuando se inicializa el módulo. Esto, sin embargo, significa que el módulo debe cargarse primero y puede causar sus propios problemas según sus necesidades.

Después de hacer esto:

• tiene un espacio de nombres coherentes para los módulos a vivir en
• tiene una interfaz consistente que permite a cualquier módulo de saber cómo registrar en sí
• se puede ampliar fácilmente la Módulo o interfaces de registro en el futuro para cosas nuevas, mientras mantiene su código limpio y fácil de entender.
• y, lo más importante es, sabrá que sus módulos realmente declararán que están cargados y/o listos en lugar de depender de la magia negra para hacerlo por usted.