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

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

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

namespace foobarbaz;

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

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

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

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

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

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

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

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 xyz {
    class SomeClass {
        use Names;
    }

    echo xyzSomeClass::getNamespace() . PHP_EOL; // xyz
    echo xyzSomeClass::getBaseClassName() . PHP_EOL; // SomeClass
}

namespace def {

    class DifferentClass extends xyzSomeClass {

    }

    echo defDifferentClass::getNamespace() . PHP_EOL; // def
    echo defDifferentClass::getBaseClassName() . PHP_EOL; // DifferentClass
}

namespace {

    class ClassWithoutNamespace {
        use Names;
    }

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

<?php

// usage anywhere
// returns HelloWorld
$name = class_basename('PathToYourClassHelloWorld');

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

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

<?php
namespace OneTwo {
    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 OneTwofoo
    {
        public function bar()
        {
            $this->foo();
        }
    }
}

namespace {
    (new OneTwofoo)->foo();
    (new Threebar)->bar();
}

// test.php:11:string 'foo' (length=3)
// test.php:11:string 'bar' (length=3)

yiihelpersStringHelper::basename(get_class($model));

This method is similar to the php function basename() except that it will
treat both  and / as directory separators, independent of the operating system.
This method was mainly created to work on php namespaces. When working with real
file paths, php's basename() should work fine for you. Note: this method is not
aware of the actual filesystem, or path components such as "..".

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

namespace FooBarBaz;

class A
{
    use ClassShortNameTrait;
}

$bench = new xoriBenchmark(1000, 1000);     # https://github.com/Xorifelse/php-benchmark-closure
$shell = new myfancynamespaceclassname(); # Just an empty class named `classname` defined in the `myfancynamespace` 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());

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

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

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

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

<?php

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

<?php

namespace MyAwesomeNamespace;

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

// both of the below calls will output: ShortClassName

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