Як отримати некваліфіковане (коротке) ім'я класу об'єкта?

Як перевірити клас об'єкта в середовищі, розміщеному в імені PHP, не вказуючи повний клас простору імен.

Наприклад, припустимо, у мене була бібліотека об'єктів / Суб'єкт / Контракт / Ім'я.

Наступний код не працює, оскільки get_class повертає повний клас простору імен.

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

Магічне ключове слово простору імен повертає поточний простір імен, який не є корисним, якщо тестований об'єкт має інший простір імен.

Я міг би просто вказати повне ім’я класу з просторами імен, але це, здається, замикається в структурі коду. Також не приносить великої користі, якщо я хотів динамічно змінити простір імен.

Хто-небудь може придумати ефективний спосіб зробити це. Я здогадуюсь, один із варіантів - регулярний вираз.

Це можна зробити за допомогою роздумів. Зокрема, ви можете використовувати ReflectionClass::getShortNameметод, який отримує назву класу без його простору імен.

Спочатку потрібно створити ReflectionClassекземпляр, а потім викликати getShortNameметод цього примірника:

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

Однак я не уявляю багатьох обставин, коли це було б бажано. Якщо ви хочете вимагати, щоб об’єкт є членом певного класу, спосіб його перевірити instanceof. Якщо ви хочете більш гнучким способом передавати певні обмеження, спосіб зробити це - написати інтерфейс і вимагати, щоб код реалізував цей інтерфейс. Знову ж, правильний спосіб це зробити instanceof. (Ви можете це зробити ReflectionClass, але це матиме набагато гірші показники.)

(new \ReflectionClass($obj))->getShortName(); є найкращим рішенням щодо продуктивності.

Мені було цікаво, яке із запропонованих рішень є найшвидшим, тому я склав невеликий тест.

Результати

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

Код

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

Результати насправді мене здивували. Я думав, що вибухне рішення буде найшвидшим шляхом ...

Я додав substr до тесту https://stackoverflow.com/a/25472778/2386943, і це найшвидший спосіб, який я міг би протестувати (CentOS PHP 5.3.3, Ubuntu PHP 5.5.9) і з i5.

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

Результати

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

Код

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

== ОНОВЛЕННЯ ==

Як згадується в коментарях @MrBandersnatch, є навіть більш швидкий спосіб зробити це:

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

Ось оновлені результати тестування з "SubstringStrChr" (економить до 0,001 с):

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

Ось більш простий спосіб зробити це, якщо ви використовуєте Laravel PHP:

<?php

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

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

Я використовую це:

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

Щоб отримати коротке ім'я як однолінійний (з PHP 5.4 ):

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

Це чистий підхід і розумний швидкий .

Я опинився в унікальній ситуації, коли instanceofне можна було використати (конкретно виділені риси імен), і мені було потрібне коротке ім'я найбільш ефективним способом, тому я зробив невеликий власний орієнтир. Він включає всі різні методи та варіації з відповідей у ​​цьому запитанні.

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

Список всього результату є тут, але ось основні моменти:

• Якщо ви все-таки будете використовувати роздуми, однак використання $obj->getShortName()найшвидшого методу ; використовуючи роздуми лише для отримання короткого імені, це майже найповільніший метод.
• 'strrpos'може повернути неправильне значення, якщо об’єкт не знаходиться в просторі імен, тому в той час як 'safe strrpos'він є трохи повільнішим, я б сказав, що це переможець.
• Для 'basename'сумісності між Linux та Windows вам потрібно використовувати, str_replace()що робить цей метод найповільнішим з усіх.

Спрощена таблиця результатів, вимірюється швидкість порівняно з найповільнішим методом:

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

Ви можете використовувати explodeдля розділення простору імен та endотримання імені класу:

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

Yii шлях

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

Yii використовує цей метод у своєму генераторі коду Gii

Методична документація

Цей метод схожий з базовою назвою функції php () за винятком того, що він буде розглядати і \, і / як роздільники каталогів, незалежно від операційної системи. Цей метод був головним чином створений для роботи над просторами імен php. Працюючи з реальними шляхами файлів, базування php () повинно працювати для вас добре. Примітка: цьому методу не відома фактична файлова система або компоненти контуру, такі як "..".

Більше інформації:

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

Ось просте рішення для 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()));
        }
    }
}

Що буде повернення?

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
}

Розширене ім’я класу та простір імен добре працює для:

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
}

Що з класом у глобальному просторі імен?

namespace {

    class ClassWithoutNamespace {
        use \Names;
    }

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

Якщо вам потрібно знати ім'я класу, яке було викликано всередині класу, і ви не хочете простору імен, ви можете використовувати це

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

Це чудово, коли у вас є метод всередині класу, який поширюється на інші класи. Крім того, це також працює, якщо простори імен взагалі не використовуються.

Приклад:

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

На основі відповіді @MaBi я зробив це:

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

Що ви можете використовувати так:

namespace Foo\Bar\Baz;

class A
{
    use ClassShortNameTrait;
}

A::classповертається Foo\Bar\Baz\A, але A::getClassShortName()повертається A.

Працює для PHP> = 5,5.

Я знаю, що це стара публікація, але це те, що я використовую - Швидше, ніж усі, що розміщені вище, просто зателефонуйте цей метод з вашого класу, набагато швидше, ніж використання Reflection

namespace Foo\Bar\Baz;

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

Знайдено на сторінці документації get_class , де вона була розміщена мною на 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];
}

Але ідея просторів імен полягає в структурі коду. Це також означає, що ви можете мати класи з тим самим іменем у кількох просторах імен. Тож теоретично об'єкт, який ви передаєте, міг би мати ім'я (позбавлене) назви класу, при цьому все-таки бути абсолютно іншим об'єктом, ніж ви очікували.

Крім того, ви можете перевірити конкретний базовий клас , і в цьому випадку get_classце зовсім не виходить. Ви можете перевірити оператора instanceof.

Ви можете отримати несподіваний результат, коли у класу немає простору імен. Тобто get_classповертається Foo, то $baseClassбуло б oo.

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

Це легко виправити за допомогою префіксації get_classза допомогою нахилу:

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

Тепер також класи без простору імен повернуть потрібне значення.

Старий хороший регулярний вираз здається швидшим, ніж більшість попередніх показаних методів:

// both of the below calls will output: ShortClassName

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

Таким чином, це спрацьовує навіть тоді, коли ви надаєте коротке ім'я класу або повністю кваліфіковане (канонічне) ім'я класу.

Те, що робить регулярний вираз, - це те, що він споживає всі попередні символи, поки не знайдеться останній роздільник (який також споживається). Таким чином, що залишився рядок буде коротким класом.

Якщо ви хочете використовувати інший роздільник (наприклад, /), просто використовуйте його. Не забудьте уникнути зворотної косої риси (тобто. \), А також діаграму char (тобто. /) У вхідному шаблоні.

Оскільки "ReflectionClass" може бути версією залежно, просто використовуйте наступне:

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

або навіть зрозуміло

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

Цитуючи php.net:

У Windows як нахил (/), так і зворотний косий () використовується як символ роздільника каталогів. В інших середовищах це пряма коса риса (/).

На основі цієї інформації та розширення з відповіді arzzzen це має працювати як у системах Windows, так і в Nix *:

<?php

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

Примітка. Я зробив орієнтир ReflectionClassпроти basename+str_replace+get_classі використання відображення приблизно на 20% швидше, ніж використання підходу базової назви, але YMMV.

Найшвидше і найпростіше рішення, яке працює в будь-якому середовищі:

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

Якщо ви просто знімаєте пробіли імен і хочете що-небудь після останнього \ у назві класу з простором імен (або просто ім'ям, якщо немає "\"), ви можете зробити щось подібне:

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

По суті, за допомогою регулярного виразів можна отримати будь-яку комбінацію символів або зворотних косих косих ринків, і до останнього косого кута потім повернути лише символи, які не є косою рисою вгору і до кінця рядка. Додавання? після першого групування означає, що якщо відповідність шаблону не існує, вона просто повертає повний рядок.

Найшвидший , що я знайшов тут PHP 7.2наUbubntu 18.04

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