¿Cómo obtengo el nombre de clase no calificado (corto) de un objeto?

¿Cómo verifico la clase de un objeto dentro del entorno espaciado de nombre de PHP sin especificar la clase de espacio de nombres completo?

Por ejemplo, supongamos que tengo una biblioteca de objetos / Entidad / Contrato / Nombre.

El siguiente código no funciona ya que get_class devuelve la clase de espacio de nombres completo.

If(get_class($object) == 'Name') {
... do this ...
}

La palabra clave mágica del espacio de nombres devuelve el espacio de nombres actual, que no sirve de nada si el objeto probado tiene otro espacio de nombres.

Simplemente podría especificar el nombre de clase completo con espacios de nombres, pero esto parece bloquear la estructura del código. Tampoco es de mucha utilidad si quisiera cambiar el espacio de nombres dinámicamente.

¿Alguien puede pensar en una manera eficiente de hacer esto? Supongo que una opción es regex.

Puedes hacer esto con reflexión. Específicamente, puede usar el ReflectionClass::getShortNamemétodo, que obtiene el nombre de la clase sin su espacio de nombres.

Primero, necesita crear una ReflectionClassinstancia y luego llamar al getShortNamemétodo de esa instancia:

$reflect = new ReflectionClass($object);
if ($reflect->getShortName() === 'Name') {
    // do this
}

Sin embargo, no puedo imaginar muchas circunstancias en las que esto sería deseable. Si desea exigir que el objeto sea miembro de una determinada clase, la forma de probarlo es con instanceof. Si desea una forma más flexible de señalar ciertas restricciones, la forma de hacerlo es escribir una interfaz y requerir que el código implemente esa interfaz. Nuevamente, la forma correcta de hacer esto es con instanceof. (Puede hacerlo ReflectionClass, pero tendría un rendimiento mucho peor).

(new \ReflectionClass($obj))->getShortName(); es la mejor solución con respecto al rendimiento.

Tenía curiosidad por saber cuál de las soluciones proporcionadas es la más rápida, así que hice una pequeña prueba.

Resultados

Reflection: 1.967512512207 s ClassA
Basename:   2.6840535163879 s ClassA
Explode:    2.6507515668869 s ClassA

Código

namespace foo\bar\baz;

class ClassA{
    public function getClassExplode(){
        return explode('\\', static::class)[0];
    }

    public function getClassReflection(){
        return (new \ReflectionClass($this))->getShortName();
    }

    public function getClassBasename(){
        return basename(str_replace('\\', '/', static::class));
    }
}

$a = new ClassA();
$num = 100000;

$rounds = 10;
$res = array(
    "Reflection" => array(),
    "Basename" => array(),
    "Explode" => array(),
);

for($r = 0; $r < $rounds; $r++){

    $start = microtime(true);
    for($i = 0; $i < $num; $i++){
        $a->getClassReflection();
    }
    $end = microtime(true);
    $res["Reflection"][] = ($end-$start);

    $start = microtime(true);
    for($i = 0; $i < $num; $i++){
        $a->getClassBasename();
    }
    $end = microtime(true);
    $res["Basename"][] = ($end-$start);

    $start = microtime(true);
    for($i = 0; $i < $num; $i++){
        $a->getClassExplode();
    }
    $end = microtime(true);
    $res["Explode"][] = ($end-$start);
}

echo "Reflection: ".array_sum($res["Reflection"])/count($res["Reflection"])." s ".$a->getClassReflection()."\n";
echo "Basename: ".array_sum($res["Basename"])/count($res["Basename"])." s ".$a->getClassBasename()."\n";
echo "Explode: ".array_sum($res["Explode"])/count($res["Explode"])." s ".$a->getClassExplode()."\n";

Los resultados realmente me sorprendieron. Pensé que la solución de explosión sería la forma más rápida de ir ...

Agregué substr a la prueba de https://stackoverflow.com/a/25472778/2386943 y esa es la forma más rápida que podría probar (CentOS PHP 5.3.3, Ubuntu PHP 5.5.9), ambos con un i5.

$classNameWithNamespace=get_class($this);
return substr($classNameWithNamespace, strrpos($classNameWithNamespace, '\\')+1);

Resultados

Reflection: 0.068084406852722 s ClassA
Basename: 0.12301609516144 s ClassA
Explode: 0.14073524475098 s ClassA
Substring: 0.059865570068359 s ClassA 

Código

namespace foo\bar\baz;
class ClassA{
  public function getClassExplode(){
    $c = array_pop(explode('\\', get_class($this)));
    return $c;
  }

  public function getClassReflection(){
    $c = (new \ReflectionClass($this))->getShortName();
    return $c;
  }

  public function getClassBasename(){
    $c = basename(str_replace('\\', '/', get_class($this)));
    return $c;
  }

  public function getClassSubstring(){
    $classNameWithNamespace = get_class($this);
    return substr($classNameWithNamespace, strrpos($classNameWithNamespace, '\\')+1);
  }
}

$a = new ClassA();
$num = 100000;

$rounds = 10;
$res = array(
    "Reflection" => array(),
    "Basename" => array(),
    "Explode" => array(),
    "Substring" => array()
);

for($r = 0; $r < $rounds; $r++){

  $start = microtime(true);
  for($i = 0; $i < $num; $i++){
    $a->getClassReflection();
  }
  $end = microtime(true);
  $res["Reflection"][] = ($end-$start);

  $start = microtime(true);
  for($i = 0; $i < $num; $i++){
    $a->getClassBasename();
  }
  $end = microtime(true);
  $res["Basename"][] = ($end-$start);

  $start = microtime(true);
  for($i = 0; $i < $num; $i++){
    $a->getClassExplode();
  }
  $end = microtime(true);
  $res["Explode"][] = ($end-$start);

  $start = microtime(true);
  for($i = 0; $i < $num; $i++){
    $a->getClassSubstring();
  }
  $end = microtime(true);
  $res["Substring"][] = ($end-$start);
}

echo "Reflection: ".array_sum($res["Reflection"])/count($res["Reflection"])." s ".$a->getClassReflection()."\n";
echo "Basename: ".array_sum($res["Basename"])/count($res["Basename"])." s ".$a->getClassBasename()."\n";
echo "Explode: ".array_sum($res["Explode"])/count($res["Explode"])." s ".$a->getClassExplode()."\n";
echo "Substring: ".array_sum($res["Substring"])/count($res["Substring"])." s ".$a->getClassSubstring()."\n";

== ACTUALIZACIÓN ==

Como se menciona en los comentarios de @MrBandersnatch, incluso hay una forma más rápida de hacer esto:

return substr(strrchr(get_class($this), '\\'), 1);

Estos son los resultados actualizados de la prueba con "SubstringStrChr" (ahorra hasta aproximadamente 0.001 s):

Reflection: 0.073065280914307 s ClassA
Basename: 0.12585079669952 s ClassA
Explode: 0.14593172073364 s ClassA
Substring: 0.060415267944336 s ClassA
SubstringStrChr: 0.059880912303925 s ClassA

Aquí está una manera más fácil de hacer esto si está utilizando el framework PHP Laravel:

<?php

// usage anywhere
// returns HelloWorld
$name = class_basename('Path\To\YourClass\HelloWorld');

// usage inside a class
// returns HelloWorld
$name = class_basename(__CLASS__);

Yo uso esto:

basename(str_replace('\\', '/', get_class($object)));

Para obtener el nombre corto como una línea (desde PHP 5.4 ):

echo (new ReflectionClass($obj))->getShortName();

Es un enfoque limpio y razonablemente rápido .

Me encontré en una situación única en la instanceofque no se podía usar (rasgos específicamente con espacios de nombres) y necesitaba el nombre corto de la manera más eficiente posible, así que he hecho un pequeño punto de referencia propio. Incluye todos los diferentes métodos y variaciones de las respuestas en esta pregunta.

$bench = new \xori\Benchmark(1000, 1000);     # https://github.com/Xorifelse/php-benchmark-closure
$shell = new \my\fancy\namespace\classname(); # Just an empty class named `classname` defined in the `\my\fancy\namespace\` namespace

$bench->register('strrpos', (function(){
    return substr(static::class, strrpos(static::class, '\\') + 1);
})->bindTo($shell));

$bench->register('safe strrpos', (function(){
    return substr(static::class, ($p = strrpos(static::class, '\\')) !== false ? $p + 1 : 0);
})->bindTo($shell));

$bench->register('strrchr', (function(){
    return substr(strrchr(static::class, '\\'), 1);
})->bindTo($shell));

$bench->register('reflection', (function(){
    return (new \ReflectionClass($this))->getShortName();
})->bindTo($shell));

$bench->register('reflection 2', (function($obj){
    return $obj->getShortName();
})->bindTo($shell), new \ReflectionClass($shell));

$bench->register('basename', (function(){
    return basename(str_replace('\\', '/', static::class));
})->bindTo($shell));

$bench->register('explode', (function(){
    $e = explode("\\", static::class);
    return end($e);
})->bindTo($shell));

$bench->register('slice', (function(){
    return join('',array_slice(explode('\\', static::class), -1));
})->bindTo($shell));    

print_r($bench->start());

Una lista del resultado completo está aquí, pero aquí están los aspectos más destacados:

• Si usted va a utilizar la reflexión de todos modos, el uso $obj->getShortName()es el método más rápido , sin embargo ; usando solo reflexión para obtener el nombre corto, es casi el método más lento.
• 'strrpos' puede devolver un valor incorrecto si el objeto no está en un espacio de nombres, así que mientras 'safe strrpos' es un poco más lento, diría que este es el ganador.
• Para hacer 'basename'compatible entre Linux y Windows, debe usarstr_replace() que hace que este método sea el más lento de todos.

Una tabla de resultados simplificada, la velocidad se mide en comparación con el método más lento:

+-----------------+--------+
| registered name | speed  |
+-----------------+--------+
| reflection 2    | 70.75% |
| strrpos         | 60.38% |
| safe strrpos    | 57.69% |
| strrchr         | 54.88% |
| explode         | 46.60% |
| slice           | 37.02% |
| reflection      | 16.75% |
| basename        | 0.00%  |
+-----------------+--------+

Puede usar explodepara separar el espacio de nombres y endobtener el nombre de la clase:

$ex = explode("\\", get_class($object));
$className = end($ex);

Yii way

\yii\helpers\StringHelper::basename(get_class($model));

Yii usa este método en su generador de código Gii

Documentación del método

Este método es similar a la función php basename () excepto que tratará los separadores de directorio \ y / as, independientemente del sistema operativo. Este método fue creado principalmente para trabajar en espacios de nombres php. Cuando trabaje con rutas de archivos reales, el nombre base de php () debería funcionar bien para usted. Nota: este método no conoce el sistema de archivos real o los componentes de ruta como "..".

Más información:

https://github.com/yiisoft/yii2/blob/master/framework/helpers/BaseStringHelper.php http://www.yiiframework.com/doc-2.0/yii-helpers-basestringhelper.html#basename()-detail

Aquí hay una solución simple para PHP 5.4+

namespace {
    trait Names {
        public static function getNamespace() {
            return implode('\\', array_slice(explode('\\', get_called_class()), 0, -1));
        }

        public static function getBaseClassName() {
            return basename(str_replace('\\', '/', get_called_class()));
        }
    }
}

¿Qué será el regreso?

namespace x\y\z {
    class SomeClass {
        use \Names;
    }

    echo \x\y\z\SomeClass::getNamespace() . PHP_EOL; // x\y\z
    echo \x\y\z\SomeClass::getBaseClassName() . PHP_EOL; // SomeClass
}

El nombre de clase extendido y el espacio de nombres funcionan bien para:

namespace d\e\f {

    class DifferentClass extends \x\y\z\SomeClass {

    }

    echo \d\e\f\DifferentClass::getNamespace() . PHP_EOL; // d\e\f
    echo \d\e\f\DifferentClass::getBaseClassName() . PHP_EOL; // DifferentClass
}

¿Qué pasa con la clase en el espacio de nombres global?

namespace {

    class ClassWithoutNamespace {
        use \Names;
    }

    echo ClassWithoutNamespace::getNamespace() . PHP_EOL; // empty string
    echo ClassWithoutNamespace::getBaseClassName() . PHP_EOL; // ClassWithoutNamespace
}

Si necesita saber el nombre de la clase que se llamó desde dentro de una clase y no desea el espacio de nombres, puede usar este

$calledClass = get_called_class();
$name = strpos($calledClass, '\\') === false ?
    $calledClass : substr($calledClass, strrpos($calledClass, '\\') + 1);

Esto es genial cuando tienes un método dentro de una clase que se extiende por otras clases. Además, esto también funciona si los espacios de nombres no se utilizan en absoluto.

Ejemplo:

<?php
namespace One\Two {
    class foo
    {
        public function foo()
        {
            $calledClass = get_called_class();
            $name = strpos($calledClass, '\\') === false ?
                $calledClass : substr($calledClass, strrpos($calledClass, '\\') + 1);

            var_dump($name);
        }
    }
}

namespace Three {
    class bar extends \One\Two\foo
    {
        public function bar()
        {
            $this->foo();
        }
    }
}

namespace {
    (new One\Two\foo)->foo();
    (new Three\bar)->bar();
}

// test.php:11:string 'foo' (length=3)
// test.php:11:string 'bar' (length=3)

Basado en la respuesta de @MaBi, hice esto:

trait ClassShortNameTrait
{
    public static function getClassShortName()
    {
        if ($pos = strrchr(static::class, '\\')) {
            return substr($pos, 1);
        } else {
            return static::class;
        }
    }
}

Que puedes usar así:

namespace Foo\Bar\Baz;

class A
{
    use ClassShortNameTrait;
}

A::classvuelve Foo\Bar\Baz\A, pero A::getClassShortName()vuelveA .

Funciona para PHP> = 5.5.

Sé que esta es una publicación antigua, pero esto es lo que uso: más rápido que todo lo publicado anteriormente, solo llame a este método desde su clase, mucho más rápido que usar Reflection

namespace Foo\Bar\Baz;

class Test {
    public function getClass() {
        return str_replace(__NAMESPACE__.'\\', '', static::class);
    }
}

Encontrado en la página de documentación de get_class , donde lo publiqué en nwhiting dot com .

function get_class_name($object = null)
{
    if (!is_object($object) && !is_string($object)) {
        return false;
    }

    $class = explode('\\', (is_string($object) ? $object : get_class($object)));
    return $class[count($class) - 1];
}

Pero la idea de los espacios de nombres es estructurar su código. Eso también significa que puede tener clases con el mismo nombre en múltiples espacios de nombres. Entonces, teóricamente, el objeto que pasa podría tener el nombre de clase (despojado), sin dejar de ser un objeto totalmente diferente de lo que espera.

Además de eso, es posible que desee verificar una clase base específica , en cuyo caso get_classno sirve para nada. Es posible que desee consultar el operador instanceof.

Puede obtener un resultado inesperado cuando la clase no tiene un espacio de nombres. Es decir , get_classvuelve Foo, entonces $baseClasssería oo.

$baseClass = substr(strrchr(get_class($this), '\\'), 1);

Esto se puede solucionar fácilmente mediante el prefijo get_classcon una barra diagonal inversa:

$baseClass = substr(strrchr('\\'.get_class($this), '\\'), 1);

Ahora también las clases sin un espacio de nombres devolverán el valor correcto.

Una buena expresión regular parece ser más rápida que la mayoría de los métodos mostrados anteriormente:

// both of the below calls will output: ShortClassName

echo preg_replace('/.*\\\\/', '', 'ShortClassName');
echo preg_replace('/.*\\\\/', '', 'SomeNamespace\SomePath\ShortClassName');

Esto funciona incluso cuando proporciona un nombre de clase corto o un nombre de clase totalmente calificado (canónico).

Lo que hace la expresión regular es que consume todos los caracteres anteriores hasta que se encuentra el último separador (que también se consume). Entonces la cadena restante será el nombre corto de la clase.

Si desea usar un separador diferente (p. Ej. /), Simplemente use ese separador en su lugar. Recuerde escapar de la barra diagonal inversa (es decir, \) y también del patrón char (es decir, /) en el patrón de entrada.

Debido a que "ReflectionClass" puede depender de la versión, solo use lo siguiente:

if(class_basename(get_class($object)) == 'Name') {
... do this ...
}

o incluso claro

if(class_basename(ClassName::class) == 'ClassName') {
... do this ...
}

Citando php.net:

En Windows, tanto la barra inclinada (/) como la barra invertida () se utilizan como caracteres separadores de directorio. En otros entornos, es la barra diagonal (/).

Según esta información y expandiendo desde la respuesta de arzzzen, esto debería funcionar tanto en los sistemas Windows como en los sistemas Nix *:

<?php

if (basename(str_replace('\\', '/', get_class($object))) == 'Name') {
    // ... do this ...
}

Nota: Hice un punto de referencia de ReflectionClasscontra basename+str_replace+get_classy usar la reflexión es aproximadamente un 20% más rápido que usar el enfoque de nombre base, pero YMMV.

La solución más rápida y fácil que funciona en cualquier entorno es:

<?php

namespace \My\Awesome\Namespace;

class Foo {

  private $shortName;

  public function fastShortName() {
    if ($this->shortName === null) {
      $this->shortName = explode("\\", static::class);
      $this->shortName = end($this->shortName);
    }
    return $this->shortName;
  }

  public function shortName() {
    return basename(strtr(static::class, "\\", "/"));
  }

}

echo (new Foo())->shortName(); // "Foo"

?>

$shortClassName = join('',array_slice(explode('\\', $longClassName), -1));

Si solo está eliminando espacios de nombres y desea algo después del último \ en un nombre de clase con espacio de nombres (o solo el nombre si no hay '\'), puede hacer algo como esto:

$base_class = preg_replace('/^([\w\\\\]+\\\\)?([^\\\\]+)$/', '$2', get_class($myobject));

Básicamente, es una expresión regular para obtener cualquier combinación de caracteres o barras invertidas y hasta la última barra invertida y luego devolver solo los caracteres que no son barras invertidas y hasta el final de la cadena. Agregar el? después de la primera agrupación significa que si la coincidencia de patrón no existe, solo devuelve la cadena completa.

Más rápido que encontré aquí para PHP 7.2elUbubntu 18.04

preg_replace('/^(\w+\\\)*/', '', static::class)