International PHP Conference Munich 2024

ReflectionClass::getMethod

(PHP 5, PHP 7, PHP 8)

ReflectionClass::getMethodObtém um ReflectionMethod para um método de classe

Descrição

public ReflectionClass::getMethod(string $name): ReflectionMethod

Obtém um ReflectionMethod para um método de classe.

Parâmetros

name

O nome do método a ser refletido.

Valor Retornado

Um ReflectionMethod.

Erros/Exceções

Uma ReflectionException se o método não existir.

Exemplos

Exemplo #1 Uso básico de ReflectionClass::getMethod()

<?php
$class
= new ReflectionClass('ReflectionClass');
$method = $class->getMethod('getMethod');
var_dump($method);
?>

O exemplo acima produzirá:

object(ReflectionMethod)#2 (2) {
  ["name"]=>
  string(9) "getMethod"
  ["class"]=>
  string(15) "ReflectionClass"
}

Veja Também

add a note

User Contributed Notes 3 notes

up
7
Jarrod Nettles
13 years ago
If you ever need to get the type hint of a parameter in a method use this.

<?php

//Target our class
$reflector = new ReflectionClass('MyClass');

//Get the parameters of a method
$parameters = $reflector->getMethod('FireCannon')->getParameters();

//Loop through each parameter and get the type
foreach($parameters as $param)
{
//Before you call getClass() that class must be defined!
echo $param->getClass()->name;
}

?>
up
0
v0ffcha
2 days ago
Replace call_user_func_array with callMethodWithNamedArgs

In PHP, when you're using call_user_func_array to call a method with named parameters, you need to convert the associative array $params into a simple array that matches the order of the function arguments. However, PHP doesn't directly support calling functions or methods with named arguments via call_user_func_array. Instead, you can use reflection for more flexibility, allowing you to pass arguments by their parameter names.

Here's a function that does this for you:

function callMethodWithNamedArgs($className, $methodName, array $params) {
$class = new ReflectionClass($className);
$method = $class->getMethod($methodName);

// Create an array where keys are argument names and values are null initially.
$argsByPosition = array_fill_keys(array_keys($method->getParameters()), null);

// Fill the $argsByPosition array with provided values based on the keys.
foreach ($params as $key => $value) {
if ($method->hasParameter($key)) {
$argsByPosition[$method->getParameter($key)->getPosition()] = $value;
}
}

// Call the method using the ordered arguments.
return $method->invokeArgs(null, $argsByPosition);
}

// Usage example:
$params = [
'page' => 3,
'size' => '23 Mb',
'source' => 'some_site',
'status' => 'ok'
];

callMethodWithNamedArgs('SomeClass', 'someFunctionName', $params);

This function uses the Reflection API to inspect the method signature, ensuring that even if some parameters are null or missing from $params, they won't cause issues during the method call, as long as they are optional in the method definition. It positions the parameters correctly according to the method's definition order.

Make sure to replace 'SomeClass' and 'someFunctionName' with your actual class name and method name. This approach is particularly handy when dealing with methods that have many parameters, some of which might be optional and passed in any order.
up
-2
sagittaracc at gmail dot com
2 years ago
if you ever need to get the body of a method, use this extension (https://github.com/sagittaracc/reflection):

namespace sagittaracc\classes;

class Test
{
public function method()
{
if (true) {
return 'this method';
}

return 'never goes here';
}
}

$reflection = new ReflectionClass(Test::class);
$method = $reflection->getMethod('method');
echo $method->body; // if (true) { return 'this method'; } return 'never goes here';
To Top