Delicious Bookmark this on Delicious Share on Facebook SlashdotSlashdot It! Digg! Digg

PHP : Function Reference : Class/Object Functions

Class/Object Functions


These functions allow you to obtain information about classes and instance objects. You can obtain the name of the class to which an object belongs, as well as its member properties and methods. Using these functions, you can find out not only the class membership of an object, but also its parentage (i.e. what class is the object class extending).


No external libraries are needed to build this extension.


There is no installation needed to use these functions; they are part of the PHP core.

Runtime Configuration

This extension has no configuration directives defined in php.ini.

Resource Types

This extension has no resource types defined.

Predefined Constants

This extension has no constants defined.


In this example, we first define a base class and an extension of the class. The base class describes a general vegetable, whether it is edible or not and what is its color. The subclass Spinach adds a method to cook it and another to find out if it is cooked.

Example 371.


// base class with member properties and methods
class Vegetable {


Vegetable($edible, $color="green")
$this->edible = $edible;
$this->color = $color;


// end of class Vegetable

// extends the base class
class Spinach extends Vegetable {

$cooked = false;

$this->Vegetable(true, "green");

$this->cooked = true;

// end of class Spinach


We then instantiate 2 objects from these classes and print out information about them, including their class parentage. We also define some utility functions, mainly to have a nice printout of the variables.

Example 372. test_script.php


include "";

// utility functions

function print_vars($obj)
   foreach (
get_object_vars($obj) as $prop => $val) {
"\t$prop = $val\n";

$arr = get_class_methods(get_class($obj));
   foreach (
$arr as $method) {
"\tfunction $method()\n";

class_parentage($obj, $class)
   if (
is_subclass_of($GLOBALS[$obj], $class)) {
"Object $obj belongs to class " . get_class($$obj);
" a subclass of $class\n";
   } else {
"Object $obj does not belong to a subclass of $class\n";

// instantiate 2 objects

$veggie = new Vegetable(true, "blue");
$leafy = new Spinach();

// print out information about objects
echo "veggie: CLASS " . get_class($veggie) . "\n";
"leafy: CLASS " . get_class($leafy);
", PARENT " . get_parent_class($leafy) . "\n";

// show veggie properties
echo "\nveggie: Properties\n";

// and leafy methods
echo "\nleafy: Methods\n";

class_parentage("leafy", "Spinach");
class_parentage("leafy", "Vegetable");

One important thing to note in the example above is that the object $leafy is an instance of the class Spinach which is a subclass of Vegetable, therefore the last part of the script above will output:

Object leafy does not belong to a subclass of Spinach
Object leafy belongs to class spinach a subclass of Vegetable

Table of Contents

call_user_method_array — Call a user method given with an array of parameters [deprecated]
call_user_method — Call a user method on an specific object [deprecated]
class_exists — Checks if the class has been defined
get_class_methods — Gets the class methods' names
get_class_vars — Get the default properties of the class
get_class — Returns the name of the class of an object
get_declared_classes — Returns an array with the name of the defined classes
get_declared_interfaces — Returns an array of all declared interfaces
get_object_vars — Gets the properties of the given object
get_parent_class — Retrieves the parent class name for object or class
interface_exists — Checks if the interface has been defined
is_a — Checks if the object is of this class or has this class as one of its parents
is_subclass_of — Checks if the object has this class as one of its parents
method_exists — Checks if the class method exists
property_exists — Checks if the object or class has a property

Code Examples / Notes » ref.classobj


[Editor's note: If you are trying to do overriding, then you can just interrogate (perhaps in the method itself) about what class (get_class()) the object belongs to, or if it is a subclass of a particular root class.
You can alway refer to the parent overriden method, see the "Classes and Objects" page of the manual and comments/editor's notes therein.]
There is no function to determine if a member belongs to a base class or current class eg:
class foo {
function foo () { }
function a () { }
class bar extends foo {
function bar () { }
function a () { }
lala = new Bar();
how do we find programmatically if member a now belongs to class Bar or Foo.


You may find it helpful in complex projects to have namespaces for your classes, and arrange these in a hierarchical manner.   A simple way to do this is to use the filesystem to order your hierarchies and then define a function like this:
function use_namespace($namespace){
(lack of indentation due to HTML UI for this page)
This requires that all your object libraries end in .obj.php (which I use) but you can modfy it to suit your needs.  To call it you could, for exmaple call:
or if foo is part of example you can call:


You could reformat your query to use the 'as colname'
<?   $db->query("select found_rows() as found_rows"); ?>


to pillepop2003
Why do u want to know the classname of an non-existant object?
The only possible explanation for this question seems to me u want to know the class before u instantiate the object. Well, this is of no use since u always instantiate a class of ur choice.
When the class is instantiated into an object u can find the class of the object by means of get_class(). This is all u need. In case of inheritance u can use get_class($this) to get the class of the instantiated object. Now u can differentiate according to which class the object belongs to.
class A{
  function A(){
     $class_of_this = get_class($this);
     echo 'Object is an instance of class '.$class_of_this.' which is the ';
        echo 'parent-class';
     else if(strcmp($class_of_this,'B')==0)
        echo 'child-class';
     echo ".\n";
class B extends A{
  function B(){
$object1 = new A();
$object2 = new B();
When u run this code-snippet the output will be:
Object is an instance of class A which is the parent-class.
Object is an instance of class B which is the child-class.


To pillepop2003 at yahoo dot de:
It seems to me if there really is no nice way to get the class name in an un-instanciated class, there is a workaround in PHP5 though using static/class variables.
class myFoo
static $__ClassName = __CLASS__;
static function getClassName()
return myFoo::$__ClassName;
class myFooExtended extends myFoo
function __construct()
myFooExtended::$__ClassName = __CLASS__;
However, you'll need to have at least instanciated an object of the class myFooExtended before calling getClassName or introduce some other initialization (the class variable will need to be set at some point to __CLASS__ in the sub-class).


To pillepop2003 at yahoo dot de:
I have the same issue.  I have a base class that manages database tasks for a number of child classes.  One of the functions in the base class is a find() method that returns instances of the child classes.  Since find() is usually called as a static method, it needs to know the name of the child class.  As you've found, this appears to be impossible to get in an easy fashion.
The only way I've found to get the child class name is to use the debug_traceback() function.  This requires me to have a find() method in every child class, but it does work.
Here's an example:
 class parentClass {
   function find() {
     $className = NULL;
     foreach (debug_backtrace() as $bt) {
       if ($bt['function'] == __FUNCTION__) {
         $className = $bt['class'];
     // here should be some code to find the proper id, let's assume it was id 1
     $id = 1;
     return new $className($id);
 class foo extends parentClass {
   function __construct($id) {
     $this->id = id;
   function find() {
     return parent::find();
 class bar extends parentClass {
   function __construct($id) {
     $this->id = id;
   function find() {
     return parent::find();
 $a = foo::find();
 printf("Type for \$a: %s<br/>\n", get_class($a));
 $b = bar::find();
 printf("Type for \$b: %s<br/>\n", get_class($b));
?> stonecypher

to covertka at muohio dot edu and pillepop2003 at yahoo dot de:
There's a much easier solution to getting a class' name for working with a factory function.  Let's assume you're doing something like this:
 function FactoryFunction($whatever, $instancedata) {
   switch ($whatever) {
     case 'stuff'      : return new Stuff($instancedata);
     case 'otherstuff' : return new Otherstuff($instancedata);
Now, consider the named parameter idiom and remember that PHP uses hashes for everything; as a result make the following changes:
 function FactoryFunction($whatever, $instancedata) {
   switch ($whatever) {
     case 'stuff'      : return array('typeis'=>'stuff',      'instance'=>new Stuff($instancedata));
     case 'otherstuff' : return array('typeis'=>'otherstuff', 'instance'=>new Otherstuff($instancedata));
Nice 'n simple.  It seems that what the original poster wanted was something like C++ static data members; unfortunately as PHP4 has no static variables at all, there would need to be significant language change to support static-like behavior.  If you move to PHP5, the static keyword solves your problem cleanly.

pascal dot poncet

Subject: using "sql_calc_found_rows" in a MySQL query while exploiting result in a PHP db class object.
There is a nice function in MySQL that allows to know how many records would have been returned if no "where" clause were set : SQL_CALC_FOUND_ROWS.
If you have create a db object to collect the returned lines, you will be a little perplex when trying to call the result of this function.
Why ?
Simply because the returned field's name is "found_rows()" and obviously it's not possible to call something like :
<?php $result->found_rows() ?> it will try to acces a method, not a property !
Then, the only way to get the right result seems to be the use of a class function, like :
 $db->query("select found_rows()");
Of course, if somebody found an other way to solve it, like a special syntax (see the one used with curled arrays in a string), I'm really open to discuss.
Good luck,


Something I found out just now that comes in very handy for my current project:
it is possible to have a class override itself in any method ( including the constructor ) like this:
class a {
..function ha ( ) {
....if ( $some_expr ) {
......$this = new b;
......return $this->ha ( );
....return $something;
in this case assuming that class b is already defined and also has the method ha ( )
note that the code after the statement to override itself is still executed but now applies to the new class
i did not find any information about this behaviour anywhere, so i have no clue wether this is supposed to be like this and if it might change... but it opens a few possibilities in flexible scripting!!


Re: Looking for an uninstantiated class
# Loads data from a table into a class object
class LFPDataFactory extends LFPObject {
       var $object;
       var $class;
       var $table;
       function LFPDataFactory($args) {
               $this->unpackArgs($args); // assigns locals from $args
               if (in_array(strtolower($this->class), get_declared_classes())) {
                       $this->object = new $this->class;
                       // assemble the columns in the table...
                       // select their values and put them in our new object...
               } else { trigger_error("Class ".$this->class." not found", E_USER_ERROR); }
$r = new LFPDataFactory("class=LFPLayout,table=layout");
$new_obj = $r->object; // this is a LFPLayout object.
This class looks to see if the class exists, then instantiates it -- a declared class is not the same as an instantiated class. As long as LFPLayout exists somewhere in the scripts, get_declared_classes() will find it. Remember strtolower on compare, however.
Why would I do this? Because I have my class layouts the same as their respective tables; the factory then selects the data (making sure that the variables match) and plugs in the data. (I've left out the actual code to do the selection/insertion).

kim dot hermansson

Note to the solution by 'zabmilenko at hotmail dot com':
Good idea but encapsulation is a better technique which is also more portable and reliable.
You can pass an object which is based on an interface/superclass to the common DB interface.
For instance:
class DB_Common {
 // data can be either an uri or array depending on how you construct it
 // e.g. data = array('host' => 'x.x.x.x', 'port' => '65535', 'etc' => '...')
 function connect($data) { die("must be overriden by subclass"); }
 function disconnect() { die("..."); }
 function query($query) { die("..."); }
class DB_MySQL extends DB_Common { /* override methods here */ }
class DB_PgSQL extends DB_Common { /* same here */
class DB_Frontend {
 var $errmsg = array('DB_Common subclass-string or object required');
 var $_db;
 // PHP4/5 compat
 function DB_Frontend($arg) { $this->__construct($arg); }
 function __construct($arg) {
   if( is_object($arg) && is_a($arg, 'DB_Common') )
     $this->_db = $arg;
     if( !is_string($arg) )
     $arg = "DB_$arg";
     if( !class_exists($arg) )
     $this->_db = new $arg;
     // use is_subclass_of(object, string) for compat with older versions
     if( !is_subclass_of($arg, 'DB_Common') )
 // add connect, disconnect that simply calls $this->_db->method() instead
 function getOne($quey) {
   // preprocess query if needed
   $result = $this->_db->query($query);
   // process result if needed
   return $result;
 /* add more methods if needed */
// string parameter
$frontend = new DB_Frontend('MySQL');
// object parameter
$backend = new DB_MySQL();
$frontend = new DB_Frontend($backend);
You can also use a static DB class. If you see PEAR::DB you will see how all this is quite equal to eachother. The main difference is the frontend class which should encapsulte the backend.
Suggestions and/or comments appreciated.


In the function class_parentage(), the use of  'get_class($$obj)' causes the omission of the word Spinach in the second/last call to this function.
I replaced 'get_class( $$obj )' with 'get_class( $GLOBALS[$obj] )' successfully.


If you want to be able to call an instance of a class from within another class, all you need to do is store a reference to the external class as a property of the local class (can use the constructor to pass this to the class), then call the external method like this:
or if the double '->' is too freaky for you, how about:
This is handy if you write something like a general SQL class that you want member functions in other classes to be able to use, but want to keep namespaces separate. Hope that helps someone.
class class1 {
   function test($var) {
       $result = $var + 2;
       return $result;
class class2{
   var $ref_to_class=''; # to be pointer to other class
   function class1(&$ref){ #constructor
       $this->ref_to_class=$ref; #save ref to other class as property of this class
   function test2($var){
       $val = $this->ref_to_class->test($var); #call other class using ref
       return $val;
$obj1=new class1;
# obj1 is instantiated.
$obj2=new class2($obj1);
# pass ref to obj1 when instantiating obj2
# call method in obj2, which calls method in obj1
echo ($result);


If anyone is interested in looking for a way to dynamically load existing objects into a class, here is what I found very useful.
// Dynamically load External Objects into a class
 function objRef ( &$obj ) {
   eval("\$this->obj_".get_class($obj)." = \$obj;");
// Reference by using: $this->obj_[object Name]->[var|f{}]
class date {  function date ( ) { $this->date = "March 3rd"; } }
class time {  function time ( ) { $this->time = "12:30pm"; } }
class show {
function objRef ( &$obj ){
eval("\$this->obj_".get_class($obj)." = \$obj;");
  function test ( $var ){
  echo "$var".$this->obj_date->date." @ ".$this->obj_time->time;
$date = new date;
$time = new time;
$show = new show;
$show->test("Time Now => ");
// Output: Time Now => March 3rd @ 12:30pm
I found the prefix 'obj_' before the class name useful because it helped me to automatically identify external object references when scanning through my scripts. You can omit this if you want. Hope this helps someone.


I spent 20 minutes or so trying to figure this out, maybe someone else has the same problem.
To access a class' function from within the class you would have to say $this->functionname(params), rather than just functionname(params) like in other programming languages.
Hope this helps


I missed some kind of function to dynamicly override or extend an Object:
function &extendObj(&$obj, $code) {
static $num = 0;

$classname = get_class($obj);
$newclass = $classname.$num;

eval('class '.$newclass.' extends '.$classname.' { '.$code.' }');

$newobj = new $newclass();
$vars = get_class_vars($classname);
foreach($vars AS $key=>$value) {
$newobj->$key = &$obj->$key;

return $newobj;
This creates a new class which extends the old one by the given code parameter, instanciates it and copy all vars from the old obj to the new one.
class testA {
var $prop = 'a';

function funcA($val) {
$this->prop = $val;

function value() {
return $this->prop;
$obj = new testA();
$newobj = &extendObj(&$obj, 'function addX() { $this->prop .= "x"; }');
echo $newobj->value();
Results in 'abcx'. You can use the function multiple times and also with class variables. Be carefull, even if $newobj is just a copy of $obj, $obj->value() will return 'abcx', too, because of the & operator: $newobj->$key = &$obj->$key;


I had tried this code but when I create the word object it takes so much time and throws a exception.

$word_object = new COM("word.application") or die("Cannot create Word object");
$word_object->Documents->Open($file_path, false, true);
$word_data = $word_object->Selection->Text;


FYI: if you want to split your class into manageble chunks, what means different files for you, you can put you functoins into includes, and make include() have a return value. Like this:
class Some_class {
 var $value = 3;
 function add_value ($input_param) {
   return include ("path/some_file.php");
And your included file:
$input_param += $this->value;
return $input_param;
Then your function call will be:
$instance = new Some_class ();
$instance->add_value (3);
And this will return
hopefully :P
Keep in mind though, that the scope in the included file will be identical to the scope the function 'add_value' has.
And if you want to return the outcome, you should also have a return statement made in your include as well.


function from Tobias K.....
stdClass Object to XML
"$xml<?xml version='1.0' standalone='yes'?>" .
"<movies>" .
"<movie eur=\"10.00\">" .
"<title>PHP: Behind the Parser</title>" .
"<characters>" .
"<character>" .
"<name>Ms. Coder</name>" .
"<actor>Onlivia Actora</actor>" .
"</character>" .
"<character>" .
"<name>Mr. Coder</name>" .
"<actor>El ActÓr</actor>" .
"</character>" .
"</characters>" .
"<plot>" .
"Text bla bla." .
"</plot>" .
"<rating ulf=\"integer\">7</rating>" .
"<rating type=\"stars\">5</rating>" .
"</movie>" .
stdClass Object
   [movie] => stdClass Object
           [title] => PHP: Behind the Parser
           [characters] => stdClass Object
                   [character] => Array
                           [0] => stdClass Object
                                   [name] => Ms. Coder
                                   [actor] => Onlivia Actora
                           [1] => stdClass Object
                                   [name] => Mr. Coder
                                   [actor] => El ActÓr
           [plot] => Text bla bla.
           [rating] => Array
                   [0] => stdClass Object
                           [_] => 7
                           [ulf] => integer
                   [1] => stdClass Object
                           [_] => 5
                           [type] => stars
           [eur] => 10
$s = htmlentities(asXML($r,"movies",array(
"movies/movie" => "eur",
"movies/movie/rating" => "ulf type"
function asXML($obj, $name, $attrNames=NULL, &$xml="", $path="", $depth=0) {
if (is_array($obj)) {
foreach ($obj as $v)
} else {
if ($path) $xml .= "\n";
$path = $path ? "$path/$name" : $name;
$indent = str_repeat(" ",$depth*4);
$xml .= "$indent<$name";
$attr = $attrNames[$path];
if ($attr) {
if (!is_object($obj))
throw new Exception("asXML(): ".
"$path is no object, so it cannot hold attributes");
$attr = explode(" ",$attr);
foreach ($attr as $key)
if ($obj->$key) $xml .= " $key=\"{$obj->$key}\"";
$xml .= ">";
if (is_object($obj)) {
$xml .= $obj->_;
$len = strlen($xml);
foreach (get_object_vars($obj) as $key => $value)
if ($key!="_" && (!is_array($attr) || !in_array($key,$attr)))
if ($len!=strlen($xml)) $xml .= "\n$indent";
} else {
$xml .= $obj;
$xml .= "</$name>";
return $xml;


As programmers, you're probably more organized than me, but, I do try and maintain some order in my classes and codes and separate them in "packages" as in java.
This helped me keep them organized but caused havok when trying to use them, so what I did was to create a class that handles the loading of classes (which I instanciate in all pages) along with my error handling class all bundled up. This way, I can load my classes with a command similar to
the function responsible for this has some checking to see if they are loaded and stuff like that...
function loadClass($packageName,$className,$constructor=""){
 // if you dont have a constructor declare any function inside
 // the class
 if ($constructor==""){
   if (defined("CLASS_DIR")){
     $pkg = CLASS_DIR.$packageName."/";
       if (is_dir($pkg)){
         // we have a directory with the package name
         $cls = $pkg.$className.".class.php";
           // we have a file
           die("Class <b>$className</b> could not be found in package <b>$packageName</b> , please check your instalation");
         die("Package <b>$packageName</b> could not be found, please check your instalation");
Just remember to define CLASS_DIR as the physical path for the directories where you packages are...
Hope this comes in handy...
Here's an example of a diretory strucutre...
/var/www/classes/   <- this would be CLASS_DIR
in there I have:
The loadClass would look like: loadClass("package1","name");
Cute and easy


as for zabmilenko's solution:
wouldn't it be better to create it this way?
// The base class for all db classes
class DB {
protected $connectId;
// Class for MySQL, which extends base class
class MySQL extends DB {
function connect () {
 $this->connectId = mysql_connect (...);
// Class for PostgreSQL, which extends base class
class pgSQL extends DB {
function connect () {
 $this->connectId = pg_connect (...);
// and then call constructor like this:
$dbName = "MySQL";
$db = new $dbName ( ... );
// ... which creates an object of class MySQL

brett_hegr xatx yahoo xdotx com

// Useful function for determining if an object is either an
// instance or a subclass of a particular class.
function is_class($object,$class_name)
 $parent = is_a($object, $class_name);
 $child = is_subclass_of($object, $class_name);
 return $parent xor $child;


I wanted to dynamically choose an extender for a class.  This took awhile of playing with it but I came up with a solution.  Note that I can't verify how safe it is, but it appears to work for me.  Perhaps someone else can shed light on the details:
class A { var $value = "Class A\n"; }
class B { var $value = "Class B\n"; }
// Uncomment which extender you want.  You can use variables as well.
// define('__EXTENDER__', 'A');
  define('__EXTENDER__', 'B');
// Use eval to create a wrapper class.
eval('class EXTENDER extends '. __EXTENDER__ . ' { }');
class C extends EXTENDER
 function __construct()
    echo $this->value;
$t = new C;
Outputs:   Class B
Practical application:  I have a database abstraction system that has individual classes for mysql, pgsql, et al.  I want to be able to create a global db class that extends one of the individual db classes depending on the application configuration.
I know that there are probably much better ways of doing this but I haven't reached that level when it comes to classes.


  class calculator {
     var $c;
function addition($a, $b) {
  $this->c = $a + $b;
  return $this->c;

function subtraction($a, $b) {
   $this->c = $a - $b;
   return $this->c;

function multiplication($a, $b) {
  $this->c = $a * $b;
  return $this->c;

function division($a, $b) {
  $this->c = $a / $b;
  return $this->c;
$cc = new calculator;
echo $cc->addition(20, 10)."
echo $cc->subtraction(20, 10)."
echo $cc->multiplication(20, 10)."
echo $cc->division(20, 10)."


//this wil give you a nice view over your used classes.
//in my config-file i've loaded my classes
//this script gives you a class-diagram
//still need to something about the javascript feature...
//hope it helps you :)
function drawClass($c){
echo "<table style=\"background-color: #FFFFCC; border: 1px solid black;\">".$c['beschrijving'];
foreach($c as $k=>$sub){
echo "<tr><td>";
echo "</td></tr>";
echo "</table>
font-family: Verdana;
font-size: 10pt;
var mem=new Array();
function up(id){
if(!mem[id]) mem[id]=true;
else mem[id]=false;
if(mem[id]) document.getElementById(id).style.visibility="hidden";
else document.getElementById(id).style.visibility="visible";
foreach($classes as $k=>$v){
$target= &$list;
$target= &$target[$parent[$i]];
$str="<tr><td style=\"background-color: #FFCC66;\"><button onclick=\"up('$v');\">UP</button>";
foreach($parent as $itt=>$p) $str.=($itt>0?"::":"").$p;
$str.="<table style=\"background-color: #FFFFCC; width: 300px;\" id=\"".$v."\">";

foreach($vars as $l=>$w){
$str.="<tr><td>var ".$l.($w?"=".$w:"").";</td></tr>";
foreach($meth as $l=>$w){
$str.="<tr><td>function ".$w."(){}</td></tr>";

Change Language

Follow Navioo On Twitter
.NET Functions
Apache-specific Functions
Alternative PHP Cache
Advanced PHP debugger
Array Functions
Aspell functions [deprecated]
BBCode Functions
BCMath Arbitrary Precision Mathematics Functions
PHP bytecode Compiler
Bzip2 Compression Functions
Calendar Functions
CCVS API Functions [deprecated]
Class/Object Functions
Classkit Functions
ClibPDF Functions [deprecated]
COM and .Net (Windows)
Crack Functions
Character Type Functions
Cybercash Payment Functions
Credit Mutuel CyberMUT functions
Cyrus IMAP administration Functions
Date and Time Functions
DB++ Functions
Database (dbm-style) Abstraction Layer Functions
dBase Functions
DBM Functions [deprecated]
dbx Functions
Direct IO Functions
Directory Functions
DOM Functions
DOM XML Functions
enchant Functions
Error Handling and Logging Functions
Exif Functions
Expect Functions
File Alteration Monitor Functions
Forms Data Format Functions
Fileinfo Functions
filePro Functions
Filesystem Functions
Filter Functions
Firebird/InterBase Functions
Firebird/Interbase Functions (PDO_FIREBIRD)
FriBiDi Functions
FrontBase Functions
FTP Functions
Function Handling Functions
GeoIP Functions
Gettext Functions
GMP Functions
gnupg Functions
Haru PDF Functions
hash Functions
Hyperwave Functions
Hyperwave API Functions
i18n Functions
IBM Functions (PDO_IBM)
iconv Functions
ID3 Functions
IIS Administration Functions
Image Functions
Imagick Image Library
Informix Functions
Informix Functions (PDO_INFORMIX)
Ingres II Functions
IRC Gateway Functions
PHP / Java Integration
JSON Functions
LDAP Functions
libxml Functions
Lotus Notes Functions
LZF Functions
Mail Functions
Mailparse Functions
Mathematical Functions
MaxDB PHP Extension
MCAL Functions
Mcrypt Encryption Functions
MCVE (Monetra) Payment Functions
Memcache Functions
Mhash Functions
Mimetype Functions
Ming functions for Flash
Miscellaneous Functions
mnoGoSearch Functions
Microsoft SQL Server Functions
Microsoft SQL Server and Sybase Functions (PDO_DBLIB)
Mohawk Software Session Handler Functions
mSQL Functions
Multibyte String Functions
muscat Functions
MySQL Functions
MySQL Functions (PDO_MYSQL)
MySQL Improved Extension
Ncurses Terminal Screen Control Functions
Network Functions
Newt Functions
NSAPI-specific Functions
Object Aggregation/Composition Functions
Object property and method call overloading
Oracle Functions
ODBC Functions (Unified)
ODBC and DB2 Functions (PDO_ODBC)
OpenAL Audio Bindings
OpenSSL Functions
Oracle Functions [deprecated]
Oracle Functions (PDO_OCI)
Output Control Functions
Ovrimos SQL Functions
Paradox File Access
Parsekit Functions
Process Control Functions
Regular Expression Functions (Perl-Compatible)
PDF Functions
PDO Functions
Phar archive stream and classes
PHP Options&Information
POSIX Functions
Regular Expression Functions (POSIX Extended)
PostgreSQL Functions
PostgreSQL Functions (PDO_PGSQL)
Printer Functions
Program Execution Functions
PostScript document creation
Pspell Functions
qtdom Functions
Rar Functions
GNU Readline
GNU Recode Functions
RPM Header Reading Functions
runkit Functions
SAM - Simple Asynchronous Messaging
Satellite CORBA client extension [deprecated]
SCA Functions
SDO Functions
SDO XML Data Access Service Functions
SDO Relational Data Access Service Functions
SESAM Database Functions
PostgreSQL Session Save Handler
Session Handling Functions
Shared Memory Functions
SimpleXML functions
SNMP Functions
SOAP Functions
Socket Functions
Standard PHP Library (SPL) Functions
SQLite Functions
SQLite Functions (PDO_SQLITE)
Secure Shell2 Functions
Statistics Functions
Stream Functions
String Functions
Subversion Functions
Shockwave Flash Functions
Swish Functions
Sybase Functions
TCP Wrappers Functions
Tidy Functions
Tokenizer Functions
Unicode Functions
URL Functions
Variable Handling Functions
Verisign Payflow Pro Functions
vpopmail Functions
W32api Functions
WDDX Functions
win32ps Functions
win32service Functions
xattr Functions
xdiff Functions
XML Parser Functions
XML-RPC Functions
XMLReader functions
XMLWriter Functions
XSL functions
XSLT Functions
YAZ Functions
YP/NIS Functions
Zip File Functions
Zlib Compression Functions
eXTReMe Tracker