(PHP 4, PHP 5, PHP 7, PHP 8)
get_class_vars — Obtener las propiedades predeterminadas de una clase
Obtiene las propiedades predeterminadas de la clase dada.
class_nameEl nombre de la clase
Devuelve una matriz asociativa de las propiedades declaradas visibles desde el
ámbito actual, con su valor predeterminado.
Los elementos del array resultante están en la forma
nombre_variable => valor.
En caso de error devuelve false.
| Versión | Descripción |
|---|---|
| 5.0.3 | get_class_vars() devolverá sólo las propiedades que pueden ser accedidas desde el ámbito actual. |
| 5.0.2 | Al llamar a get_class_vars() ahora se expondrán todas las propiedades como una matriz, a diferencia del comportamiento anterior donde las propieades protected y private eran prefijadas con bytes nul. |
| 5.0.1 | Al llamar a get_class_vars() se expondrán todas las propiedades, como cuando se convierte un objeto en una clase. |
Ejemplo #1 Ejemplo de get_class_vars()
<?php
class miclase {
var $var1; // esta no tiene valor predeterminado...
var $var2 = "xyz";
var $var3 = 100;
private $var4;
// constructor
function __construct() {
// cambiar algunas propiedades
$this->var1 = "foo";
$this->var2 = "bar";
return true;
}
}
$mi_clase = new miclase();
$vars_clase = get_class_vars(get_class($mi_clase));
foreach ($vars_clase as $nombre => $valor) {
echo "$nombre : $valor\n";
}
?>El resultado del ejemplo sería:
var1 : var2 : xyz var3 : 100
Ejemplo #2 get_class_vars() y comportamiento de ámbito
<?php
function formato($matriz)
{
return implode('|', array_keys($matriz)) . "\r\n";
}
class TestCase
{
public $a = 1;
protected $b = 2;
private $c = 3;
public static function expose()
{
echo formato(get_class_vars(__CLASS__));
}
}
TestCase::expose();
echo formato(get_class_vars('TestCase'));
?>El resultado del ejemplo sería:
// 5.0.0 a| * b| TestCase c a| * b| TestCase c // 5.0.1 - 5.0.2 a|b|c a|b|c // 5.0.3 + a|b|c a
If you want to retrieve the class vars from within the class itself, use $this.
<?php
class Foo {
var $a;
var $b;
var $c;
var $d;
var $e;
function GetClassVars()
{
return array_keys(get_class_vars(get_class($this))); // $this
}
}
$Foo = new Foo;
$class_vars = $Foo->GetClassVars();
foreach ($class_vars as $cvar)
{
echo $cvar . "<br />\n";
}
?>
Produces, after PHP 4.2.0, the following:
a
b
c
d
eI needed to get only the class static variables, leaving out instance variables.
<?php
function get_static_vars($class) {
$result = array();
foreach (get_class_vars($class) as $name => $default)
if (isset($class::$$name))
$result[$name] = $default;
return $result;
}
?>
That function returns only the public ones. The same pattern can be used inside a class, then it returns private and protected static variables, too:
<?php
static protected function get_static_vars($class = NULL) {
if (!isset($class)) $class = get_called_class();
$result = array();
foreach (get_class_vars($class) as $name => $default)
if (isset($class::$$name))
$result[$name] = $default;
return $result;
}
?>All 3 of get_object_vars, get_class_vars and reflection getDefaultProperties will reveal the name of the array. For serialization I recommend:
<?php
$cName = get_class($this);
$varTemplate= get_class_vars($cName)
foreach ($varTemplate as $name => $defaultVal) {
$vars[$name] = $this->$name; // gets actual val.
}
?>
No scan the $vars and create serialization string how you wish.
This protects against erroneous prior deserializing in maintaining the integrity of the class template and ignoring unintended object properties.<?php
class someClass {
public function toArray() {
$records = array();
foreach( $this as $key => $value ) {
$records[$key] = $value;
}
return $records;
}
}
?>I propse following for getting Public members, always:
<?PHP
if (!function_exists("get_public_class_vars")) {
function get_public_class_vars($class) {
return get_class_vars($class);
}
}
if (!function_exists("get_public_object_vars")) {
function get_public_object_vars($object) {
return get_object_vars($object);
}
}
?>
This is to mitigate the problem and a feature that get_object_vars($this) returns private members. Running it simply outside the scope will get the public.
Iterating public members only and their defaults are enormously useful in e.g. in serialization classes such as options where each public member is an serializable that is saved and loaded.If you need get the child protected/private vars ignoring the parent vars, use like this:
<?php
class childClass extends parentClass {
private $login;
private $password;
public function __set($key, $val) {
if ($key == 'password')
$this->$key = md5($val);
else
$this->$key = $val;
}
}
class parentClass {
public $name;
public $email;
function __construct() {
$reflection = new ReflectionClass($this);
$vars = array_keys($reflection->getdefaultProperties());
$reflection = new ReflectionClass(__CLASS__);
$parent_vars = array_keys($reflection->getdefaultProperties());
$my_child_vars = array();
foreach ($vars as $key) {
if (!in_array($key, $parent_vars)) {
$my_child_vars[] = $key;
}
}
print_r($my_child_vars);
}
}
$child_class = new childClass();
?>There seems to be be a function to get constants missing , i.e. get_class_constants() ... so here is a simple function for you all. Hopefully Zend will include this in the next round as a native php call, without using reflection.
<?php
function GetClassConstants($sClassName) {
$oClass = new ReflectionClass($sClassName);
return $oClass->getConstants());
}
?>