Wie erhalte ich den nicht qualifizierten (kurzen) Klassennamen eines Objekts?

Wie überprüfe ich die Klasse eines Objekts innerhalb der PHP-Namespace-Umgebung, ohne die vollständige Namespace-Klasse anzugeben?

Nehmen wir zum Beispiel an, ich hätte eine Objektbibliothek/Entität/Vertrag/Name.

Der folgende Code funktioniert nicht, da get_class die vollständige Namespace-Klasse zurückgibt.

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

Das magische Schlüsselwort namespace gibt den aktuellen Namespace zurück, was sinnlos ist, wenn das getestete Objekt einen anderen Namespace hat.

Ich könnte einfach den vollständigen Klassennamen mit Namensräumen angeben, aber dies scheint die Struktur des Codes einzuschließen. Auch nicht von großem Nutzen, wenn ich den Namensraum dynamisch ändern wollte.

Kann sich jemand einen effizienten Weg vorstellen, dies zu tun. Ich denke, eine Option ist Regex.

Sie können dies mit Reflexion tun. Insbesondere können Sie die verwenden ReflectionClass::getShortName -Methode, die den Namen der Klasse ohne ihren Namensraum erhält.

Zuerst müssen Sie eine erstellen ReflectionClass Instanz, und rufen Sie dann die auf getShortName Methode dieser Instanz:

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

Ich kann mir jedoch nicht viele Umstände vorstellen, in denen dies wünschenswert wäre. Wenn Sie verlangen möchten, dass das Objekt Mitglied einer bestimmten Klasse ist, können Sie es mit testen instanceof. Wenn Sie bestimmte Einschränkungen flexibler signalisieren möchten, können Sie eine Schnittstelle schreiben und verlangen, dass der Code diese Schnittstelle implementiert. Auch hier ist der richtige Weg, dies zu tun, mit instanceof. (Sie können es mit ReflectionClassaber es hätte eine viel schlechtere Leistung.)

(new \ReflectionClass($obj))->getShortName(); ist die beste Lösung in Bezug auf die Leistung.

Ich war neugierig, welche der bereitgestellten Lösungen die schnellste ist, also habe ich einen kleinen Test zusammengestellt.

Ergebnisse

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

Code

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('\\', "https://stackoverflow.com/", 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";

Die Ergebnisse haben mich tatsächlich überrascht. Ich dachte, die Explosionslösung wäre der schnellste Weg …

Ich habe substr zum Test von https://stackoverflow.com/a/25472778/2386943 hinzugefügt und das ist der schnellste Weg, den ich testen konnte (CentOS PHP 5.3.3, Ubuntu PHP 5.5.9), beide mit einem i5.

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

Ergebnisse

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

Code

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('\\', "https://stackoverflow.com/", 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";

==AKTUALISIEREN==

Wie in den Kommentaren von @MrBandersnatch erwähnt, gibt es dafür sogar einen schnelleren Weg:

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

Hier die aktualisierten Testergebnisse mit “SubstringStrChr” (spart bis ca. 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

Hier ist eine einfachere Möglichkeit, dies zu tun, wenn Sie das Laravel PHP-Framework verwenden:

<?php

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

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


/**
 * Get the class "basename" of the given object / class.
 *
 * @param  string|object  $class
 * @return string
 */
function class_basename($class)
{
    $class = is_object($class) ? get_class($class) : $class;

    return basename(str_replace('\\', "https://stackoverflow.com/", $class));
}

Ich benutze das:

basename(str_replace('\\', "https://stackoverflow.com/", get_class($object)));

Um den Kurznamen als Einzeiler zu erhalten (seit PHP5.4):

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

Es ist ein sauberer Ansatz und angemessen schnell.

Ich befand mich in einer einzigartigen Situation, wo instanceof konnten nicht verwendet werden (insbesondere Namensraummerkmale) und I erforderlich den Kurznamen so effizient wie möglich zu verwenden, also habe ich selbst einen kleinen Benchmark durchgeführt. Es enthält alle verschiedenen Methoden und Variationen der Antworten auf diese Frage.

$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('\\', "https://stackoverflow.com/", 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());

Eine Liste der des gesamten Ergebnisses ist hier aber hier die Highlights:

• Wenn Sie werden sowieso Reflektion verwenden, using $obj->getShortName() ist die schnellste Methode jedoch; Reflexion verwenden nur Um den Kurznamen zu erhalten, ist dies fast die langsamste Methode.
• 'strrpos' kann einen falschen Wert zurückgeben, wenn sich das Objekt nicht in einem Namensraum befindet, so while 'safe strrpos' ist ein kleines bisschen langsamer Ich würde sagen, das ist der Gewinner.
• Zu machen 'basename' kompatibel zwischen Linux und Windows, die Sie verwenden müssen str_replace() was diese Methode zur langsamsten von allen macht.

Eine vereinfachte Ergebnistabelle, die Geschwindigkeit wird im Vergleich zur langsamsten Methode gemessen:

+-----------------+--------+
| 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%  |
+-----------------+--------+