Rendere una variabile globale accessibile per ogni funzione all'interno di una classe

Question

Ho una variabile sull'ambito globale che è denominata ${SYSTEM}, dove SYSTEM è una costante definita. Ho un sacco di classi con funzioni che hanno bisogno di avere accesso a questa variabile e trovo fastidioso dichiarare global ${SYSTEM}; ogni volta.

Ho provato a dichiarare una variabile di classe: public ${SYSTEM} = $GLOBALS[SYSTEM]; ma questo si traduce in un errore di sintassi che è strano perché ho un'altra classe che dichiara le variabili di classe in questo modo e sembra funzionare correttamente. L'unica cosa che posso pensare è che la costante non viene riconosciuta.

Sono riuscito a estrapolarlo con un costruttore ma sto cercando una soluzione più semplice prima di ricorrere a questo. variabile

---

EDIT I $ globali {} SYSTEM è un array con un sacco di altri array bambino in esso. Purtroppo non sembra esserci un modo per aggirare l'utilizzo di un costruttore ...

Answer 1

La specifica diretta delle variabili membro non può contenere riferimenti ad altre variabili (class {public $membervar = $outsidevar;} non è valido). Utilizzare invece un costruttore.

Tuttavia, poiché si tratta di una costante, perché non si utilizzano le strutture constant o class constant di php?

Answer 2

direi che le prime due cose che si distinguono per me sono:

1. non ti servono le parentesi attorno al nome della variabile, si può semplicemente fare sistema $ pubblico o $ sistema pubblico.
2. Anche se PHP non sempre lo richiede, è prassi comune incapsulare gli indici di array non numerici in virgolette singole o doppie nel caso in cui la stringa che si sta utilizzando diventi una costante a un certo punto.

Questo dovrebbe essere quello che stai cercando per

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

È inoltre possibile utilizzare le costanti di classe che sarebbe invece essere

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

Questo può fare riferimento all'interno della classe con 'auto: : SYSTEM 'ed esternamente con' SomeClass :: SYSTEM '.

Answer 3

Si potrebbe anche provare il modello singleton, anche se in qualche modo è disapprovato nei cerchi OOP, è comunemente indicato come la variabile globale delle classi.

<?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(); 

?> 

Questo esempio è leggermente modificato da wikipedia, ma è possibile ottenere l'idea. Prova googling il pattern Singleton per avere maggiori informazioni

Answer 4

Si potrebbe usare un costruttore come questo:

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

EDIT: Grazie per aver ricordato l'errore di battitura, Peter!

Questo funziona anche per la matrice.Se l'assegnazione non è desiderato, prendendo il riferimento funziona anche:

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

EDIT2: Il seguente codice è stato utilizzato per testare questo metodo e ha funzionato sul mio sistema:

<?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

Stai cercando di fare qualcosa di veramente fuori dall'ordinario, quindi puoi aspettarti che sia imbarazzante. Lavorare con i globals non è mai piacevole, soprattutto non con la selezione dinamica del nome usando la costante SYSTEM. Personalmente vi consiglio di utilizzare $GLOBALS[SYSTEM] ovunque, invece, o ...

$sys = $GLOBALS[SYSTEM]; 

... se avete intenzione di usarlo molto.

Answer 6

Ok, si spera ho l'essenza di ciò che si sta cercando di raggiungere

<?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

questo è come accedo cose a livello globale, senza 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 ora è un riferimento all'istanza di exampleGetInstance classe.

formattazione fisso

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);