class PropertyTest
    /**  Location for overloaded data.  */
    private $data = array();

    /**  Overloading not used on declared properties.  */
    public $declared = 1;

    /**  Overloading only used on this when accessed outside the class.  */
    private $hidden = 2;

    public function __set($name, $value)
        echo "Setting '$name' to '$value'n";
        $this->data[$name] = $value;

    public function __get($name)
        echo "Getting '$name'n";
        if (array_key_exists($name, $this->data)) {
            return $this->data[$name];

        $trace = debug_backtrace();
            'Undefined property via __get(): ' . $name .
            ' in ' . $trace[0]['file'] .
            ' on line ' . $trace[0]['line'],
        return null;

    /**  As of PHP 5.1.0  */
    public function __isset($name)
        echo "Is '$name' set?n";
        return isset($this->data[$name]);

    /**  As of PHP 5.1.0  */
    public function __unset($name)
        echo "Unsetting '$name'n";

    /**  Not a magic method, just here for example.  */
    public function getHidden()
        return $this->hidden;

echo "<pre>n";

$obj = new PropertyTest;

$obj->a = 1;
echo $obj->a . "nn";

echo "n";

echo $obj->declared . "nn";

echo "Let's experiment with the private property named 'hidden':n";
echo "Privates are visible inside the class, so __get() not used...n";
echo $obj->getHidden() . "n";
echo "Privates not visible outside of class, so __get() is used...n";
echo $obj->hidden . "n";

The above example will output:

Setting 'a' to '1'

Getting 'a'


Is 'a' set?


Unsetting 'a'

Is 'a' set?



Let's experiment with the private property named 'hidden':

Privates are visible inside the class, so __get() not used...


Privates not visible outside of class, so __get() is used...

Getting 'hidden'

Notice:  Undefined property via __get(): hidden in <file> on line 70 in <file> on line 29

http://stackoverflow.com/questions/4697705/php-function-overloading 에서 참조

You can only overload class methods, but not functions. See php.net/manual/en/language.oop5.overloading.php – Spechal

You cannot overload PHP functions. Function signatures are based only on their names and do not include argument lists, so you cannot have two functions with the same name. Class method overloading is different in PHP than in many other languages. PHP uses the same word but it describes a different pattern.

You can, however, declare a variadic function that takes in a variable number of arguments. You would use func_num_args() and func_get_arg() to get the arguments passed, and use them normally.

For example:

function myFunc() { for ($i = 0; $i < func_num_args(); $i++) { printf("Argument %d: %sn", $i, func_get_arg($i)); } } /* Argument 0: a Argument 1: 2 Argument 2: 3.5 */ myFunc('a', 2, 3.5);

why Do We Need Namespaces?

As the size of your PHP code library increases, there is increased risk of accidentally re-defining a function or class name that has been declared before. The problem is exacerbated when you attempt to add third-party components or plugins; what if two or more code sets implement a ‘Database’ or ‘User’ class?

Until now, the only solution has been long class/function names. For example, WordPress prefixes every name with ‘WP_’. The Zend Framework uses a highly descriptive naming convention that results in long-winded class names such as Zend_Search_Lucene_Analysis_Analyzer_Common_Text_CaseInsensitive.

Name collision problems can be solved with namespaces. PHP constants, classes, and functions can be grouped into namespaced libraries.

How are Namespaces Defined?

By default, all constant, class, and function names are placed in the global space — like they were before PHP supported namespaces.

Namespaced code is defined using a single namespace keyword at the top of your PHP file. It must be the first command (with the exception of declare) and no non-PHP code, HTML, or white-space can precede the command, e.g.

 <?php // define this code in the 'MyProject' namespace namespace MyProject; // ... code ... 

The code following this line will be assigned to the ‘MyProject’ namespace. It is not possible to nest namespaces or define more than one namespace for the same code block (only the last will be recognized). However, you can define different namespaced code in the same file, e.g.

 <?php namespace MyProject1; // PHP code for the MyProject1 namespace namespace MyProject2; // PHP code for the MyProject2 namespace // Alternative syntax namespace MyProject3 { // PHP code for the MyProject3 namespace } ?> 

Although this is possible, I would advise against it: retain your sanity by defining a single namespace per file.

PHP allows you to define a hierarchy of namespaces so libraries can be sub-divided. Sub-namespaces are separated using a backslash () character, e.g.

  • MyProjectSubName
  • MyProjectDatabaseMySQL
  • CompanyNameMyProjectLibraryCommonWidget1

Calling Namespaced Code

In a file named lib1.php, we will define a constant, a function, and a class within the AppLib1 namespace:


 <?php // application library 1 namespace AppLib1; const MYCONST = 'AppLib1MYCONST'; function MyFunction() { return __FUNCTION__; } class MyClass { static function WhoAmI() { return __METHOD__; } } ?> 

We can now include this code in another PHP file, e.g.


 <?php header('Content-type: text/plain'); require_once('lib1.php'); echo AppLib1MYCONST . "n"; echo AppLib1MyFunction() . "n"; echo AppLib1MyClass::WhoAmI() . "n"; ?> 

No namespace is defined in myapp.php so the code exists in the global space. Any direct reference to MYCONST, MyFunction or MyClass will fail because they exist in the AppLib1 namespace. To call code in lib1.php, we can add a prefix of AppLib1 to define fully-qualified names. The following result is output when we load myapp.php:

 AppLib1MYCONST AppLib1MyFunction AppLib1MyClass::WhoAmI 

Fully-qualified names can become quite long and there are few obvious benefits over defining long class names such as App-Lib1-MyClass. Therefore, in the next article, we will discuss aliasing and take a closer look at how PHP resolves namespace names.