オブジェクトの修飾されていない（短い）クラス名を取得するにはどうすればよいですか？

名前空間の完全なクラスを指定せずに、PHP名前空間環境内のオブジェクトのクラスを確認するにはどうすればよいですか。

たとえば、オブジェクトライブラリ/エンティティ/契約/名前があるとします。

get_classが完全な名前空間クラスを返すため、次のコードは機能しません。

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

名前空間のmagicキーワードは、現在の名前空間を返します。これは、テストされたオブジェクトに別の名前空間がある場合は使用されません。

名前空間で完全なクラス名を指定することもできますが、これはコードの構造に固定されているようです。名前空間を動的に変更したい場合もあまり役に立ちません。

誰でもこれを行うための効率的な方法を考えることができますか？1つのオプションは正規表現だと思います。

リフレクションでこれを行うことができます。具体的に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";

結果は実際に私を驚かせた。私は爆発ソリューションが最も速い方法だと思っていました...

https://stackoverflow.com/a/25472778/2386943のテストにsubstrを追加しました 。これは、i5で両方をテストできる最も速い方法（CentOS PHP 5.3.3、Ubuntu PHP 5.5.9）です。

$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関数basename（）に似ています。このメソッドは、主にphp名前空間で動作するように作成されました。実際のファイルパスを操作する場合、phpのbasename（）が正常に機能するはずです。注：このメソッドは、実際のファイルシステムや「..」などのパスコンポーネントを認識しません。

詳しくは：

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

したがって、これは、短いクラス名または完全修飾（正規）クラス名を指定した場合でも機能します。

正規表現は、最後のセパレーターが見つかるまで（これも消費されます）、それまでのすべての文字を消費するということです。したがって、残りの文字列は短いクラス名になります。

別のセパレーター（例：/）を使用したい場合は、代わりにそのセパレーターを使用してください。入力パターンでは、バックスラッシュ（つまり\）とパターン文字（つまり/）をエスケープすることを忘れないでください。

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