class ABC { private $array = ['username' => 'scott', 'password' => 'p@$$word', 'isActive' => true]; private $user = '******'; public function getUser() { return $this->user; } /* create __call function */ /* name is string & parameter is array*/ public function __call($function_name, $function_parameter) { return "{$function_name}" . implode(', ', $function_parameter) . "\n"; /*if(array_key_exists($function_name,$this->array)){ return $this->array[$function_name]; }else{ echo "You are trying to call a function name $function_name with following parameter:"; print_r($function_parameter); }*/ } private function getUserName($var) { return 'sdfs' . $var; } } $obj = new ABC(); /* call member function. */ //echo $obj->getUser(); /* Fatal error: Call to undefined method ABC::getUserName() */ echo $obj->getUserName('abc'); //echo $obj->isActive()?'Logged In':'Not Logged In';
} } } public function __get($name) { if (property_exists($this, $name)) { return $this->{$name}; } } public function results() { return $this->array; } } /* create object */ $obj = new ABC(); /* set the value/ assign value $obj->parray =array('asd','xyz'); var_dump($obj->parray); */ $obj->text = 'abc'; $obj->key = "!@#\$%^&"; echo $obj->key; var_dump($obj->results()); //var_dump($obj->array); /* reference */ /* @this is slower (than getters/setters) @there is no auto-completion (and this is a major problem actually), and type management by the IDE for refactoring and code-browsing (under Zend Studio/PhpStorm this can be handled with the @property phpdoc annotation but that requires to maintain them: quite a pain) @the documentation (phpdoc) doesn't match how your code is supposed to be used, and looking at your class doesn't bring much answers as well. This is confusing. @added after edit: having getters for properties is more consistent with "real" methods where getXXX() is not only returning a private property but doing real logic. You have the same naming. For example you have $user->getName() (returns private property) and $user->getToken($key) (computed). The day your getter gets more than a getter and needs to do some logic, everything is still consistent.
<?php class ABC { public function __construct() { echo "inside construct"; } public function __destruct() { echo "inside destruct"; } public function xyz() { echo "inside xyz"; } public function s() { echo "inside s"; } } $a = new ABC(); $a->xyz(); $a->s();
<?php /* * @ __callstatic * @description * call static is same as call function. using call function we call object of the functions. * but in __callstatic we call context of the function. */ class ABC { private $array = ['abc' => 'ABC variable', 'xyz' => 'XYZ variable']; public static function __callstatic($name, $value) { if (function_exists($name)) { return 'function exists'; } else { echo 'function not exists'; } } public static function getName() { return "SCott"; } } var_dump(ABC::getName());
<?php trait A { function p() { echo "A\n"; } } trait B { function p() { echo "B\n"; } } trait C { function p() { echo "C\n"; } } class ABC { use A, B, C { A::p insteadof B, C; } } $abc = new ABC(); $abc->p();