(PHP 4, PHP 5, PHP 7, PHP 8)
get_class_vars — 获取类的默认属性
类类名
返回一个关联数组，其中包含从当前作用域可见的已声明属性及其默认值。结果数组元素的形式为 varname => value。如果发生错误，则返回 false。
示例 #1 get_class_vars() 示例
<?php
类 MyClass
{
public $var1; // 此属性没有显式默认值（从技术上讲，其默认值为 NULL）...
public $var2 = "xyz";
public $var3 = 100;
private $var4;
public function __construct()
{
// 更改某些属性
$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}: ", var_export($value, true), "\n";
}
?>以上示例将输出
var1: NULL var2: 'xyz' var3: 100
示例 #2 get_class_vars() 和作用域行为
<?php
函数 format($array)
{
return implode('|', array_keys($array)) . "\r\n";
}
类 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'));
?>以上示例将输出
// 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
如果您想从类本身检索类变量，请使用 $this。
<?php
类 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";
}
?>
在 PHP 4.2.0 之后生成以下内容
a
b
c
d
eget_object_vars、get_class_vars 和 reflection getDefaultProperties 这三个函数都会显示数组的名称。对于序列化，我建议
<?php
$cName = get_class($this);
$varTemplate= get_class_vars($cName)
foreach ($varTemplate as $name => $defaultVal) {
$vars[$name] = $this->$name; // 获取实际值。
}
?>
不要扫描 $vars 并根据需要创建序列化字符串。
这可以防止在维护类模板的完整性和忽略意外的对象属性时发生错误的先前反序列化。我需要获取仅限于类的静态变量，排除实例变量。
<?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;
}
?>
该函数只返回公有的静态变量。同样的模式可以在类内部使用，这样它也会返回私有和受保护的静态变量。
<?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;
}
?>似乎缺少获取常量的函数，例如 get_class_constants()... 所以这里有一个简单的函数供大家使用。希望 Zend 在下一轮中将其作为原生 PHP 调用包含进来，而无需使用反射。
<?php
function GetClassConstants($sClassName) {
$oClass = new ReflectionClass($sClassName);
return $oClass->getConstants());
}
?><?php
class someClass {
public function toArray() {
$records = array();
foreach( $this as $key => $value ) {
$records[$key] = $value;
}
return $records;
}
}
?>我建议以下方法来获取公共成员，始终如此
<?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);
}
}
?>
这是为了缓解问题，并且 get_object_vars($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();
?>所以我想在 5.3.0 之前的版本中使用静态函数获取子类中的公共参数列表。在 5.3.0 及更高版本中，您可以像使用 'self' 一样使用新的 'static' 来获取延迟绑定。
<?php
class childClass extends parentClass
{
public $id;
public $name;
public static function getFields()
{
return self::_getFields(__CLASS__);
}
}
abstract class parentClass
{
public $idInParent;
public $nameInParent;
abstract public static function getFields();
final protected static function _getFields($className)
{
$rtn = array();
foreach (array_keys(get_class_vars($className)) as $var) {
$rtn[] = $var;
}
return $rtn;
}
}
var_dump(childClass::getFields());
?>
结果
array(4) {
[0]=>
string(2) "id"
[1]=>
string(4) "name"
[2]=>
string(10) "idInParent"
[3]=>
string(12) "nameInParent"
}如果您使用 self 作用域默认将常量值赋给变量，则 get_class_vars() 将导致致命错误。
示例
<?PHP
class Foo {
const Bar = "error";
public $Foo = self::Bar;
}
print_r(get_class_vars("Foo"));
?>
... 但是使用 "Foo::Bar" 代替 "self::Bar" 将可以工作；)在 PHP5 中，要获取所有变量（包括私有等），请使用
$reflection = new ReflectionClass($class);
$defaults = $reflection->getdefaultProperties();与手册中多处注释相反，在类内部执行 get_class_vars() 可以访问任何公共、受保护和私有成员。
<?php
class Foo {
public $x;
protected $y;
private $z;
public function __sleep() {
return( get_class_vars( __CLASS__ ) );
}
}
?>
运行良好（返回 x、y 和 z）。但是，假设与上面相同的类，
<?php
print_r( get_class_vars( "Foo" ) );
?>
将不会返回 x、y 和 z。相反，它只会返回公共成员（在本例中为 z）。这是最好的 PHP 函数之一。看看你可以做什么
类 Object
{
var $updtFields; //跟踪受影响的值
function Object($record="") {
if (is_array($record))
{
$this->updtFields = array();
foreach(array_keys(get_class_vars(get_class($this))) as $k)
if (isset($record[$k]))
{
$this->$k = $record[$k];
$this->updtFields[] = $k;
}
}
}//end of arrayToObject
function toDebug($nl='<br>')
{
foreach(array_keys(get_class_vars(get_class($this))) as $k)
echo "$k = [" . $this->$k . "]{$nl}";
}//end of toDebug
}
现在你可以做一些非常酷的事情。如果你有一个像这样的表单
<form action="" method="post">
<input type="text" name="name" />
<input type="text" name="phone" />
<input type="submit" />
</form>
并且你这样定义你的类
class Person extends Object{
var $name; //与表单中的相同
var $phone;
}
当你提交表单时，你可以像这样获取数据
$person = new Person($_POST);
//所有操作都在一行中完成，很酷！此外，如果你使用 pear db 或 adodb 从数据库获取数据，你可以执行相同的操作，只是使用从数据库获取的 $row。请记住，要求结果为关联模式。
这是我所有操作的核心对象，并且运行良好。get_class_vars_assoc()
- 返回一个关联数组，其中（父）类名称作为键，相应的类变量作为子数组。我的一些粗略的 O/R 映射的样板代码。
注意：子类中重新定义的变量将被忽略。
<?php
class GrandClass {
public $grandVar;
public $in_grand_and_parent;
public $in_grand_and_child;
public static function load() {
print_r(self::get_class_vars_assoc());
}
protected static function get_class_vars_assoc() {
$called = get_called_class();
//echo "called: $called \n";
$classVars[$called] = array_keys(get_class_vars($called));
$parent = get_parent_class($called);
while ( $parent !== FALSE ) {
//echo "parent: $parent \n";
$classVars[$parent] = array_keys(get_class_vars($parent));
$classVars[$called] = array_diff($classVars[$called],
$classVars[$parent]);
if ( isset($prevParentVars) ) {
$prevParentVars = array_diff($prevParentVars,
$classVars[$parent]);
}
$prevParentVars = &$classVars[$parent];
$parent = get_parent_class($parent);
}
return $classVars;
}
}
class ParentClass extends GrandClass {
public $in_grand_and_parent;
public $parentVar;
public $in_parent_and_child;
}
class ChildClass extends ParentClass {
public $in_grand_and_child;
public $in_parent_and_child;
public $childVar;
}
ChildClass::load();
?>
数组
(
[ChildClass] => 数组
(
[2] => childVar
)
[ParentClass] => 数组
(
[1] => parentVar
[2] => in_parent_and_child
)
[GrandClass] => 数组
(
[0] => grandVar
[1] => in_grand_and_parent
[2] => in_grand_and_child
)
)如果在包含类之前需要变量，则此函数似乎不起作用。
使用反射类来解决此问题。
https://php.net/reflectionclass我想要一个简单的 ToString() 函数，它应该是自动的且与类无关。我想将其转储到任何几个类中并快速获取值。我想将其保留在那里，以便可以为每个类自定义它，因此外部函数不适合。我想出了这个，并认为它可能有用。玩得开心！
<?php
function ToString () {
$s = "";
$s .= "<table>\n";
$s .= "<tr><td colspan=2><hr></td></tr>\n";
foreach (get_class_vars(get_class($this)) as $name => $value) {
$s .= "<tr><td>$name:</td><td>" . $this->$name . "</td></tr>\n";
}
$s .= "<tr><td colspan=2><hr></td></tr>\n";
$s .= "</table>\n";
return $s;
}
?>