Rendre une variable globale accessible pour chaque fonction dans une classe

Question

J'ai une variable sur la portée globale qui est nommée ${SYSTEM}, où SYSTEM est une constante définie. J'ai beaucoup de classes avec des fonctions qui ont besoin d'avoir accès à cette variable et je trouve ennuyeux de déclarer global ${SYSTEM}; à chaque fois.

J'ai essayé de déclarer une variable de classe: public ${SYSTEM} = $GLOBALS[SYSTEM]; mais cela entraîne une erreur de syntaxe qui est bizarre car j'ai une autre classe qui déclare des variables de classe de cette manière et semble fonctionner correctement. La seule chose à laquelle je peux penser est que la constante n'est pas reconnue.

J'ai réussi à décrocher avec un constructeur mais je cherche une solution plus simple avant d'y recourir.

---

EDIT La variable globale de $ {SYSTEM} est un tableau avec beaucoup d'autres tableaux dans ce. Malheureusement, il ne semble pas y avoir un moyen de contourner l'utilisation d'un constructeur ...

Answer 1

La spécification directe des variables membres ne peut contenir aucune référence à d'autres variables (class {public $membervar = $outsidevar;} n'est pas valide non plus). Utilisez un constructeur à la place.

Cependant, comme vous avez affaire à une constante, pourquoi n'utilisez-vous pas les installations constant ou class constant de php?

Answer 2

Je dirais que les deux premières choses qui se démarquent me sont:

1. Vous ne avez pas besoin des crochets autour du nom de la variable, vous pouvez simplement faire système public $ ou public $ SYSTEM.
2. Bien que PHP ne l'exige pas toujours, il est courant d'encapsuler des index de tableaux non numériques entre guillemets simples ou doubles au cas où la chaîne que vous utilisez deviendrait une constante à un moment donné.

Cela devrait être ce que vous cherchez

class SomeClass { 
    public $system = $GLOBALS['system']; 
} 

Vous pouvez également utiliser des constantes de classe qui serait plutôt

class SomeClass { 
    const SYSTEM = $GLOBALS['system']; 
} 

Cela peut être référencé dans la classe avec « auto: : SYSTEM 'et en externe avec' SomeClass :: SYSTEM '.

Answer 3

Vous pouvez également essayer le modèle singleton, même si dans une certaine mesure il est désapprouvé dans les cercles de POO, il est communément appelé la variable globale des classes.

<?php 
class Singleton { 

    // object instance 
    private static $instance; 

    // The protected construct prevents instantiating the class externally. The construct can be 
    // empty, or it can contain additional instructions... 
    protected function __construct() { 
    ... 
    } 

    // The clone and wakeup methods prevents external instantiation of copies of the Singleton class, 
    // thus eliminating the possibility of duplicate objects. The methods can be empty, or 
    // can contain additional code (most probably generating error messages in response 
    // to attempts to call). 
    public function __clone() { 
    trigger_error('Clone is not allowed.', E_USER_ERROR); 
    } 

    public function __wakeup() { 
    trigger_error('Deserializing is not allowed.', E_USER_ERROR); 
    } 

    //This method must be static, and must return an instance of the object if the object 
    //does not already exist. 
    public static function getInstance() { 
    if (!self::$instance instanceof self) { 
     self::$instance = new self; 
    } 
    return self::$instance; 
    } 

    //One or more public methods that grant access to the Singleton object, and its private 
    //methods and properties via accessor methods. 
    public function GetSystemVar() { 
    ... 
    } 
} 

//usage 
Singleton::getInstance()->GetSystemVar(); 

?> 

Cet exemple est légèrement modifié à partir de wikipedia, mais vous pouvez avoir l'idée. Essayez googler le singleton pour plus d'informations

Answer 4

Vous pouvez utiliser un constructeur comme ceci:

class Myclass { 
    public $classvar; 
    function Myclass() { 
    $this->classvar = $GLOBALS[SYSTEM]; 
    } 
} 

EDIT: Merci de remarquer la faute de frappe, Peter!

Ceci fonctionne aussi pour le tableau.Si l'assignation ne souhaite pas, en prenant la référence fonctionne aussi:

$this->classvar =& $GLOBALS[SYSTEM]; 

EDIT2: Le code suivant a été utilisé pour tester cette méthode et il a travaillé sur mon système:

<?php 
define('MYCONST', 'varname'); 
$varname = array("This is varname", "and array?"); 

class Myclass { 
    public $classvar; 
    function Myclass() { 
    $this->classvar =& $GLOBALS[MYCONST]; 
    } 
    function printvar() { 
    echo $this->classvar[0]; 
    echo $this->classvar[1]; 
    } 
}; 

$myobj = new Myclass; 
$myobj->printvar(); 
?> 

Answer 5

Vous essayez de faire quelque chose de vraiment hors de l'ordinaire ici, alors vous pouvez vous attendre à ce qu'il soit gênant. Travailler avec les globals n'est jamais agréable, surtout pas avec la sélection de nom dynamique utilisant la constante SYSTEM. Personnellement, je vous recommande d'utiliser $GLOBALS[SYSTEM] partout à la place, ou ...

$sys = $GLOBALS[SYSTEM]; 

... si vous allez l'utiliser beaucoup.

Answer 6

Ok, je l'espère, j'ai l'essentiel de ce que vous essayez d'atteindre

<?php 
    // the global array you want to access 
    $GLOBALS['uname'] = array('kernel-name' => 'Linux', 'kernel-release' => '2.6.27-11-generic', 'machine' => 'i686'); 

    // the defined constant used to reference the global var 
    define(_SYSTEM_, 'uname'); 

    class Foo { 

     // a method where you'd liked to access the global var 
     public function bar() { 
      print_r($this->{_SYSTEM_}); 
     } 

     // the magic happens here using php5 overloading 
     public function __get($d) { 
      return $GLOBALS[$d]; 
     } 

    } 

    $foo = new Foo; 
    $foo->bar(); 

?> 

Answer 7

Voilà comment j'accéder à des choses à l'échelle mondiale sans globale.

class exampleGetInstance 
{ 

private static $instance; 

public $value1; 
public $value2; 


private function initialize() 
{ 
    $this->value1 = 'test value'; 
    $this->value2 = 'test value2'; 

} 

public function getInstance() 
{ 
    if (!isset(self::$instance)) 
    { 
     $class = __CLASS__; 
     self::$instance = new $class(); 
     self::$instance->initialize(); 
    } 
    return self::$instance; 
} 

} 

$myInstance = exampleGetInstance::getInstance(); 

echo $myInstance->value1; 

$myInstance est maintenant une référence à l'instance de exampleGetInstance classe.

mise en forme fixe

Answer 8

class Dateutility { 

    public $a,$b; 
    public function getCurrentTime() { 
     date_default_timezone_set("Asia/Karachi"); 
     echo "The current time is: "; 
     echo date("g:i a"); 
    } 

    public function seta($c) { 
     $a=$c; 
     echo "<br/>value of a is:".$a; 
    } 

    public function setb($d) { 
     $b=$d; 
     echo "value of b is:".$b; 
    } 

} 

$vari = new Dateutility;   
$vari->getCurrentTime(); 

$vari->seta(10); 
$vari->setb(20);