Comment puis-je obtenir un objet non qualifiés (court) nom de la classe?

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

Tout d'abord, vous avez besoin pour construire un ReflectionClass instance, puis en appel le getShortName méthode de cette instance:

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

Cependant, je ne peux pas imaginer de nombreuses situations, ce qui serait souhaitable. Si vous voulez exiger que l'objet est un membre d'une certaine classe, pour le tester c'est avec instanceof. Si vous voulez un moyen plus souple de signal de certaines contraintes, la façon de le faire est d'écrire une interface et d'exiger que le code à implémenter cette interface. De nouveau, la bonne façon de le faire est avec instanceof. (Vous pouvez le faire avec ReflectionClass, mais il aurait pu avoir bien pire performance.)

J'ai ajouté substr à l'épreuve de https://stackoverflow.com/a/25472778/2386943
et c'est la fastet 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 y a même un moyen plus rapide pour ce faire:

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

Voici la mise à jour des résultats de test avec "SubstringStrChr" (permet d'économiser 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

J'utilise ceci:

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

Je me suis retrouvé dans une situation unique où instanceof ne pouvait pas être utilisé spécifiquement à des espaces de traits) et je nécessaire le nom court de la manière la plus efficace possible, j'ai donc fait un petit benchmark de mon propre. Il comprend toutes les différentes méthodes & des variations dans les 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 la de la tout le résultat est ici, mais voici les faits saillants:

• Si vous allez utiliser la réflexion de toute façon, à l'aide de $obj->getShortName() est la méthode la plus rapide cependant; l'aide de la réflexion seulement pour obtenir le nom court c'est presque la méthode la plus lente.
• 'strrpos' peut retourner une valeur erronée si l'objet n'est pas dans un espace de noms ainsi, alors que 'safe strrpos' est un tout petit peu plus lent, je dirais que c'est le vainqueur.
• De faire 'basename' compatibles entre Linux et Windows, vous devez utiliser str_replace() ce qui rend cette méthode le plus lent de tous.

Un tableau simplifié des résultats, 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 explode pour la séparation de l'espace de noms et end pour obtenir le nom de la classe:

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

Si vous avez besoin de savoir le nom de la classe qui a été appelé à partir de l'intérieur de la classe et ne veulent pas l'espace de noms, vous pouvez utiliser ce un

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

C'est super quand vous avez une méthode à l'intérieur d'une classe, qui est prolongé par d'autres classes. En outre, cela fonctionne aussi si les espaces de noms ne sont pas utilisés du tout.

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)

Trouvé sur le page de documentation du 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 d'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, en théorie, l'objet que vous passez peut avoir le nom (stripped) nom de la classe, tout en étant un tout autre objet que vous attendez.

En outre, vous voudrez peut-être consulter pour un de la classe de base, auquel cas get_class ne pas faire l'affaire à tous les. Vous pourriez vouloir vérifier l'opérateur instanceof.

Citant php.net:

Sur les Fenêtres, la barre oblique (/) et la barre oblique inverse () sont utilisés comme séparateur de répertoire de caractère. Dans d'autres environnements, c'est la barre oblique (/).

Basé sur cette info et l'expansion à partir de arzzzen réponse cela devrait fonctionner sur Windows et Nix* systèmes:

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

Remarque: j'ai fait un test de ReflectionClass contre basename+str_replace+get_class et en utilisant la réflexion est environ 20% plus rapide que d'utiliser le nom de base de l'approche, mais YMMV.

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

Un bon vieux regex semble être plus rapide que la plupart des anciens montré méthodes:

//both of the below calls will output: ShortClassName
echo preg_replace('/.*\\\\/', '', 'ShortClassName');
echo preg_replace('/.*\\\\/', '', 'SomeNamespace\SomePath\ShortClassName');

Si cela fonctionne même lorsque vous fournissez un court nom de la classe ou complet (canonique) nom de la classe.

Ce que la regex n'est qu'elle consomme tous les précédents caractères jusqu'à la dernière séparateur (ce qui est également consommée). Si la chaîne restante sera court nom de la classe.

Si vous souhaitez utiliser un autre séparateur (eg. /) ensuite, il suffit d'utiliser un séparateur à la place. N'oubliez pas d'échapper à la barre oblique inverse (ie. \) et également le modèle de char (ie. /) dans le modèle d'entrée.