Haciendo que una variable global sea accesible para cada función dentro de una clase

Question

Tengo una variable en el ámbito global que se llama ${SYSTEM}, donde SISTEMA es una constante definida. Tengo muchas clases con funciones que necesitan tener acceso a esta variable y me resulta molesto declarar global ${SYSTEM}; cada vez.

Intenté declarar una variable de clase: public ${SYSTEM} = $GLOBALS[SYSTEM]; pero esto da como resultado un error de sintaxis que es extraño porque tengo otra clase que declara las variables de clase de esta manera y parece funcionar bien. Lo único que puedo pensar es que la constante no está siendo reconocida.

He logrado hacer esto con un constructor pero estoy buscando una solución más simple antes de recurrir a eso.

---

EDITAR Los $ globales {} SISTEMA variable es una matriz con una gran cantidad de otras matrices niño en ella. Lamentablemente, no parece haber una forma de evitar el uso de un constructor ...

Answer 1

La especificación directa de las variables miembro no puede contener ninguna referencia a otras variables (class {public $membervar = $outsidevar;} tampoco es válido). Use un constructor en su lugar.

Sin embargo, como se trata de una constante, ¿por qué no utiliza las instalaciones de constant o class constant de php?

Answer 2

yo diría que las dos primeras cosas que se destacan para mí son:

1. usted no necesita los soportes de todo el nombre de la variable, sólo tiene que hacer el sistema público o $ $ SISTEMA pública.
2. Si bien PHP no siempre lo requiere, es una práctica estándar encapsular índices de matriz no numéricos en comillas simples o dobles en caso de que la cadena que está utilizando se convierta en constante en algún momento.

Esto debe ser lo que estás buscando

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

También puede utilizar constantes de clase que en cambio ser

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

Esto se puede hacer referencia dentro de la clase con 'auto: : SYSTEM 'y externamente con' SomeClass :: SYSTEM '.

Answer 3

También podría probar el patrón de singleton, aunque hasta cierto punto está mal visto en los círculos de OOP, se conoce comúnmente como la variable global de las clases.

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

?> 

Este ejemplo está ligeramente modificado de la wikipedia, pero puede hacerse una idea. Intenta buscando en Google el patrón Singleton para más información

Answer 4

Se puede usar un constructor de la siguiente manera:

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

EDIT: Gracias por señalar el error tipográfico, Peter!

Esto también funciona para la matriz.Si no se desea la asignación, tomando la referencia también funciona:

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

Edit2: El siguiente código se utiliza para probar este método y ha funcionado en mi 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

Usted está tratando de hacer algo realmente fuera de lo común aquí, por lo que puede esperar que sea incómodo. Trabajar con globales nunca es agradable, especialmente no con la selección de su nombre dinámico utilizando la constante SYSTEM. En lo personal me gustaría recomendar que utiliza $GLOBALS[SYSTEM] todas partes en su lugar, o ...

$sys = $GLOBALS[SYSTEM]; 

... si vas a usarlo mucho.

Answer 6

Ok, es de esperar Tengo la esencia de lo que estamos tratando de lograr

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

así es como puedo acceder a las cosas globalmente sin global.

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 es ahora una referencia a la instancia de exampleGetInstance clase.

formato fijo

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