Forum d'entraide PHPFrance

salut la team

j'ai une table de db qui contient moulte information special...
j'aimerai créé une superglobal $_ZZZ qui serai en fait un tableau associatif un peu comme $_SESSION, $_SERVER ....

j'ai trois fichier: ma_page.php à laquel j'inclue system.php dans lequel est inclue fonction.php

dans fonction.php, j'ai la fonction suivante pour definir cette superglobal $_ZZZ:

function definition_superglobal()
{
   //connexion au serveur MySQL
   include ("../info_sql_connection.php");
   $connexion = mysql_connect($hostdb, $userdb, $passdb) or die('Erreur SQL !<br />'.$connexion.'<br />'.mysql_error());

   //sélection de la BDD
   $db = mysql_select_db($usedb_su,$connexion) or die('Erreur SQL !<br />'.$db.'<br />'.mysql_error());

   // selection de toutes les valeur de la table pour id=1
   $sql = "SELECT * FROM `$table_su` WHERE id = 1";
   $result = mysql_query($sql) or die('Erreur SQL !<br />'.$sql.'<br />'.mysql_error());

   mysql_close();
   
   $_ZZZ = mysql_fetch_assoc($result); // met toutes mes valeurs sql en tableau associatif
   global $_ZZZ; // je fait en sorte que cette variable soit global donc reutilisable de partout
}

mon problème est que si je fait un print_r($_ZZZ); sur ma page, rien n'est retourné

si quelqu'un a une idée a me soumettre pour faire en sorte que, lorsque la fonction est executer, ma superglobal $_ZZZ soit utilisable sur mes page, ainsi que dans fonction.php et systeme.php?

merci d'avance

hello,

Pour vulgariser le systeme de "global" (je sais pas trop comment l'expliquer autrement en fait )

Imaginons un systeme à étages : le rez-de-chaussée c'est ta procédure, le premier étage c'est la définition de ta fonction... "global" te sert au premier étage pour récupérer une variable du rez-de-chaussée, c'est tout. Donc ne répond pas du tout à ton probleme.

Si tu souhaites rendre une variable globale, en théorie, tu as pas vraiment d'autre choix que de passer par le tableau $GLOBALS. Accessoirement tu peux aussi affecter des valeurs comme cela t'amuse à $_GET ou $_POST (qui existent toujours et sont toujours superglobaux) mais question propreté c'est super limite (allons pas de chichis, c'est super dégueu en fait !)

Sinon la derniere solution (qui peut etre assez propre suivant l'utilisation qu'on en fait, enfin à mon sens) :
tu définis une structure (classe) aux propriétés statiques.

class MaSuperGlobaleAMoi{
	public static $valeur;
}

Une classe étant accessible de maniere statique globalement, tu peux l'utiliser à n'importe quel "étage" de ton script :

MaSuperGlobaleAMoi::$valeur = $truc;

hmmm, interessant tout plein

ma class doit etre definit dans quel fichier aussi ?

une variable superglobal est une variable accessible partout. Il n'est pas possible d'en créer pour l'instant. Il y a eu quelque thread a ce sujet pour php6 mais rien de véritablement avancé. Juste quelque discussion.
Tout ce que tu peux faire toi, c'est des variables global, c'est a dire accessible depuis le script principal sans avoir a faire de spécification globale, ou depuis une fonction en spécifiant que la variable est global. Cette varibale sera automatiquement dans le tableau superglobal $GLOBALS.
Pour info, La dénomination $_VAR n'est pas interdite mais déconseillé car Zend se reserve le droit de créer des variables systeme de ce type.

Sur le code que tu donnes, tu fais une erreur. Il faut dabord définir la comme étant globale

function definition_super() {
// Toute acces a $_ZZZ sera désormais considéré comme global, impossible de faire une référence a un $_ZZZ local
global $_ZZZ;

// Ensuite,  Tout acces ou définition se fera sur le tas global

$_ZZZ = mysql_fetch_assoc($result);

$GLOBALS['_YYY'] = 'titi'; // Définie $_YYY a titi dans le scope global
$_YYY = 'toto'; // Définie $_YYY a toto dans le scope local de la fonction, 



}
definition_super();
print_r($_ZZZ) ; // Affiche le contenu initialisé par la fonction definition_super();
echo $_YYY; // Affichera titi

Si tu veux pouvoir accéder a $_ZZZ depuis une autre fonction, il te faudra
- Soit déclarer global $_ZZZ avant l'acces.
- Soit utiliser la super global $GLOBALS['_ZZZ']

merci titerm et merci à tous

j'ai trouver mon bonheur, y'a bon

ok je revient vous voir car j'ai un tit soucis que je ne m'explique pas...

j'ai 3 fichiers. ma_page.php au debut de laquelle j'inclue fichier1.php. dans ce dernier j'inclue fonction.php et j'execute un fonction make_global_ZZZ(); .

voici la dite fonction de fonction.php:

function make_global_ZZZ()
{
   // on definit $_ZZZ comme global afin d'y avoir acces à l'extrieur de la fonction
   global $_ZZZ;

   //connexion au serveur MySQL
   include ("../path/sql_connection.php");
   $connexion = mysql_connect($hostdb, $userdb, $passdb) or die('Erreur SQL !<br />'.$connexion.'<br />'.mysql_error());

   //sélection de la BDD
   $db = mysql_select_db($usedb,$connexion) or die('Erreur SQL !<br />'.$db.'<br />'.mysql_error());

   // on recupere tout le contenu de la table3
   $sql = "SELECT * FROM `table3` WHERE id = 1";
   $result = mysql_query($sql) or die('Erreur SQL !<br />'.$sql.'<br />'.mysql_error());
   mysql_close();

   // on definit la variable global precedement defini comme telle
   $_ZZZ = mysql_fetch_assoc($result);
}

mes infos enregistrées dans $_ZZZ sont disponible sur ma_page.php et fichier1.php mais par contre je suis obliger de repreciser global $_ZZZ; dans toutes les autres fonctions utilisant $_ZZZ.
Pourtant la fonction make_global_ZZZ() est dans le même fichier fonction.php que les autres fonctions...
celles-ci ne devraient elles pas avoir acces à $_ZZZ qui est definit en global dans make_global_ZZZ(), sans avoir à repreciser global $_ZZZ dans chacunes d'elles?

apres moulte test d'echo de la var $_ZZZ, je m'aperçoi qu'elle est accesible de partout (page, fichier1.php, autre fichier inclue à la page) mais pas dans les autres fonctions du même fichier où celle ci est definit (fonction.php).

cette global $_ZZZ ne devrai elle pas etre aussi accesible dans les autres fonction defini sur le même fichier ?

Pour qu'une variable globale soit accessible dans une fonction, quelque soit le fichier, il faut la déclarer comme global dans la fonction.

function toto() {
gloabl $_ZZZ;

print_r($_ZZZ);
}

oui mais la c'est bien ce que je fait...

en gros c'est pour avoir acces à la global $_ZZZ dans les autres fonctions du même fichier

suis-je obliger de mettre un global $_ZZZ dans toutes les autres fonctions où l'on se sert de $_ZZZ, ou simplement la definir comme global dans sa fonction de definition (voir precedent message) ?

Comme dit le précédent miens. ...

global ne rend pas une variable globale. Elle dit que la variable est une variable global. Si tu ne le mentionne pas, elle sera considérée comme locale. Relit bien mon premier post. j'ai l'impression que tu n'as pas vraiment comprit le principe et le fonctionnement du mot clé global.

suis-je obliger de mettre un global $_ZZZ dans toutes les autres fonctions où l'on se sert de $_ZZZ

Oui...

Pour répondre à la question initiale il n'est pas possible de créer une superglobale à moins de patcher PHP.

Donc tout ce que tu peux faire c'est une variable GLOBALE...

suis-je obliger de mettre un global $_ZZZ dans toutes les autres fonctions où l'on se sert de $_ZZZ

Oui.

Une autre méthode peut-être plus propre pour ce que tu veux faire, c'est d'utiliser PHP5, la POO, et le Pattern Singleton (c'est la méthode Singleton::instance() ci-dessous) :

class Singleton
{
    private $_array;
    public function __construct() {
        $this->_array = array();
    }
    static function instance() {
        static $obj = null;
        if ($obj === null) {
            $obj = new Singleton();
        }
        return $obj;
    }
    public function __get($varname) {
        return $this->_array[$varname];
    }
    public function __set($varname, $value) {
        $this->_array[$varname] = $value;
    }
}

On peut aussi ne pas mettre de méthode instance() dans la classe Singleton, mais la sortir pour en faire une fonction à part :

function SingletonInstance() {
    ...
}

Si on appelle cette fonction avec un nom court (genre ZZZ), ça permet d'appeler ZZZ() au lieu de Singleton::instance(), légèrement plus simple à mémoriser.

Utilisation, n'importe où même dans une fonction quelconque ou une autre classe :

ZZZ()->ma_variable = 35;
$variable = ZZZ()->ma_variable;

merci les gars

merci Naholyr pour ces infos tres interessante mais il est encore un peu tôt pour moi de passer par cette methode

par contre je trouve rien dans la doc et dans mon PHP5avancé sur les variable annoncer comme public, private et protected.

quelqu'un aurrai il des infos sur ces trois definitions de type de variables?

encore merci les gars
je vait commencer a regarder les classes et objet d'ici peu