(PHP 4, PHP 5, PHP 7, PHP 8)
get_class_vars — Restituisce le proprietà di default della classe
Restituisce le proprietà di default della classe data.
class_nameIl nome della classe
Restituisce un array associativo delle proprietà dichiarate e visibili
dall'ambito corrente, con il loro valore di default.
Gli elementi dell'array risultante sono nella forma di
nomevariabile => valore.
In caso di errore, essa restituisce false.
| Versione | Descrizione |
|---|---|
| 5.0.3 | get_class_vars() restituirà solo le proprietà che possono essere accedute dall'ambito corrente. |
| 5.0.2 | Chiamando get_class_vars() verranno esposte tutte le proprietà come array, a differenza dei precedenti comportamenti dove le proprietà protected e private erano prefissate con byte nul. |
| 5.0.1 | Chiamando get_class_vars() verranno esposte tutte le proprietà, come quando si converte un oggetto in una classe. |
Example #1 Esempio di get_class_vars()
<?php
class myclass {
var $var1; // questa non ha valori di default...
var $var2 = "xyz";
var $var3 = 100;
private $var4;
// costruttore
function __construct() {
// modifica di alcune proprietà
$this->var1 = "foo";
$this->var2 = "bar";
return true;
}
}
$my_class = new myclass();
$class_vars = get_class_vars(get_class($my_class));
foreach ($class_vars as $name => $value) {
echo "$name : $value\n";
}
?>Il precedente esempio visualizzerà:
var1 : var2 : xyz var3 : 100
Example #2 get_class_vars() e comportamento dell'ambito
<?php
function format($array)
{
return implode('|', array_keys($array)) . "\r\n";
}
class TestCase
{
public $a = 1;
protected $b = 2;
private $c = 3;
public static function expose()
{
echo format(get_class_vars(__CLASS__));
}
}
TestCase::expose();
echo format(get_class_vars('TestCase'));
?>Il precedente esempio visualizzerà:
// 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.<?phpclass 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:abcdeI needed to get only the class static variables, leaving out instance variables.<?phpfunction 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:<?phpstatic 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:<?PHPif (!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()); }?>