Get class name from file

You can make PHP do the work by just including the file and get the last declared class:

$file = 'class.php'; # contains class Foo

include($file);
$classes = get_declared_classes();
$class = end($classes);
echo $class; # Foo

If you need to isolate that, wrap it into a commandline script and execute it via shell_exec:

$file = 'class.php'; # contains class Foo

$class = shell_exec("php -r \"include('$file'); echo end(get_declared_classes());\"");    
echo $class; # Foo

If you dislike commandline scripts, you can do it like in this question, however that code does not reflect namespaces.

Thanks to some people from Stackoverflow and Github, I was able to write this amazing fully working solution:

/**
 * get the full name (name \ namespace) of a class from its file path
 * result example: (string) "I\Am\The\Namespace\Of\This\Class"
 *
 * @param $filePathName
 *
 * @return  string
 */
public function getClassFullNameFromFile($filePathName)
{
    return $this->getClassNamespaceFromFile($filePathName) . '\\' . $this->getClassNameFromFile($filePathName);
}


/**
 * build and return an object of a class from its file path
 *
 * @param $filePathName
 *
 * @return  mixed
 */
public function getClassObjectFromFile($filePathName)
{
    $classString = $this->getClassFullNameFromFile($filePathName);

    $object = new $classString;

    return $object;
}





/**
 * get the class namespace form file path using token
 *
 * @param $filePathName
 *
 * @return  null|string
 */
protected function getClassNamespaceFromFile($filePathName)
{
    $src = file_get_contents($filePathName);

    $tokens = token_get_all($src);
    $count = count($tokens);
    $i = 0;
    $namespace = '';
    $namespace_ok = false;
    while ($i < $count) {
        $token = $tokens[$i];
        if (is_array($token) && $token[0] === T_NAMESPACE) {
            // Found namespace declaration
            while (++$i < $count) {
                if ($tokens[$i] === ';') {
                    $namespace_ok = true;
                    $namespace = trim($namespace);
                    break;
                }
                $namespace .= is_array($tokens[$i]) ? $tokens[$i][1] : $tokens[$i];
            }
            break;
        }
        $i++;
    }
    if (!$namespace_ok) {
        return null;
    } else {
        return $namespace;
    }
}

/**
 * get the class name form file path using token
 *
 * @param $filePathName
 *
 * @return  mixed
 */
protected function getClassNameFromFile($filePathName)
{
    $php_code = file_get_contents($filePathName);

    $classes = array();
    $tokens = token_get_all($php_code);
    $count = count($tokens);
    for ($i = 2; $i < $count; $i++) {
        if ($tokens[$i - 2][0] == T_CLASS
            && $tokens[$i - 1][0] == T_WHITESPACE
            && $tokens[$i][0] == T_STRING
        ) {

            $class_name = $tokens[$i][1];
            $classes[] = $class_name;
        }
    }

    return $classes[0];
}

I modified Nette\Reflection\AnnotationsParser that so it returns an array of namespace+classname that are defined in the file

$parser = new PhpParser();
$parser->extractPhpClasses('src/Path/To/File.php');


class PhpParser
{
    public function extractPhpClasses(string $path)
    {
        $code = file_get_contents($path);
        $tokens = @token_get_all($code);
        $namespace = $class = $classLevel = $level = NULL;
        $classes = [];
        while (list(, $token) = each($tokens)) {
            switch (is_array($token) ? $token[0] : $token) {
                case T_NAMESPACE:
                    $namespace = ltrim($this->fetch($tokens, [T_STRING, T_NS_SEPARATOR]) . '\\', '\\');
                    break;
                case T_CLASS:
                case T_INTERFACE:
                    if ($name = $this->fetch($tokens, T_STRING)) {
                        $classes[] = $namespace . $name;
                    }
                    break;
            }
        }
        return $classes;
    }

    private function fetch(&$tokens, $take)
    {
        $res = NULL;
        while ($token = current($tokens)) {
            list($token, $s) = is_array($token) ? $token : [$token, $token];
            if (in_array($token, (array) $take, TRUE)) {
                $res .= $s;
            } elseif (!in_array($token, [T_DOC_COMMENT, T_WHITESPACE, T_COMMENT], TRUE)) {
                break;
            }
            next($tokens);
        }
        return $res;
    }
}

$st = get_declared_classes();
include "classes.php"; //one or more classes in file, contains class class1, class2, etc...

$res = array_values(array_diff_key(get_declared_classes(),$st));
print_r($res); # Array ([0] => class1 [1] => class2 [2] ...)

You can do this in two ways:

• complex solution: open the file and through regex extract the class-name (like /class ([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)/)
• simply solution: name all your php files with the class-name contained (eg: the class TestFoo in the file TestFoo.php or TestFoo.class.php)

You could get all declared classes before you include the file using get_declared_classes. Do the same thing after you have included it and compare the two with something like array_diff and you have your newly added class.

This sample returns all classes. If you're looking for a class which is derived of a specific one, use is_subclass_of

$php_code = file_get_contents ( $file );
    $classes = array ();
    $namespace="";
    $tokens = token_get_all ( $php_code );
    $count = count ( $tokens );

    for($i = 0; $i < $count; $i ++)
    {
        if ($tokens[$i][0]===T_NAMESPACE)
        {
            for ($j=$i+1;$j<$count;++$j)
            {
                if ($tokens[$j][0]===T_STRING)
                    $namespace.="\\".$tokens[$j][1];
                elseif ($tokens[$j]==='{' or $tokens[$j]===';')
                    break;
            }
        }
        if ($tokens[$i][0]===T_CLASS)
        {
            for ($j=$i+1;$j<$count;++$j)
                if ($tokens[$j]==='{')
                {
                    $classes[]=$namespace."\\".$tokens[$i+2][1];
                }
        }
    }
    return $classes;

I spent lots of productive time looking for a way around this. From @netcoder's solution its obvious there are lots of cons in all the solutions so far.

So I decided to do this instead. Since most PHP classes has class name same as filename, we could get the class name from the filename. Depending on your project you could also have a naming convention. NB: This assume class does not have namespace

<?php
    $path = '/path/to/a/class/file.php';

    include $path;

    /*get filename without extension which is the classname*/
    $classname = pathinfo(basename($path), PATHINFO_FILENAME);

    /* you can do all this*/
    $classObj = new $classname();

    /*dough the file name is classname you can still*/
    get_class($classObj); //still return classname

Let me add a PHP 8 compatible solution as well. This will scan a file accordingly and return all FQCN's:

$file      = 'whatever.php';
$classes   = [];
$namespace = '';
$tokens    = PhpToken::tokenize(file_get_contents($file));

for ($i = 0; $i < count($tokens); $i++) {
    if ($tokens[$i]->getTokenName() === 'T_NAMESPACE') {
        for ($j = $i + 1; $j < count($tokens); $j++) {
            if ($tokens[$j]->getTokenName() === 'T_NAME_QUALIFIED') {
                $namespace = $tokens[$j]->text;
                break;
            }
        }
    }

    if ($tokens[$i]->getTokenName() === 'T_CLASS') {
        for ($j = $i + 1; $j < count($tokens); $j++) {
            if ($tokens[$j]->getTokenName() === 'T_WHITESPACE') {
                continue;
            }

            if ($tokens[$j]->getTokenName() === 'T_STRING') {
                $classes[] = $namespace . '\\' . $tokens[$j]->text;
            } else {
                break;
            }
        }
    }
}

// Contains all FQCNs found in a file.
$classes;

You may be able to use the autoload function.

function __autoload($class_name) {
    include "special_directory/" .$class_name . '.php';
}

And you can echo $class_name. But that requires a directory with a single file.

But it is standard practice to have one class in each file in PHP. So Main.class.php will contain Main class. You may able to use that standard if you are the one coding.

This one does the trick for me:

/**
 * @param string $filepath
 * @return string|null
 */
public function getClassFromFile(string $filepath): ?string
{
    static $classes = [];

    if (empty($filepath = $filepath ? realpath($filepath) : null)) {
        return null;
    } elseif (array_key_exists($filepath, $classes)) {
        return $classes[$filepath];
    } 

    $basename = substr(basename($filepath), 0, -4);
    require_once($filepath);
    foreach (array_reverse(get_declared_classes()) as $classname) {
        if (! strcasecmp($basename, basename('/'.str_replace('\\', '/', $classname)))) {
            $reflector = new \ReflectionClass($classname);
            if ($reflector->getFileName() == $filepath) {
                return ($classes[$filepath] = $classname);
            }
        }
    }

    return ($classes[$filepath] = null);
}

You can regiester all classess automatically (in case of not using tools like composer) and have all corresponding files/classes mapping:

spl_autoload_register(function ($class) {
    $file = str_replace('\\', DIRECTORY_SEPARATOR, $class) . '.php';
    echo "file is $file and class is $class\n";
    if (file_exists($file)) {
        require_once $file;
        return true;
    }
    return false;
});