Utiliser des variables globales, les passer en paramètre ou bien une autre méthode

Bonjour à tous.
Aujourd'hui se pose à moi un gros dilem.
Voici mon cas. Je dois développer une application qui utilisera le multilangue. J'ai donc l'habitude faire un fichier par langue avec par exemple:

<?php
$config['accueil']['titre']="Bienvenue";
.....
?>

Selon ma variable de session, j'inclus tel ou tel fichier.

Hors vocici qu'arrive mon problème, les classes. Imaginons que je veuille inclure ce fichier dans mes classes et pouvoir utiliser ces variables dans mes fonctions, quel est la meilleure façon de faire. Utiliser global? Utiliser le passage de paramètre? Une autre façon de faire?

<?php
include_once('monFichier.php')
class myClass
{
   ...
   ...
 
   function myFunction(){
      global $config;
      ...
   }
 
}
ou
 
include_once('monFichier.php')
class myClass
{
   ...
   ...
 
   function myFunction($config){
      ...
      ...
   }
 
}
?>


Merci pour vos futures réponses :p

Hello,

pourquoi pas une classe de configuration statique ?
class oConf {
    static $config;
   
    private static function getConf() {
       $sLng = 'EN';
       if(isset($_SESSION['language'])) {
             $sLng = $_SESSION['language']);
       }
       require_once 'conf/config_'.$sLng.'.php';
       self::$config = $config;
    }

    static function getMsg($sMsg)  {
       if(is_null(self::$config)) {
          self::getConf();
        }
       if(!isset(self::$config[$sMsg])) {
             throw new confException...
         }
       return self::$config[$sMsg]
    }
}

class myClass {
    function myFunc() {
       echo oConf::getTrans('message');
    }
}

oConf::getMsg() à changer en oConf::getTrans()...ou l'inverse.

Cette idée ne pas l'air mal du tout, par contre j'ai une petite question technique.
J'ai l'habitude d'utiliser les classes mais de cette facon.

$monInstance = new nomDeClass();
$monInstance->maFunction();

Hors la je suis un peu perdu. Reprenons:
class oConf {     //Ok
    static $config; //Correspond à quoi? C'est mon tableau je pense.
   
    private static function getConf() {   //Ok
       $sLng = 'EN';  //Je suppose que c'est le paramètre par défaut
       if(isset($_SESSION['language'])) {   //Ok
             $sLng = $_SESSION['language']);   //Ok
       }   //Ok
       require_once 'conf/config_'.$sLng.'.php';   //Ok
       self::$config = $config; //self::$config car c'est en static c'est ça? c'est comme si on fesait $this->config=$config; sauf que comme c'est static, c'est self
    }

    static function getMsg($sMsg)  {  //Ok
       if(is_null(self::$config)) { //Ok
          self::getConf();  //Ok
        }   //Ok
       if(!isset(self::$config[$sMsg])) { //Ok
             throw new confException...   //Ok
         }   //Ok
       return self::$config[$sMsg]   //Ok
    }   //Ok
}   //Ok
-> PERFECT<-


class myClass {   //Ok
    function myFunc() {   //Ok
       echo oConf::getMsg('message'); //AIE, fatal error, cest le oConf:: qui me gêne, on ne fait pas $chose = new oConf(), a quoi corresponde les ::
    }
}

Voila si tu pouvais prendre le temps de me répondre, se serait vraiment top. Sinon on m'a suggéré les constantes. Quel est l'avantage d'utiliser les classes dans ce cas (hormis le fait de tout développer en classe). En tout cas je trouvve ton idée plutôt pas mal.

Re,

j'ai tapé ce code sur CS directement...ce qui n'est pas simple.
Reprenons afin de tester avec un $config bidon :
<?php
class oConf {
    static $config;
  
    private static function getConf() {
       $sLng = 'EN';
       if(isset($_SESSION['language'])) {
             $sLng = $_SESSION['language'];
       }
       self::$config = array('message'=> 'bla');
    }

    static function getMsg($sMsg)  {
       if(is_null(self::$config)) {
          self::getConf();
        }
       if(!isset(self::$config[$sMsg])) {
             throw new Exception('aie');
       }
       return self::$config[$sMsg];
    }
}

class myClass {
    function myFunc() {
       echo oConf::getMsg('message');
    }
}
$a = new myClass();
$a->myFunc();
?>

J'avais fait quelques erreurs de frappe, oubliant des points-virgules par-ci , des trucs par-là...

Appeler une métrhode statique d'une classe ne nécessite pas d'instancier un objet de cette classe : on fait appel à la classe, pas à un objet. C'est pour ça que je n'instancie pas oConf.
:: est l'opérateur de résolution de portée.
Je te redirige sur la doc (en français) :
http://www.php.net/manual/fr/language.oop5.static.php

Je viens de tester c'est tout simplement terrible. Un grand merci. Je vais aller faire un tour sur la doc pour bien comprendre comment on utilise les static et tout ça. Est ce qu'a tout hasard tu connaitrais un très bon tuto sur PHP 5?

Juste un dernier truc sur ton code, tu penses qu'il vaut mieux utiliser ça, on plutot que de définir $config['message'], faire des constantes. En gros au lieu d'avoir un fichier avec des variables, avoir un fichier avec des constantes, ce qui évite de passer par une classe. Quel est t'on avis?

En tout cas un gros merci pour ta patience et tes explications très claires.

Perso j'utilise du XML pour ça, alors bon...les classes permettent d'avoir quelquechose de constant et de bien structuré. Mais un simple fichier de variables ou de constantes sera plus rapide. Par contre...avec un gros volume de traductions (et de langues), ce n'est plus viable. Du tout. J'ai fait un back-oofice d'internationalisation ici, avec une classe gérant ces traductions. Il n'est pas aussi complet que celui que j'utilise (bah ouais...lol, c'est mon taf quand même), mais il fonctionne. Cherche à oLoc ou à internationalisation, pour avoir n exemple.