« QuickHashIntStringHash::update
Introducción »
PHP Manual
Extensiones relacionadas con variable y tipo
Reflection
Reflection
Introducción
Ejemplos
Extensión
Reflection
— Clase Reflection
Reflection::export
— Exportar
Reflection::getModifierNames
— Obtener nombres de modificadores
ReflectionClass
— Clase ReflectionClass
ReflectionClass::__construct
— Construye un objeto de tipo ReflectionClass
ReflectionClass::export
— Exporta una clase
ReflectionClass::getAttributes
— Gets Attributes
ReflectionClass::getConstant
— Obtener una constante definida
ReflectionClass::getConstants
— Obtener constantes
ReflectionClass::getConstructor
— Obtiene el constructor de una clase
ReflectionClass::getDefaultProperties
— Obtener propiedades predeterminadas
ReflectionClass::getDocComment
— Obtener los comentarios de documentación
ReflectionClass::getEndLine
— Consultar línea final
ReflectionClass::getExtension
— Obtiene un objeto ReflectionExtension para la extensión que definió la clase
ReflectionClass::getExtensionName
— Obtiene el nombre de la extensión que definió una clase
ReflectionClass::getFileName
— Obtiene el nombre de fichero en el que está definida la clase
ReflectionClass::getInterfaceNames
— Obtiene nombres de las interfaces
ReflectionClass::getInterfaces
— Obtiene las interfaces
ReflectionClass::getLazyInitializer
— Gets lazy initializer
ReflectionClass::getMethod
— Obtiene un objeto ReflectionMethod para un método de una clase
ReflectionClass::getMethods
— Obtiene un array de métodos
ReflectionClass::getModifiers
— Obtiene los modificadores de clase
ReflectionClass::getName
— Obtiene el nombre de la clase
ReflectionClass::getNamespaceName
— Obtiene el nombre del espacio de nombres
ReflectionClass::getParentClass
— Obtiene la clase padre
ReflectionClass::getProperties
— Obtiene las propiedades
ReflectionClass::getProperty
— Obtiene un objeto ReflectionProperty para una propiedad de una clase
ReflectionClass::getReflectionConstant
— Gets a ReflectionClassConstant for a class's constant
ReflectionClass::getReflectionConstants
— Gets class constants
ReflectionClass::getShortName
— Obtiene el nombre abreviado
ReflectionClass::getStartLine
— Obtiene el número de linea de inicio
ReflectionClass::getStaticProperties
— Obtiene las propiedades estáticas
ReflectionClass::getStaticPropertyValue
— Obtiene el valor de una propiedad estática
ReflectionClass::getTraitAliases
— Obtiene un array con los alias usados con los traits
ReflectionClass::getTraitNames
— Devuelve un array con los nombres de los traits usados por esta clase
ReflectionClass::getTraits
— Obtiene un array con los traits que utiliza esta clase
ReflectionClass::hasConstant
— Comprueba si una constante está o no definida
ReflectionClass::hasMethod
— Comprueba si un método está o no definido
ReflectionClass::hasProperty
— Comprueba si una propiedad está o no definida
ReflectionClass::implementsInterface
— Comprueba si se implementa una determinada interfaz
ReflectionClass::initializeLazyObject
— Forces initialization of a lazy object
ReflectionClass::inNamespace
— Comprueba si pertenece a un determinado espacio de nombres
ReflectionClass::isAbstract
— Comprueba si la clase es abstracta
ReflectionClass::isAnonymous
— Checks if class is anonymous
ReflectionClass::isCloneable
— Comprueba si la clase es o no clonable
ReflectionClass::isEnum
— Returns whether this is an enum
ReflectionClass::isFinal
— Comprueba si la clase inal
ReflectionClass::isInstance
— Comprueba si un objeto es instancia de la clase
ReflectionClass::isInstantiable
— Comprueba si una clase es instanciable
ReflectionClass::isInterface
— Comprueba una la clase es una interfaz
ReflectionClass::isInternal
— Comprueba si una clase está definida internamente por una extensión o por el núcleo
ReflectionClass::isIterable
— Check whether this class is iterable
ReflectionClass::isIterateable
— Comprueba si es iterable
ReflectionClass::isReadOnly
— Checks if class is readonly
ReflectionClass::isSubclassOf
— Comprueba si es una subclase
ReflectionClass::isTrait
— Comprueba si es un trait
ReflectionClass::isUninitializedLazyObject
— Checks if an object is lazy and uninitialized
ReflectionClass::isUserDefined
— Comprueba si es una clase definida por el usuario
ReflectionClass::markLazyObjectAsInitialized
— Marks a lazy object as initialized without calling the initializer or factory
ReflectionClass::newInstance
— Crea una nueva instancia de clase a partir de la lista de parámetros dados
ReflectionClass::newInstanceArgs
— Crea una nueva instancia de clase a partir de los argumentos dados
ReflectionClass::newInstanceWithoutConstructor
— Crea una nueva clase sin invocar al constructor
ReflectionClass::newLazyGhost
— Creates a new lazy ghost instance
ReflectionClass::newLazyProxy
— Creates a new lazy proxy instance
ReflectionClass::resetAsLazyGhost
— Resets an object and marks it as lazy
ReflectionClass::resetAsLazyProxy
— Resets an object and marks it as lazy
ReflectionClass::setStaticPropertyValue
— Establece el valor de una propiedad estática
ReflectionClass::__toString
— Devuelve la representación en forma de string del objeto ReflectionClass
ReflectionClassConstant
— The ReflectionClassConstant class
ReflectionClassConstant::__construct
— Constructs a ReflectionClassConstant
ReflectionClassConstant::export
— Export
ReflectionClassConstant::getAttributes
— Gets Attributes
ReflectionClassConstant::getDeclaringClass
— Gets declaring class
ReflectionClassConstant::getDocComment
— Gets doc comments
ReflectionClassConstant::getModifiers
— Gets the class constant modifiers
ReflectionClassConstant::getName
— Get name of the constant
ReflectionClassConstant::getType
— Gets a class constant's type
ReflectionClassConstant::getValue
— Gets value
ReflectionClassConstant::hasType
— Checks if class constant has a type
ReflectionClassConstant::isDeprecated
— Checks if deprecated
ReflectionClassConstant::isEnumCase
— Checks if class constant is an Enum case
ReflectionClassConstant::isFinal
— Checks if class constant is final
ReflectionClassConstant::isPrivate
— Checks if class constant is private
ReflectionClassConstant::isProtected
— Checks if class constant is protected
ReflectionClassConstant::isPublic
— Checks if class constant is public
ReflectionClassConstant::__toString
— Returns the string representation of the ReflectionClassConstant object
ReflectionConstant
— The ReflectionConstant class
ReflectionConstant::__construct
— Constructs a ReflectionConstant
ReflectionConstant::getExtension
— Gets ReflectionExtension of the defining extension
ReflectionConstant::getExtensionName
— Gets name of the defining extension
ReflectionConstant::getFileName
— Gets name of the defining file
ReflectionConstant::getName
— Gets name
ReflectionConstant::getNamespaceName
— Gets namespace name
ReflectionConstant::getShortName
— Gets short name
ReflectionConstant::getValue
— Gets value
ReflectionConstant::isDeprecated
— Checks if deprecated
ReflectionConstant::__toString
— Returns string representation
ReflectionEnum
— The ReflectionEnum class
ReflectionEnum::__construct
— Instantiates a ReflectionEnum object
ReflectionEnum::getBackingType
— Gets the backing type of an Enum, if any
ReflectionEnum::getCase
— Returns a specific case of an Enum
ReflectionEnum::getCases
— Returns a list of all cases on an Enum
ReflectionEnum::hasCase
— Checks for a case on an Enum
ReflectionEnum::isBacked
— Determines if an Enum is a Backed Enum
ReflectionEnumUnitCase
— The ReflectionEnumUnitCase class
ReflectionEnumUnitCase::__construct
— Instantiates a ReflectionEnumUnitCase object
ReflectionEnumUnitCase::getEnum
— Gets the reflection of the enum of this case
ReflectionEnumUnitCase::getValue
— Gets the enum case object described by this reflection object
ReflectionEnumBackedCase
— The ReflectionEnumBackedCase class
ReflectionEnumBackedCase::__construct
— Instantiates a ReflectionEnumBackedCase object
ReflectionEnumBackedCase::getBackingValue
— Gets the scalar value backing this Enum case
ReflectionZendExtension
— Clase ReflectionZendExtension
ReflectionZendExtension::__clone
— Clon de controlador
ReflectionZendExtension::__construct
— Constructor
ReflectionZendExtension::export
— Exportar
ReflectionZendExtension::getAuthor
— Consultar autor
ReflectionZendExtension::getCopyright
— Consultar los derechos de copia
ReflectionZendExtension::getName
— Obtiene el nombre
ReflectionZendExtension::getURL
— Obtiene la URL
ReflectionZendExtension::getVersion
— Obtiene la versión
ReflectionZendExtension::__toString
— Convierte a texto
ReflectionExtension
— Clase ReflectionExtension
ReflectionExtension::__clone
— Clonar
ReflectionExtension::__construct
— Constructor de los objetos ReflectionExtension
ReflectionExtension::export
— Exportar
ReflectionExtension::getClasses
— Obtiene clases
ReflectionExtension::getClassNames
— Obtiene nombres de las clases
ReflectionExtension::getConstants
— Obtiene las constantes
ReflectionExtension::getDependencies
— Obtiene las dependencias
ReflectionExtension::getFunctions
— Obtiene las funciones de una extensión
ReflectionExtension::getINIEntries
— Obtiene las entradas INI de la extensión
ReflectionExtension::getName
— Obtiene el nombre de la extensión
ReflectionExtension::getVersion
— Obtiene la versión de una extensión
ReflectionExtension::info
— Imprime información sobre la extensión
ReflectionExtension::isPersistent
— Indica si la extensión es persistente
ReflectionExtension::isTemporary
— Indica si la extensión es temporal
ReflectionExtension::__toString
— Convertir a string
ReflectionFunction
— Clase ReflectionFunction
ReflectionFunction::__construct
— Contruye un objeto de tipo ReflectionFunction
ReflectionFunction::export
— Exporta una función
ReflectionFunction::getClosure
— Genera dinámicamente una función anónima de esta función
ReflectionFunction::invoke
— Invoca una función
ReflectionFunction::invokeArgs
— Invoca a la función con argumentos
ReflectionFunction::isAnonymous
— Checks if a function is anonymous
ReflectionFunction::isDisabled
— Comprueba si una función está desactivada
ReflectionFunction::__toString
— Convertir a string
ReflectionFunctionAbstract
— Clase ReflectionFunctionAbstract
ReflectionFunctionAbstract::__clone
— Clona una función
ReflectionFunctionAbstract::getAttributes
— Gets Attributes
ReflectionFunctionAbstract::getClosureCalledClass
— Returns the class corresponding to static:: inside a closure
ReflectionFunctionAbstract::getClosureScopeClass
— Devuelve el ámbito asociado al cierre
ReflectionFunctionAbstract::getClosureThis
— Devuelve una función anónima que apunta a esta función
ReflectionFunctionAbstract::getClosureUsedVariables
— Returns an array of the used variables in the Closure
ReflectionFunctionAbstract::getDocComment
— Obtiene comentarios de documentación
ReflectionFunctionAbstract::getEndLine
— Obtiene número de linea final
ReflectionFunctionAbstract::getExtension
— Obtiene información sobre la extensión
ReflectionFunctionAbstract::getExtensionName
— Obtiene el nombre de la extensión
ReflectionFunctionAbstract::getFileName
— Obtiene el nombre del fichero
ReflectionFunctionAbstract::getName
— Obtiene el nombre de la función
ReflectionFunctionAbstract::getNamespaceName
— Obtiene el nombre del espacio de nombres
ReflectionFunctionAbstract::getNumberOfParameters
— Obtiene el número total de parámetros
ReflectionFunctionAbstract::getNumberOfRequiredParameters
— Obtiene el número de parámetros obligatorios
ReflectionFunctionAbstract::getParameters
— Obtiene los parámetros
ReflectionFunctionAbstract::getReturnType
— Gets the specified return type of a function
ReflectionFunctionAbstract::getShortName
— Obtiene el nombre abreviado de la función
ReflectionFunctionAbstract::getStartLine
— Obtiene el número de la línea de inicio
ReflectionFunctionAbstract::getStaticVariables
— Obtiene las variable estáticas
ReflectionFunctionAbstract::getTentativeReturnType
— Returns the tentative return type associated with the function
ReflectionFunctionAbstract::hasReturnType
— Checks if the function has a specified return type
ReflectionFunctionAbstract::hasTentativeReturnType
— Devuelve si la función tiene un tipo de retorno tentativo
ReflectionFunctionAbstract::inNamespace
— Comprueba si pertenece a un espacio de nombres
ReflectionFunctionAbstract::isClosure
— Comprobar si es un cierre
ReflectionFunctionAbstract::isDeprecated
— Comprueba si está obsoleta
ReflectionFunctionAbstract::isGenerator
— Devuelve si la función es un generador
ReflectionFunctionAbstract::isInternal
— Comprueba si la función es interna
ReflectionFunctionAbstract::isStatic
— Checks if the function is static
ReflectionFunctionAbstract::isUserDefined
— Comprueba si es una función definida por un usuario
ReflectionFunctionAbstract::isVariadic
— Comprueba si la función es varíadica
ReflectionFunctionAbstract::returnsReference
— Comprueba si devuelve una referencia
ReflectionFunctionAbstract::__toString
— Convertir a texto
ReflectionMethod
— La clase ReflectionMethod
ReflectionMethod::__construct
— Construye un objeto ReflectionMethod
ReflectionMethod::createFromMethodName
— Creates a new ReflectionMethod
ReflectionMethod::export
— Exporta un objeto de tipo ReflectionMethod
ReflectionMethod::getClosure
— Devuelve un cierre creado dinámicamente para este método
ReflectionMethod::getDeclaringClass
— Obtiene la clase en la que se ha declarado el método
ReflectionMethod::getModifiers
— Obtiene los modificadores del método
ReflectionMethod::getPrototype
— Obtiene el prototipo del método (si lo hubiera)
ReflectionMethod::hasPrototype
— Returns whether a method has a prototype
ReflectionMethod::invoke
— Invoca un método
ReflectionMethod::invokeArgs
— Invoca un método con argumentos
ReflectionMethod::isAbstract
— Comprueba si el método es abstracto
ReflectionMethod::isConstructor
— Comprueba si el método es un constructor
ReflectionMethod::isDestructor
— Comprueba si el método es un destructor
ReflectionMethod::isFinal
— Comprueba si el método es final
ReflectionMethod::isPrivate
— Comprueba si el método es privado
ReflectionMethod::isProtected
— Comprueba si el método está protegido
ReflectionMethod::isPublic
— Comprueba si el método es público
ReflectionMethod::setAccessible
— Asigna la accesibilidad del método
ReflectionMethod::__toString
— Devuelve la representación en forma de texto de este objeto
ReflectionNamedType
— The ReflectionNamedType class
ReflectionNamedType::getName
— Get the name of the type as a string
ReflectionNamedType::isBuiltin
— Checks if it is a built-in type
ReflectionObject
— Clase ReflectionObject
ReflectionObject::__construct
— Construye un ReflectionObject
ReflectionObject::export
— Exportación
ReflectionParameter
— La clase ReflectionParameter
ReflectionParameter::allowsNull
— Comprueba si null es permitido
ReflectionParameter::canBePassedByValue
— Devuelve si este parámetro de puede pasar por valor
ReflectionParameter::__clone
— Clon
ReflectionParameter::__construct
— Construct
ReflectionParameter::export
— Exportar
ReflectionParameter::getAttributes
— Gets Attributes
ReflectionParameter::getClass
— Obtener la clase con declaraciones de tipos
ReflectionParameter::getDeclaringClass
— Obtiene declaración de la clase
ReflectionParameter::getDeclaringFunction
— Obtiene declaración de función
ReflectionParameter::getDefaultValue
— Obtiene el valor del parámetro por defecto
ReflectionParameter::getDefaultValueConstantName
— Devuelve el nombre de la consntante del valor predeterminado si el valor predeterminado es constante o null
ReflectionParameter::getName
— Obtener el nombre del parámetro
ReflectionParameter::getPosition
— Obtiene la posición del parámetro
ReflectionParameter::getType
— Gets a parameter's type
ReflectionParameter::hasType
— Checks if parameter has a type
ReflectionParameter::isArray
— Comprueba si el parámetro espera un array
ReflectionParameter::isCallable
— Devuelve si el parámetro DEBE ser de tipo callable
ReflectionParameter::isDefaultValueAvailable
— Comprueba si el valor por defecto está disponible
ReflectionParameter::isDefaultValueConstant
— Devuelve si el valor predeterminado de este parámetro es constante
ReflectionParameter::isOptional
— Comprueba si es opcional
ReflectionParameter::isPassedByReference
— Comprueba si es pasado por referencia
ReflectionParameter::isPromoted
— Checks if a parameter is promoted to a property
ReflectionParameter::isVariadic
— Comprueba si el parámetro es varíadico
ReflectionParameter::__toString
— A string
ReflectionProperty
— Clase ReflectionProperty
ReflectionProperty::__clone
— Clonar
ReflectionProperty::__construct
— Construir un objeto ReflectionProperty
ReflectionProperty::export
— Exportar
ReflectionProperty::getAttributes
— Gets Attributes
ReflectionProperty::getDeclaringClass
— Obtiene la clase en la que se declaró
ReflectionProperty::getDefaultValue
— Returns the default value declared for a property
ReflectionProperty::getDocComment
— Obtiene los comentarios de documentación de una propiedad
ReflectionProperty::getHook
— Returns a reflection object for a specified hook
ReflectionProperty::getHooks
— Returns an array of all hooks on this property
ReflectionProperty::getModifiers
— Obtiene los modificadores
ReflectionProperty::getName
— Obtiene el nombre de la propiedad
ReflectionProperty::getRawValue
— Returns the value of a property, bypassing a get hook if defined
ReflectionProperty::getSettableType
— Returns the parameter type of a setter hook
ReflectionProperty::getType
— Gets a property's type
ReflectionProperty::getValue
— Obtiene el valor
ReflectionProperty::hasDefaultValue
— Checks if property has a default value declared
ReflectionProperty::hasHook
— Returns whether the property has a given hook defined
ReflectionProperty::hasHooks
— Returns whether the property has any hooks defined
ReflectionProperty::hasType
— Checks if property has a type
ReflectionProperty::isAbstract
— Determines if a property is abstract
ReflectionProperty::isDefault
— Comprueba si una propiedad es predeterminada
ReflectionProperty::isDynamic
— Checks if property is a dynamic property
ReflectionProperty::isFinal
— Determines if this property is final or not
ReflectionProperty::isInitialized
— Checks whether a property is initialized
ReflectionProperty::isLazy
— Checks whether a property is lazy
ReflectionProperty::isPrivate
— Comprueba si una propiedad es privada
ReflectionProperty::isPrivateSet
— Checks if property is private for writing
ReflectionProperty::isPromoted
— Checks if property is promoted
ReflectionProperty::isProtected
— Comprueba si la propiedad es protegida
ReflectionProperty::isProtectedSet
— Checks whether the property is protected for writing
ReflectionProperty::isPublic
— Comprueba si la propiedad es pública
ReflectionProperty::isReadOnly
— Checks if property is readonly
ReflectionProperty::isStatic
— Comprueba si la propiedad es estática
ReflectionProperty::isVirtual
— Determines if a property is virtual
ReflectionProperty::setAccessible
— Hace accesible una propiedad
ReflectionProperty::setRawValue
— Sets the value of a property, bypassing a set hook if defined
ReflectionProperty::setRawValueWithoutLazyInitialization
— Set raw property value without triggering lazy initialization
ReflectionProperty::setValue
— Establece el valor de la propiedad
ReflectionProperty::skipLazyInitialization
— Marks property as non-lazy
ReflectionProperty::__toString
— Convertir a texto
ReflectionType
— The ReflectionType class
ReflectionType::allowsNull
— Checks if null is allowed
ReflectionType::__toString
— To string
ReflectionUnionType
— The ReflectionUnionType class
ReflectionUnionType::getTypes
— Returns the types included in the union type
ReflectionGenerator
— The ReflectionGenerator class
ReflectionGenerator::__construct
— Constructs a ReflectionGenerator object
ReflectionGenerator::getExecutingFile
— Gets the file name of the currently executing generator
ReflectionGenerator::getExecutingGenerator
— Gets the executing Generator object
ReflectionGenerator::getExecutingLine
— Gets the currently executing line of the generator
ReflectionGenerator::getFunction
— Gets the function name of the generator
ReflectionGenerator::getThis
— Gets the $this value of the generator
ReflectionGenerator::getTrace
— Gets the trace of the executing generator
ReflectionGenerator::isClosed
— Checks if execution finished
ReflectionFiber
— The ReflectionFiber class
ReflectionFiber::__construct
— Constructs a ReflectionFiber object
ReflectionFiber::getCallable
— Gets the callable used to create the Fiber
ReflectionFiber::getExecutingFile
— Get the file name of the current execution point
ReflectionFiber::getExecutingLine
— Get the line number of the current execution point
ReflectionFiber::getFiber
— Get the reflected Fiber instance
ReflectionFiber::getTrace
— Get the backtrace of the current execution point
ReflectionIntersectionType
— The ReflectionIntersectionType class
ReflectionIntersectionType::getTypes
— Returns the types included in the intersection type
ReflectionReference
— La clase ReflectionReference
ReflectionReference::__construct
— Private constructor to disallow direct instantiation
ReflectionReference::fromArrayElement
— Create a ReflectionReference from an array element
ReflectionReference::getId
— Get unique ID of a reference
ReflectionAttribute
— The ReflectionAttribute class
ReflectionAttribute::__construct
— Private constructor to disallow direct instantiation
ReflectionAttribute::getArguments
— Gets arguments passed to attribute
ReflectionAttribute::getName
— Gets attribute name
ReflectionAttribute::getTarget
— Returns the target of the attribute as bitmask
ReflectionAttribute::isRepeated
— Returns whether the attribute of this name has been repeated on a code element
ReflectionAttribute::newInstance
— Instantiates the attribute class represented by this ReflectionAttribute class and arguments
Reflector
— La interfaz Reflector
Reflector::export
— Exportar
ReflectionException
— La clase ReflectionException
PropertyHookType
— The PropertyHookType Enum