Comment obtenir le nom de classe non qualifié (court) d'un objet?

Comment vérifier la classe d'un objet dans l'environnement d'espacement des noms PHP sans spécifier la classe d'espacement de noms complète.

Par exemple, supposons que j'ai une bibliothèque d'objets / Entité / Contrat / Nom.

Le code suivant ne fonctionne pas car get_class renvoie la classe d'espace de noms complète.

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

Le mot-clé namespace magic renvoie l'espace de noms actuel, ce qui ne sert à rien si l'objet testé a un autre espace de noms.

Je pourrais simplement spécifier le nom de classe complet avec les espaces de noms, mais cela semble verrouiller la structure du code. Aussi peu utile si je voulais changer l'espace de noms de manière dynamique.

Quelqu'un peut-il penser à un moyen efficace de le faire. Je suppose qu'une option est regex.

Vous pouvez le faire avec la réflexion. Plus précisément, vous pouvez utiliser la ReflectionClass::getShortNameméthode, qui obtient le nom de la classe sans son espace de noms.

Tout d'abord, vous devez créer une ReflectionClassinstance, puis appeler la getShortNameméthode de cette instance:

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

Cependant, je ne peux pas imaginer de nombreuses circonstances où cela serait souhaitable. Si vous voulez exiger que l'objet soit membre d'une certaine classe, la façon de le tester est avec instanceof. Si vous voulez une manière plus flexible de signaler certaines contraintes, la manière de le faire est d'écrire une interface et d'exiger que le code implémente cette interface. Encore une fois, la bonne façon de faire est avec instanceof. (Vous pouvez le faire avec ReflectionClass, mais les performances seraient bien pires.)

(new \ReflectionClass($obj))->getShortName(); est la meilleure solution en termes de performances.

J'étais curieux de savoir laquelle des solutions proposées était la plus rapide, j'ai donc préparé un petit test.

Résultats

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";

Les résultats m'ont surpris. Je pensais que la solution exploser serait le moyen le plus rapide d'aller ...

J'ai ajouté substr au test de https://stackoverflow.com/a/25472778/2386943 et c'est la manière la plus rapide que j'ai pu tester (CentOS PHP 5.3.3, Ubuntu PHP 5.5.9) à la fois avec un i5.

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

Résultats

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";

== MISE À JOUR ==

Comme mentionné dans les commentaires de @MrBandersnatch, il existe un moyen encore plus rapide de le faire:

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

Voici les résultats des tests mis à jour avec "SubstringStrChr" (enregistre jusqu'à environ 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

Voici un moyen plus simple de le faire si vous utilisez le 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__);

J'utilise ceci:

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

Pour obtenir le nom court en une seule ligne (depuis PHP 5.4 ):

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

C'est une approche propre et raisonnable rapide .

Je me suis retrouvé dans une situation unique où instanceofje ne pouvais pas être utilisé (en particulier les traits d'espacement de noms) et j'avais besoin du nom court de la manière la plus efficace possible, alors j'ai fait un petit benchmark par moi-même. Il comprend toutes les différentes méthodes et variations des réponses à cette question.

$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());

Une liste de l'ensemble du résultat est ici mais voici les faits saillants:

• Si vous allez à la réflexion de l' utilisation de toute façon, à l' aide $obj->getShortName()est la méthode la plus rapide cependant ; en utilisant la réflexion uniquement pour obtenir le nom court, c'est presque la méthode la plus lente.
• 'strrpos'peut renvoyer une valeur erronée si l'objet n'est pas dans un espace de noms, alors que 'safe strrpos'c'est un tout petit peu plus lent, je dirais que c'est le gagnant.
• Pour rendre 'basename'compatible entre Linux et Windows, vous devez utiliser str_replace()ce qui fait de cette méthode la plus lente de toutes.

Un tableau de résultats simplifié, la vitesse est mesurée par rapport à la méthode la plus lente:

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

Vous pouvez utiliser explodepour séparer l'espace de noms et endpour obtenir le nom de la classe:

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

Voie Yii

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

Yii utilise cette méthode dans son générateur de code Gii

Documentation de la méthode

Cette méthode est similaire à la fonction php basename () sauf qu'elle traitera à la fois \ et / comme des séparateurs de répertoires, indépendamment du système d'exploitation. Cette méthode a été principalement créée pour fonctionner sur les espaces de noms php. Lorsque vous travaillez avec des chemins de fichiers réels, basename () de php devrait fonctionner correctement pour vous. Remarque: cette méthode ne connaît pas le système de fichiers réel ou les composants du chemin tels que "..".

Plus d'information:

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

Voici une solution simple pour 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()));
        }
    }
}

Quel sera le retour?

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
}

Le nom de classe et l'espace de noms étendus fonctionnent bien pour:

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'en est-il de la classe dans l'espace de noms global?

namespace {

    class ClassWithoutNamespace {
        use \Names;
    }

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

Si vous avez besoin de connaître le nom de la classe qui a été appelée depuis l'intérieur d'une classe et que vous ne voulez pas l'espace de noms, vous pouvez utiliser celui-ci

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

C'est génial lorsque vous avez une méthode dans une classe qui est étendue par d'autres classes. De plus, cela fonctionne également si les espaces de noms ne sont pas du tout utilisés.

Exemple:

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

Sur la base de la réponse de @MaBi, j'ai fait ceci:

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

Que vous pouvez utiliser comme ça:

namespace Foo\Bar\Baz;

class A
{
    use ClassShortNameTrait;
}

A::classrevient Foo\Bar\Baz\A, mais A::getClassShortName()revient A.

Fonctionne pour PHP> = 5.5.

Je sais que c'est un vieil article mais c'est ce que j'utilise - Plus rapide que tout ce qui est posté ci-dessus, appelez simplement cette méthode depuis votre classe, beaucoup plus rapidement que d'utiliser Reflection

namespace Foo\Bar\Baz;

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

Trouvé sur la page de documentation de get_class , où il a été posté par moi à 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];
}

Mais l'idée des espaces de noms est de structurer votre code. Cela signifie également que vous pouvez avoir des classes avec le même nom dans plusieurs espaces de noms. Donc, théoriquement, l'objet que vous passez pourrait avoir le nom de classe (dépouillé), tout en étant un objet totalement différent de celui que vous attendez.

En plus de cela, vous voudrez peut-être rechercher une classe de base spécifique , auquel cas get_classne fait pas du tout l'affaire. Vous voudrez peut-être vérifier l'opérateur instanceof.

Vous pouvez obtenir un résultat inattendu lorsque la classe n'a pas d'espace de noms. Ie get_classretourne Foo, alors $baseClassserait oo.

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

Cela peut facilement être corrigé en préfixant get_classavec une barre oblique inverse:

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

Désormais, les classes sans espace de noms renverront également la bonne valeur.

Une bonne vieille regex semble être plus rapide que la plupart des méthodes précédentes montrées:

// both of the below calls will output: ShortClassName

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

Cela fonctionne donc même lorsque vous fournissez un nom de classe court ou un nom de classe complet (canonique).

Ce que fait l'expression régulière, c'est qu'il consomme tous les caractères précédents jusqu'à ce que le dernier séparateur soit trouvé (qui est également consommé). La chaîne restante sera donc le nom court de la classe.

Si vous souhaitez utiliser un séparateur différent (par exemple. /), Utilisez simplement ce séparateur à la place. N'oubliez pas d'échapper la barre oblique inverse (c'est-à-dire. \) Et également le caractère de motif (c'est-à-dire. /) Dans le modèle d'entrée.

Parce que "ReflectionClass" peut dépendre de la version, utilisez simplement ce qui suit:

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

ou même clair

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

Citant php.net:

Sous Windows, la barre oblique (/) et la barre oblique inverse () sont utilisées comme séparateur de répertoire. Dans d'autres environnements, il s'agit de la barre oblique (/).

Sur la base de ces informations et de l'expansion de la réponse arzzzen, cela devrait fonctionner sur les systèmes Windows et Nix *:

<?php

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

Remarque: j'ai fait un benchmark de ReflectionClasscontre basename+str_replace+get_classet l'utilisation de la réflexion est environ 20% plus rapide que l'utilisation de l'approche du nom de base, mais YMMV.

La solution la plus rapide et la plus simple qui fonctionne dans n'importe quel environnement est:

<?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 vous supprimez simplement les espaces de nom et que vous voulez quelque chose après le dernier \ dans un nom de classe avec un espace de noms (ou juste le nom s'il n'y a pas de '\'), vous pouvez faire quelque chose comme ceci:

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

Fondamentalement, c'est regex pour obtenir n'importe quelle combinaison de caractères ou de barres obliques inverses vers le haut et jusqu'à la dernière barre oblique inverse, puis de ne renvoyer que les caractères sans barre oblique inverse jusqu'à la fin de la chaîne. Ajout du? après le premier regroupement, cela signifie que si la correspondance de modèle n'existe pas, elle renvoie simplement la chaîne complète.

Plus rapide que j'ai trouvé ici pour PHP 7.2leUbubntu 18.04

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