PHP Conference Nagoya 2025

get_class_vars

(PHP 4, PHP 5, PHP 7, PHP 8)

get_class_varsObtener las propiedades predeterminadas de una clase

Descripción

get_class_vars(string $class_name): array

Obtiene las propiedades predeterminadas de la clase dada.

Parámetros

class_name

El nombre de la clase

Valores devueltos

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.

Historial de cambios

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.

Ejemplos

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

Ver también

add a note

User Contributed Notes 15 notes

up
13
rec at NOSPAM dot instantmassacre dot com
21 years ago
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
e
up
3
ken at verango dot com
14 years ago
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.
up
4
bof at bof dot de
12 years ago
I 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;
}
?>
up
2
artktec at art-k-tec dot com
17 years ago
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());
}
?>
up
1
flobee
9 years ago
<?php
class someClass {
public function
toArray() {
$records = array();

foreach(
$this as $key => $value ) {
$records[$key] = $value;
}

return
$records;
}

}
?>
up
1
ciantic
12 years ago
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.
up
1
ianitsky at gmail dot com
15 years ago
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();
?>
up
0
harmor
15 years ago
So I wanted to get a list of the public parameters in a child class using a static function pre-5.3.0 (< 5.3.0). In 5.3.0+ you would use the new 'static' like you would 'self' to get the late binding.

<?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());
?>

Results:
array(4) {
[0]=>
string(2) "id"
[1]=>
string(4) "name"
[2]=>
string(10) "idInParent"
[3]=>
string(12) "nameInParent"
}
up
0
bernd at tiggerswelt dot net
17 years ago
If you assign a constant value using the self-scope by default to a variable, get_class_vars() will result in a FATAL error.

Example:

<?PHP

class Foo {
const
Bar = "error";

public
$Foo = self::Bar;
}

print_r(get_class_vars("Foo"));

?>

... but using "Foo::Bar" instead "self::Bar" will work ;)
up
-1
alan_k at php dot net
19 years ago
in PHP5 to get all the vars (including private etc.) use:

$reflection = new ReflectionClass($class);
$defaults = $reflection->getdefaultProperties();
up
-2
php dot net at sharpdreams dot com
19 years ago
Contrary to multiple comments throughout the manual, get_class_vars() performed within a class can access any public, protected, and private members.

<?php
class Foo {
public
$x;
protected
$y;
private
$z;
public function
__sleep() {
return(
get_class_vars( __CLASS__ ) );
}
}
?>

works fine (returns x, y, & z). However, given the same class as above,

<?php
print_r
( get_class_vars( "Foo" ) );
?>

will NOT return x, y, & z. Instead it will only return the public members (in our case, z).
up
-3
phpnet at stccorp dot net
17 years ago
This is one of the best php functions. Look at what you can do

class Object
{
var $updtFields;//keep track of affected values
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
}

Now you can do really cool things. If you have a form like
<form action="" method="post">
<input type="text" name="name" />
<input type="text" name="phone" />
<input type="submit" />
</form>

and you define your class like this
class Person extends Object{
var $name; //same same as in the form
var $phone;
}

when you submmit the form, you can get the data like

$person = new Person($_POST);

//everything in just one line,cool!! Also if you use pear db or adodb when you get data from the database you can do the same thing except use the $row that you get from the database. Remember to ask the result is associative mode.

This is my core Object for everthing I do and it works great.
up
-4
Mattias Ahlbck
12 years ago
get_class_vars_assoc()
- Returns an associative array with name of (parent) class(es) as key(s) and corresponding class vars as sub-arrays. My boilerplate for some crude O/R mapping.

Note: vars re-defined in sub-classes are ignored.

<?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();

?>

Array
(
[ChildClass] => Array
(
[2] => childVar
)

[ParentClass] => Array
(
[1] => parentVar
[2] => in_parent_and_child
)

[GrandClass] => Array
(
[0] => grandVar
[1] => in_grand_and_parent
[2] => in_grand_and_child
)

)
up
-4
pBakhuis at Gmail dot com
13 years ago
If you need the variables before the class is included this function does not seem to work.
Use a reflection class to get around this.
http://www.php.net/reflectionclass
up
-5
gizmobits at hotmail dot com
18 years ago
I wanted a simple ToString() function that was automatic and class independent. I wanted to dump it into any of several classes and get values quickly. I wanted to leave it there so I could customize it for each class, so an outside function wasn't suitable. I came up with this and thought it might be useful. Have fun!

<?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;
}

?>
To Top