Wie erhalte ich den unqualifizierten (kurzen) Klassennamen eines Objekts?

Wie überprüfe ich die Klasse eines Objekts in der Umgebung mit PHP-Namensabständen, ohne die vollständige Klasse mit Namensabständen anzugeben?

Angenommen, 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 Namespace Magic-Schlüsselwort gibt den aktuellen Namespace zurück. Dies ist nicht sinnvoll, wenn das getestete Objekt einen anderen Namespace hat.

Ich könnte einfach den vollständigen Klassennamen mit Namespaces angeben, aber dies scheint die Struktur des Codes zu blockieren. Auch nicht sehr nützlich, wenn ich den Namespace 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 verwendenReflectionClass::getShortName Methode verwenden, die den Namen der Klasse ohne ihren Namespace abruft.

Zuerst müssen Sie eine ReflectionClassInstanz erstellen und dann die getShortNameMethode dieser Instanz aufrufen :

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

Ich kann mir jedoch nicht viele Umstände vorstellen, unter denen dies wünschenswert wäre. Wenn Sie möchten, dass das Objekt Mitglied einer bestimmten Klasse ist, können Sie es mit testen instanceof. Wenn Sie eine flexiblere Methode zum Signalisieren bestimmter Einschränkungen wünschen, müssen Sie dazu eine Schnittstelle schreiben und verlangen, dass der Code diese Schnittstelle implementiert. Auch hier ist der richtige Weg, dies zu tun instanceof. (Sie können es damit machen ReflectionClass, aber 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 angebotenen Lösungen die schnellste ist, deshalb 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('\\', '/', 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 dem Test von https://stackoverflow.com/a/25472778/2386943 substr hinzugefügt, und so konnte ich (CentOS PHP 5.3.3, Ubuntu PHP 5.5.9) beide mit einem i5 testen.

$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('\\', '/', 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";

== UPDATE ==

Wie in den Kommentaren von @MrBandersnatch erwähnt, gibt es noch einen schnelleren Weg, dies zu tun:

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

Hier sind die aktualisierten Testergebnisse mit "SubstringStrChr" (spart bis zu 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

Dies ist eine einfachere Möglichkeit, 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__);

Ich benutze das:

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

So erhalten Sie den Kurznamen als Einzeiler (seit PHP 5.4 ):

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

Es ist ein sauberer Ansatz und vernünftig schnell .

Ich befand mich in einer einzigartigen Situation, in der ich instanceofnicht verwendet werden konnte (insbesondere Merkmale mit Namensraum), und ich brauchte den Kurznamen so effizient wie möglich, sodass ich selbst einen kleinen Benchmark erstellt habe. Es enthält alle verschiedenen Methoden und Variationen der Antworten in dieser 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('\\', '/', 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 des gesamten Ergebnisses finden Sie hier, aber hier sind die Highlights:

• Wenn Sie sowieso Verwendung Reflexion gehen, verwenden $obj->getShortName()ist die schnellste Methode jedoch ; Es ist fast die langsamste Methode , Reflexion nur zu verwenden, um den Kurznamen zu erhalten.
• 'strrpos' kann einen falschen Wert zurückgeben, wenn sich das Objekt nicht in einem Namespace befindet 'safe strrpos' befindet. es also etwas langsamer ist, würde ich sagen, dass dies der Gewinner ist.
• Um die 'basename'Kompatibilität zwischen Linux und Windows zu gewährleisten, müssen Sie diese verwenden str_replace(), wodurch diese Methode die langsamste von allen ist.

In einer vereinfachten Ergebnistabelle wird die Geschwindigkeit 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%  |
+-----------------+--------+

Sie können explodeden Namespace trennen und endden Klassennamen abrufen:

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

Yii Weg

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

Yii verwendet diese Methode in seinem Gii-Codegenerator

Methodendokumentation

Diese Methode ähnelt der PHP-Funktion basename (), behandelt jedoch sowohl \ als auch / als Verzeichnistrennzeichen, unabhängig vom Betriebssystem. Diese Methode wurde hauptsächlich für PHP-Namespaces entwickelt. Wenn Sie mit echten Dateipfaden arbeiten, sollte der Basisname () von PHP für Sie gut funktionieren. Hinweis: Diese Methode kennt weder das tatsächliche Dateisystem noch Pfadkomponenten wie "..".

Mehr Informationen:

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

Hier ist eine einfache Lösung für 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()));
        }
    }
}

Was wird zurückgegeben?

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
}

Der erweiterte Klassenname und der erweiterte Namespace eignen sich gut für:

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
}

Was ist mit der Klasse im globalen Namespace?

namespace {

    class ClassWithoutNamespace {
        use \Names;
    }

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

Wenn Sie den Klassennamen kennen müssen, der innerhalb einer Klasse aufgerufen wurde, und den Namespace nicht möchten, können Sie diesen verwenden

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

Dies ist ideal, wenn Sie eine Methode in einer Klasse haben, die um andere Klassen erweitert wird. Darüber hinaus funktioniert dies auch, wenn Namespaces überhaupt nicht verwendet werden.

Beispiel:

<?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)

Basierend auf der Antwort von @MaBi habe ich Folgendes gemacht:

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

Was Sie so verwenden können:

namespace Foo\Bar\Baz;

class A
{
    use ClassShortNameTrait;
}

A::classkehrt zurück Foo\Bar\Baz\A, A::getClassShortName()kehrt aber zurück A.

Funktioniert für PHP> = 5.5.

Ich weiß, dass dies ein alter Beitrag ist, aber das ist, was ich benutze - Schneller als alle oben genannten, rufen Sie einfach diese Methode aus Ihrer Klasse auf, viel schneller als mit Reflection

namespace Foo\Bar\Baz;

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

Gefunden auf der Dokumentationsseite von get_class , wo es von mir bei nwhiting dot com gepostet wurde .

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];
}

Die Idee von Namespaces ist jedoch, Ihren Code zu strukturieren. Das bedeutet auch, dass Sie Klassen mit demselben Namen in mehreren Namespaces haben können. Theoretisch könnte das Objekt, das Sie übergeben, den Klassennamen name (stripped) haben und dennoch ein völlig anderes Objekt sein als erwartet.

Außerdem möchten Sie möglicherweise nach einer bestimmten Basisklasse suchen . In diesem Fall get_classreicht der Trick überhaupt nicht aus. Vielleicht möchten Sie den Operator überprüfen instanceof.

Möglicherweise erhalten Sie ein unerwartetes Ergebnis, wenn die Klasse keinen Namespace hat. Dh get_classkehrt Foo, dann $baseClasswäre oo.

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

Dies kann leicht behoben werden, indem get_classein Backslash vorangestellt wird :

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

Jetzt geben auch Klassen ohne Namespace den richtigen Wert zurück.

Ein guter alter Regex scheint schneller zu sein als die meisten der zuvor gezeigten Methoden:

// both of the below calls will output: ShortClassName

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

Dies funktioniert also auch, wenn Sie einen kurzen Klassennamen oder einen vollständig qualifizierten (kanonischen) Klassennamen angeben.

Der Regex verbraucht alle vorherigen Zeichen, bis das letzte Trennzeichen gefunden wird (das auch verbraucht wird). Die verbleibende Zeichenfolge ist also der kurze Klassenname.

Wenn Sie ein anderes Trennzeichen verwenden möchten (z. B. /), verwenden Sie stattdessen einfach dieses Trennzeichen. Denken Sie daran, den Backslash (dh. \) Und auch das Musterzeichen (dh. /) Im Eingabemuster zu umgehen.

Da "ReflectionClass" versionabhängig sein kann, verwenden Sie einfach Folgendes:

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

oder sogar klar

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

Zitieren von php.net:

Unter Windows werden sowohl Schrägstrich (/) als auch Backslash () als Verzeichnistrennzeichen verwendet. In anderen Umgebungen ist dies der Schrägstrich (/).

Basierend auf diesen Informationen und der Erweiterung von arzzzen answer sollte dies sowohl auf Windows- als auch auf Nix * -Systemen funktionieren:

<?php

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

Hinweis: Ich habe einen Benchmark von ReflectionClassgegen basename+str_replace+get_classund Reflexion durchgeführt, der ungefähr 20% schneller ist als der Basisnamen-Ansatz, aber YMMV.

Die schnellste und einfachste Lösung, die in jeder Umgebung funktioniert, ist:

<?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));

Wenn Sie nur Namensräume entfernen und nach dem letzten \ in einem Klassennamen mit Namespace etwas möchten (oder nur den Namen, wenn kein '\' vorhanden ist), können Sie Folgendes tun:

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

Grundsätzlich ist es Regex, eine beliebige Kombination von Zeichen oder Backslashes zu erhalten und bis zum letzten Backslash nur die Nicht-Backslash-Zeichen bis zum Ende der Zeichenfolge zurückzugeben. Hinzufügen der? Wenn nach der ersten Gruppierung die Musterübereinstimmung nicht vorhanden ist, wird nur die vollständige Zeichenfolge zurückgegeben.

Am schnellsten habe ich hier für PHP 7.2am gefundenUbubntu 18.04

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