The ReflectionParameter class

(PHP 5, PHP 7, PHP 8)

Einführung

The ReflectionParameter class retrieves information about function's or method's parameters.

To introspect function parameters, first create an instance of the ReflectionFunction or ReflectionMethod classes and then use their ReflectionFunctionAbstract::getParameters() method to retrieve an array of parameters.

Klassenbeschreibung

class ReflectionParameter implements Reflector {

/* Eigenschaften */

public string $name;

/* Methoden */

public __construct(string|array|object $function, int|string $param)

public allowsNull(): bool

public canBePassedByValue(): bool

private __clone(): void

public static export(string $function, string $parameter, bool $return = ?): string

public getAttributes(?string $name = null, int $flags = 0): array

#[\Deprecated]
public getClass(): ?ReflectionClass

public getDeclaringClass(): ?ReflectionClass

public getDeclaringFunction(): ReflectionFunctionAbstract

public getDefaultValue(): mixed

public getDefaultValueConstantName(): ?string

public getName(): string

public getPosition(): int

public getType(): ?ReflectionType

public hasType(): bool

#[\Deprecated]
public isArray(): bool

#[\Deprecated]
public isCallable(): bool

public isDefaultValueAvailable(): bool

public isDefaultValueConstant(): bool

public isOptional(): bool

public isPassedByReference(): bool

public isPromoted(): bool

public isVariadic(): bool

public __toString(): string

}

Eigenschaften

name: Name of the parameter. Read-only, throws ReflectionException in attempt to write.

Changelog

Version	Beschreibung
8.0.0	ReflectionParameter::export() was removed.

Inhaltsverzeichnis

ReflectionParameter::allowsNull — Checks if null is allowed
ReflectionParameter::canBePassedByValue — Returns whether this parameter can be passed by value
ReflectionParameter::__clone — Clone
ReflectionParameter::__construct — Construct
ReflectionParameter::export — Exports
ReflectionParameter::getAttributes — Gets Attributes
ReflectionParameter::getClass — Get a ReflectionClass object for the parameter being reflected or null
ReflectionParameter::getDeclaringClass — Gets declaring class
ReflectionParameter::getDeclaringFunction — Gets declaring function
ReflectionParameter::getDefaultValue — Gets default parameter value
ReflectionParameter::getDefaultValueConstantName — Returns the default value's constant name if default value is constant or null
ReflectionParameter::getName — Gets parameter name
ReflectionParameter::getPosition — Gets parameter position
ReflectionParameter::getType — Gets a parameter's type
ReflectionParameter::hasType — Checks if parameter has a type
ReflectionParameter::isArray — Checks if parameter expects an array
ReflectionParameter::isCallable — Returns whether parameter MUST be callable
ReflectionParameter::isDefaultValueAvailable — Checks if a default value is available
ReflectionParameter::isDefaultValueConstant — Returns whether the default value of this parameter is a constant
ReflectionParameter::isOptional — Checks if optional
ReflectionParameter::isPassedByReference — Checks if passed by reference
ReflectionParameter::isPromoted — Checks if a parameter is promoted to a property
ReflectionParameter::isVariadic — Checks if the parameter is variadic
ReflectionParameter::__toString — To string

Found A Problem?

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

＋add a note

User Contributed Notes 4 notes

down

fgm at riff dot org ¶

16 years ago

The note about the signature of the ReflectionParameter constructor is actually incomplete, at least in 5.2.5: it is possible to use an integer for the second parameter, and the constructor will use it to return the n-th parameter.



This allows you to obtain proper ReflectionParameter objects even when documenting code from extensions which (strangely enough) define several parameters with the same name. The string-based constructor always returns the first parameter with the matching name, whereas the integer-based constructor correctly returns the n-th parameter.



So, in short, this works:

<?php

// supposing the extension defined something like:

// Some_Class::someMethod($a, $x, $y, $x, $y)

$p = new ReflectionParameter(array('Some_Class', 'someMethod'), 4);

// returns the last parameter, whereas

$p = new ReflectionParameter(array('Some_Class', 'someMethod'), 'y');

// always returns the first $y at position 2

?>

down

killgecNOFSPAM at gmail dot com ¶

17 years ago

Signature of constructor of ReflectionParameter correctly is:



public function __construct(array/string $function, string $name);



where $function is either a name of a global function, or a class/method name pair.

down

massimo at mmware dot it ¶

17 years ago

I found these limitations using class ReflectionParameter from ReflectionFunction with INTERNAL FUNCTIONS (eg print_r, str_replace, ... ) :



1. parameter names don't match with manual: (try example 19.35 with arg "call_user_func" )

2. some functions (eg PCRE function, preg_match etc) have EMPTY parameter names 

3. calling getDefaultValue on Parameters will result in Exception "Cannot determine default value for internal functions"

down

rasmus at mindplay dot dk ¶

1 year ago

There are so many parameter modes now, and I needed to know exactly what `ReflectionParameter` is going to return, so I wrote a little test-script - you can find the script and results in a table here:

https://gist.github.com/mindplay-dk/082458088988e32256a827f9b7491e17

＋add a note