PHP 8.3.4 Released!

The ReflectionMethod class

(PHP 5, PHP 7, PHP 8)

Introdução

The ReflectionMethod class reports information about a method.

Resumo da classe

class ReflectionMethod extends ReflectionFunctionAbstract {
/* Constantes */
public const int IS_STATIC;
public const int IS_PUBLIC;
public const int IS_PROTECTED;
public const int IS_PRIVATE;
public const int IS_ABSTRACT;
public const int IS_FINAL;
/* Propriedades */
public string $class;
/* Propriedades herdadas */
public string $name;
/* Métodos */
public __construct(object|string $objectOrMethod, string $method)
public __construct(string $classMethod)
public static createFromMethodName(string $method): static
public static export(string $class, string $name, bool $return = false): string
public getClosure(?object $object = null): Closure
public getModifiers(): int
public hasPrototype(): bool
public invoke(?object $object, mixed ...$args): mixed
public invokeArgs(?object $object, array $args): mixed
public isAbstract(): bool
public isDestructor(): bool
public isFinal(): bool
public isPrivate(): bool
public isProtected(): bool
public isPublic(): bool
public setAccessible(bool $accessible): void
public __toString(): string
/* Métodos herdados */
}

Propriedades

name

Method name

class

Class name

Constantes pré-definidas

ReflectionMethod Modifiers

ReflectionMethod::IS_STATIC

Indicates that the method is static. Prior to PHP 7.4.0, the value was 1.

ReflectionMethod::IS_PUBLIC

Indicates that the method is public. Prior to PHP 7.4.0, the value was 256.

ReflectionMethod::IS_PROTECTED

Indicates that the method is protected. Prior to PHP 7.4.0, the value was 512.

ReflectionMethod::IS_PRIVATE

Indicates that the method is private. Prior to PHP 7.4.0, the value was 1024.

ReflectionMethod::IS_ABSTRACT

Indicates that the method is abstract. Prior to PHP 7.4.0, the value was 2.

ReflectionMethod::IS_FINAL

Indicates that the method is final. Prior to PHP 7.4.0, the value was 4.

Nota:

The values of these constants may change between PHP versions. It is recommended to always use the constants and not rely on the values directly.

Registro de Alterações

Versão Descrição
8.0.0 ReflectionMethod::export() was removed.

Índice

add a note

User Contributed Notes 3 notes

up
9
Anonymous
3 years ago
We can make a "Automatic dependenci injector" in classes when her constructors depends other classes (with type hint).

<?php

class Dependence1 {
function
foo() {
echo
"foo";
}
}

class
Dependence2 {
function
foo2() {
echo
"foo2";
}
}

final class
myClass
{
private
$dep1;
private
$dep2;

public function
__construct(
Dependence1 $dependence1,
Dependence2 $dependence2
)
{
$this->dep1 = $dependence1;
$this->dep2 = $dependence2;
}

}

// Automatic dependence injection (CLASSES)

$constructor = new ReflectionMethod(myClass::class, '__construct');
$parameters = $constructor->getParameters();

$dependences = [];
foreach (
$parameters as $parameter) {
$dependenceClass = (string) $parameter->getType();
$dependences[] = new $dependenceClass();
}

$instance = new myClass(...$dependences);
var_dump($instance);

?>

Results in:

object(myClass)#6 (2) {
["dep1":"myClass":private]=>
object(Dependence1)#4 (0) {
}
["dep2":"myClass":private]=>
object(Dependence2)#5 (0) {
}
}
up
12
webseiten dot designer at googlemail dot com
12 years ago
Note that the public member $class contains the name of the class in which the method has been defined:

<?php
class A {public function __construct() {}}
class
B extends A {}

$method = new ReflectionMethod('B', '__construct');
echo
$method->class; // prints 'A'
?>
up
-18
no dot prob at gmx dot net
17 years ago
I have written a function which returns the value of a given DocComment tag.

Full example:

<?php

header
('Content-Type: text/plain');

class
Example
{
/**
* This is my DocComment!
*
* @DocTag: prints Hello World!
*/
public function myMethod()
{
echo
'Hello World!';
}
}

function
getDocComment($str, $tag = '')
{
if (empty(
$tag))
{
return
$str;
}

$matches = array();
preg_match("/".$tag.":(.*)(\\r\\n|\\r|\\n)/U", $str, $matches);

if (isset(
$matches[1]))
{
return
trim($matches[1]);
}

return
'';
}

$method = new ReflectionMethod('Example', 'myMethod');

// will return Hello World!
echo getDocComment($method->getDocComment(), '@DocTag');

?>

Maybe you can add this functionality to the getDocComment methods of the reflection classes.
To Top