ReflectionClass::__construct

(PHP 5, PHP 7, PHP 8)

ReflectionClass::__constructConstructs a ReflectionClass

Description

public ReflectionClass::__construct(object|string $objectOrClass)

Constructs a new ReflectionClass object.

Parameters

objectOrClass

Either a string containing the name of the class to reflect, or an object.

Errors/Exceptions

Throws ReflectionException if the class to reflect does not exist.

Examples

Example #1 Basic usage ReflectionClass

<?php
$reflection
= new ReflectionClass('Exception');
echo
$reflection;
?>

The above example will output something similar to:

Class [ <internal:Core> class Exception implements Stringable, Throwable ] {

  - Constants [0] {
  }

  - Static properties [0] {
  }

  - Static methods [0] {
  }

  - Properties [7] {
    Property [ protected $message = '' ]
    Property [ private string $string = '' ]
    Property [ protected $code = 0 ]
    Property [ protected string $file = '' ]
    Property [ protected int $line = 0 ]
    Property [ private array $trace = [] ]
    Property [ private ?Throwable $previous = NULL ]
  }

  - Methods [11] {
    Method [ <internal:Core> private method __clone ] {

      - Parameters [0] {
      }
      - Return [ void ]
    }

    Method [ <internal:Core, ctor> public method __construct ] {

      - Parameters [3] {
        Parameter #0 [ <optional> string $message = "" ]
        Parameter #1 [ <optional> int $code = 0 ]
        Parameter #2 [ <optional> ?Throwable $previous = null ]
      }
    }

    Method [ <internal:Core> public method __wakeup ] {

      - Parameters [0] {
      }
      - Tentative return [ void ]
    }

    Method [ <internal:Core, prototype Throwable> final public method getMessage ] {

      - Parameters [0] {
      }
      - Return [ string ]
    }

    Method [ <internal:Core, prototype Throwable> final public method getCode ] {

      - Parameters [0] {
      }
    }

    Method [ <internal:Core, prototype Throwable> final public method getFile ] {

      - Parameters [0] {
      }
      - Return [ string ]
    }

    Method [ <internal:Core, prototype Throwable> final public method getLine ] {

      - Parameters [0] {
      }
      - Return [ int ]
    }

    Method [ <internal:Core, prototype Throwable> final public method getTrace ] {

      - Parameters [0] {
      }
      - Return [ array ]
    }

    Method [ <internal:Core, prototype Throwable> final public method getPrevious ] {

      - Parameters [0] {
      }
      - Return [ ?Throwable ]
    }

    Method [ <internal:Core, prototype Throwable> final public method getTraceAsString ] {

      - Parameters [0] {
      }
      - Return [ string ]
    }

    Method [ <internal:Core, prototype Stringable> public method __toString ] {

      - Parameters [0] {
      }
      - Return [ string ]
    }
  }
}

See Also

add a note

User Contributed Notes 5 notes

up
13
danbettles at yahoo dot co dot uk
9 years ago
To reflect on a namespaced class in PHP 5.3, you must always specify the fully qualified name of the class - even if you've aliased the containing namespace using a "use" statement.

So instead of:

<?php
use App\Core as Core;
$oReflectionClass = new ReflectionClass('Core\Singleton');
?>

You would type:

<?php
use App\Core as Core;
$oReflectionClass = new ReflectionClass('App\Core\Singleton');
?>
up
3
me [at] klay [dot] me
10 years ago
Example of usage:

public static function getClassData($class)
{
// Trying to create a new object of ReflectionClass class
$class = new ReflectionClass($class);

$details = sprintf('%s - %s%s%s%s%s%s%s%s',
$class->getName(),
$class->isInternal() ? 'internal class,' : 'user-defined class,',
$class->isTrait() ? ' is trait,' : '',
$class->isInterface() ? ' is interface,' : '',
$class->isAbstract() ? ' is abstract,' : '',
$class->isFinal() ? ' is final,' : '',
$class->isCloneable() ? ' is cloneable,' : '',
$class->isInstantiable() ? ' is instantiable,' : '',
$class->isIterateable() ? ' is iterable : ''
);

return '<pre class="debug">' . rtrim($details, ',') . '</pre>';
}
up
3
gafisher at griasolutions dot com
12 years ago
Running the following code on Windows Vista (I know, I know), PHP 5.3.9, the ReflectionClass constructor actually throws a ReflectionException when the desired class cannot be instantiated:

<?php
try {
$ReflectedClass = new ReflectionClass('NonExist');
} catch (
LogicException $Exception) {
die(
'Not gonna make it in here...');
} catch (
ReflectionException $Exception) {
die(
'Your class does not exist!');
}
?>
up
0
ivo at jansch dot nl
14 years ago
It's very useful to know that you can also use the ReflectionClass to inspect interfaces, even thouth Interfaces are not classes. Example:

<?php

interface Edible
{
public function
eat();
}

$refl = new ReflectionClass("Edible");
$methods = $refl->getMethods();
?>

[Edit by danbrown AT php DOT net - Contains a bugfix by (dbl AT bnet DOT com) on 18-AUG-2010 with the following message: "underline had to be removed for it to work ( new Reflection_Class -> new ReflectionClass )"]
up
-2
cspray at gmail dot com
13 years ago
Useful to know that if you pass a string into the construct and the class cannot be instantiated for some reason a SPL LogicException will be thrown.

This code was ran on a Mac OS X 10.6.7, AMP, PHP 5.3+

<?php

// index.php
try {
$ReflectedClass = new ReflectionClass('NonExist');
} catch (
LogicException $logicDuh) {
print_r($logicDuh);
}

?>

Will return a deeply nested array full of useful information about the error.
To Top