getter __get magique pour les propriétés statiques en PHP

Question

public static function __get($value)

ne fonctionne pas, et même si elle l'a fait, il se trouve que je l'ai déjà besoin de la magie __get getter pour les propriétés d'instance dans la même classe.

Ceci est probablement oui ou non question, donc, il est possible?

Answer 1

Non, il est impossible.

page de manuel de __get :

  

membre de surcharge ne fonctionne que dans   contexte de l'objet. Ces méthodes magiques   ne sera pas déclenché en statique   le contexte. Par conséquent, ces méthodes peuvent   ne pas être déclarée statique.

En PHP 5.3, __callStatic a été ajoutée ; mais il n'y a pas encore __getStatic ni __setStatic; même si l'idée de les avoir / codage revient souvent sur le php-mailling @ internals liste.

Il y a même un Demande de commentaires: les classes statiques pour PHP
Mais, encore, pas mis en œuvre (encore?)

Answer 2

Peut-être quelqu'un encore besoin ceci:

static public function __callStatic($method, $args) {

  if (preg_match('/^([gs]et)([A-Z])(.*)$/', $method, $match)) {
    $reflector = new \ReflectionClass(__CLASS__);
    $property = strtolower($match[2]). $match[3];
    if ($reflector->hasProperty($property)) {
      $property = $reflector->getProperty($property);
      switch($match[1]) {
        case 'get': return $property->getValue();
        case 'set': return $property->setValue($args[0]);
      }     
    } else throw new InvalidArgumentException("Property {$property} doesn't exist");
  }
}

Answer 3

Très belle mbrzuchalski. Mais il semble fonctionner que sur les variables publiques. Il suffit de changer votre passage à ce pour lui permettre d'accéder privés / protégées:

switch($match[1]) {
   case 'get': return self::${$property->name};
   case 'set': return self::${$property->name} = $args[0];
}

Et vous voudrez probablement modifier l'instruction if pour limiter les variables qui sont accessibles, ou bien elle irait à l'encontre d'entre eux ayant être privé ou protégé.

if ($reflector->hasProperty($property) && in_array($property, array("allowedBVariable1", "allowedVariable2"))) {...)

Ainsi, par exemple, j'ai une classe conçue pour tirer diverses données pour moi d'un serveur distant en utilisant un module de poire ssh, et je veux faire certaines hypothèses sur le répertoire cible en fonction de ce serveur, il est demandé de regarder à. Une version peaufiné de la méthode de mbrzuchalski est parfait pour cela.

static public function __callStatic($method, $args) {
    if (preg_match('/^([gs]et)([A-Z])(.*)$/', $method, $match)) {
        $reflector = new \ReflectionClass(__CLASS__);
        $property = strtolower($match[2]). $match[3];
        if ($reflector->hasProperty($property)) {
            if ($property == "server") {
                $property = $reflector->getProperty($property);
                switch($match[1]) {
                    case 'set':
                        self::${$property->name} = $args[0];
                        if ($args[0] == "server1") self::$targetDir = "/mnt/source/";
                        elseif($args[0] == "server2") self::$targetDir = "/source/";
                        else self::$targetDir = "/";
                    case 'get': return self::${$property->name};
                }
            } else throw new InvalidArgumentException("Property {$property} is not publicly accessible.");
        } else throw new InvalidArgumentException("Property {$property} doesn't exist.");
    }
}

Answer 4

essayez ceci:

class nameClass{
    private static $_sData = [];
    private static $object = null;
    private $_oData = [];

    public function __construct($data=[]){
        $this->_oData = $data;
    }

    public static function setData($data=[]){
        self::$_sData = $data;
    }

    public static function Data(){
        if( empty( self::$object ) ){
            self::$object = new self( self::$_sData ); 
        }
        return self::$object;
    }

    public function __get($key) {
        if( isset($this->_oData[$key] ){
            return $this->_oData[$key];
        }
    }

    public function __set($key, $value) {
        $this->_oData[$key] = $value;
    }
}

nameClass::setData([
    'data1'=>'val1',
    'data2'=>'val2',
    'data3'=>'val3',
    'datan'=>'valn'
]);

nameClass::Data()->data1 = 'newValue';
echo(nameClass::Data()->data1);
echo(nameClass::Data()->data2);

Answer 5

Vous pouvez également obtenir des propriétés statiques comme les accès à des propriétés membres, en utilisant __get ():

class ClassName {    
    private static $data = 'smth';

    function __get($field){
        if (isset($this->$field)){
            return $this->$field;
        }
        if(isset(self::$$field)){  
            return self::$$field;  // here you can get value of static property
        }
        return NULL;
    }
}

$obj = new ClassName();
echo $obj->data; // "smth"

Answer 6

La combinaison __callStatic et call_user_func ou call_user_func_array peut donner accès à des propriétés statiques en classe PHP

Exemple:

class myClass {

    private static $instance;

    public function __construct() {

        if (!self::$instance) {
            self::$instance = $this;
        }

        return self::$instance;
    }

    public static function __callStatic($method, $args) {

        if (!self::$instance) {
            new self();
        }

        if (substr($method, 0, 1) == '$') {
            $method = substr($method, 1);
        }

        if ($method == 'instance') {
            return self::$instance;
        } elseif ($method == 'not_exist') {
            echo "Not implemented\n";
        }
    }

    public function myFunc() {
        echo "myFunc()\n";
    }

}

// Getting $instance
$instance = call_user_func('myClass::$instance');
$instance->myFunc();

// Access to undeclared
call_user_func('myClass::$not_exist');