[Corten]

Je veux faire un truc du genre :

Code PHP:

<?php

class myClass{
  private $defaultPath = $_SERVER['DOCUMENT_ROOT'];
  ...
}

Mais ca ne va pas.

Alors pour m'en sortir, j'ai fait ça :

Code PHP:

class myClass{

  public function __construct(){
  $this->defaultPath = $_SERVER['DOCUMENT_ROOT'];
  }
  ... 

Vraiment terrible
Parce que évidement, je veux une fonction statique dans ma classe et je ne peux pas accéder à $this->defaultPath. J'aurais bien voulu avoir un self::defaultPath.

Comment peut-on s'en sortir ?

[Choucas]

T'as essayé en déclarant ta propriété static ?

Code PHP:

<?php

class myClass{
  private static $defaultPath = $_SERVER['DOCUMENT_ROOT'];
  ...
}

J'ai pas testé, mais ça ressemble à cet exemple, nan ?

[Corten]

oui j'ai tenté en static et ça ne va pas non plus.

Ca diffère de l'exemple car ici je fais une référence vers une autre variable, c'est ça qu'il n'aime pas.
Mais ça ne m'arrange pas vraiment

Les gars qui font du java, vous avez le même comportement ?

[Assuran]

En java tu es pas sencé affecter une valeur à une variable lors de la déclaration de celle-ci mais lui fournir un type (en php théoriquement pas non plus mais tu peux le faire

Sinon pour ta question

ton utilisation ne semble pas erronée, elle est proche de certains examples que tu peux trouver

http://ch.php.net/manual/fr/language.oop5.php

Es tu sur de ta version de php question à la con mais si t'as une vieille version de 4 qui traine ne t'étonnes pas que ça marche de travers.

[leinou]

En java y'a pas de soucis, on déclare la variable dans la classe et elle est utilisable dans les fonctions.

Après pour PHP, je sais pas du tout mais la réponse m'intéresse.

[Votre pseudo ici]

à tout hasard,

Code:

class myClass{
  var $_defaultPath;
  public function __construct(){
     $this->_defaultPath = $_SERVER['DOCUMENT_ROOT'];
  }

Je dis ça parce que dans ton code, tu ne délcare pas $defaultPath avant de l'initialiser, ce que tu ne peux pas faire.

[Homesick Monkey]

A priori, il n'y a aucune obligation de déclarer une propriété avant de la "setter"

Si tu veux vraiment faire du self::$var tu peux faire ainsi :

Code PHP:

<?php

class test {
    private static $defaultPath = null;
    private $nom, $prenom;
    public function __construct($nom, $prenom) {
        if(self::$defaultPath === null) {
            self::init();
        }
        $this->nom = $nom;
        $this->prenom = $prenom;
    }
    public function showInfos() {
        echo '<p>' . $this->prenom . ' ' . $this->nom . ' ' . self::$defaultPath . '</p>';
    }
    private static function init() {
        self::$defaultPath = $_SERVER['DOCUMENT_ROOT'];
    }
}

$test = new test('machin','cousin');
$test->showInfos();

$test2 = new test('malkovitch','john');
$test2->showInfos();

?>

ou ainsi mais bof

Code PHP:

<?php

class test {
    private static $defaultPath = null;
    private $nom, $prenom;
    public function __construct($nom, $prenom) {
        $this->nom = $nom;
        $this->prenom = $prenom;
    }
    public function showInfos() {
        echo '<p>' . $this->prenom . ' ' . $this->nom . ' ' . self::$defaultPath . '</p>';
    }
    public static function init() {
        if(self::$defaultPath === null) {
            self::$defaultPath = $_SERVER['DOCUMENT_ROOT'];
        }
    }
}

test::init();

$test = new test('machin','cousin');
$test->showInfos();

$test2 = new test('malkovitch','john');
$test2->showInfos();

?>

[Corten]

Citation :

Publié par Homesick Monkey

...

Ca résout effectivement le problème d'accès par self:: à l'intérieur de la classe.

Mais ce qui me manque encore c'est de pouvoir mettre cette satanée variable bien au dessus avec toutes mes const et mes static qui me servent de config.
Et je doit faire un test::init ou un new une première fois si je veux accéder à ma variable.

Je me suis inspiré de ton code et j'ai fait ça :

Code PHP:

<?php

class myClass {
    private static $defaultPath = null;
    
    public static function getDefaultPath(){
        if (self::$defaultPath === null){
            self::$defaultPath = $_SERVER['DOCUMENT_ROOT'];
        }
        return self::$defaultPath;
    }
}
echo myClass::getDefaultPath();

Si quelqu'un a mieux, je suis preneur.

[Homesick Monkey]

Le but c'est de setter les variables de config de ta classe une seule fois qu'elle soit instanciée ou non ?

Si c'est le cas tu peux faire un truc dans ce style :

Code PHP:

<?php

class Test {
    private static $config;
    public function __construct() {
        if(self::$config === null) {
            self::config();
        }
    }
    public function printShortPath() {
        echo self::$config->shortPath;
    }
    public static function config() {
        if(self::$config === null) {
            self::$config = new Config(array(
                'defaultPath' => $_SERVER['DOCUMENT_ROOT'],
                'shortPath' => $_SERVER['PHP_SELF']
            ));
        }
        return self::$config;
    }
}

class Config {
    public function __construct($array) {
        foreach($array as $k => $v) {
            $this->$k = $v;
        }
    }
}

echo Test::config()->defaultPath; // la config sera instanciée une seule fois
echo '<br />';
$test = new Test();
$test->printShortPath();

?>

[Corten]

Ouais c'est cool.

On sait pourquoi on ne sait pas setter les variables comme on veut ?

[Sylm]

Sans doute un problème de compilo/contexte d'exécution ou autre. Mais sinon tu as toujours l'option de faire un fichier de conf et de l'importer dès le chargement de ta classe via un compact() ou un array_merge().

[NayFe]

que c'est laid le php longue vie au C

[Zeil l'exilé]

Citation :

Publié par Sylmerìn

Sans doute un problème de compilo/contexte d'exécution ou autre. Mais sinon tu as toujours l'option de faire un fichier de conf et de l'importer dès le chargement de ta classe via un compact() ou un array_merge().

C'est juste le langage qui ne le permet pas.

Ce n'est d'ailleurs pas le seul à ne pas vouloir de sorte de "bloc statique de construction par défaut" (à défaut de meilleur nom).