Initialiser des variables hors constructeur

Version imprimable

Bonsoir.

Je cherche à initialiser des variables, en dehors de tout constructeur, avec des valeurs d'autres variables.
Ainsi, je voudrais faire :
Code:

1 2 3 4 5 6 7 8 9 10 11 <?php class Constants { private static $varA = "hello wold"; private static $varB = "bonjour le monde"; public static $var1 = self::$varA; //public static $var1 = $varA; public static $var2 = self::$varA; public static $var3 = self::$varB; } ?>
J'ai une erreur du type

Code:

Parse error: syntax error, unexpected T_VARIABLE, expecting T_STRING

ou

Code:

Parse error: syntax error, unexpected T_VARIABLE

(en fonction de la présence de self:: ou non).
Ainsi, je n'ai que la classe de constante à changer, pas les classes qui utilisent $var1, $var2 ou $var3.

Dans le même genre, j'aurais besoin de faire :
Code:

1 2 3 4 5 6 7 8 9 <?php class Constants { public static $varA = "hello wold"; } class Essai { private $myvar = Constants::$varA; } ?>
Et rebelotte :

Code:

Parse error: syntax error, unexpected T_VARIABLE, expecting T_STRING

Quelle est la bonne syntaxe pour faire cela ?

08/02/2011, 23h39
Madfrix

Bonjour,

commence par virer tes 2 private pour mettre public à la place
09/02/2011, 08h05
Petibidon

Hello,

Le pourquoi se trouve ici : http://fr.php.net/manual/fr/language...properties.php

Les valeurs par défaut ne peuvent être initialisées que par des littéraux ou des constantes.
Pour le reste il faudra passer par un constructeur ou des méthodes d'initialisation.
20/02/2011, 16h19
sql_ignorant

Arf, pas cool !
Autant pour la classe Essai, je peux définir explicitement un constructeur au lieu d'utiliser le constructeur implicite, autant je ne vois pas comment faire pour une classe de type Constants.
20/02/2011, 18h05
rawsrc

Salut sql_ignorant,

Je ne vois pas l'intérêt d'avoir une classe Constants avec des variables déclarées static partout.
Si je suis ta logique ta classe ne devrait comporter que des constantes obligatoirement immutables alors que mettre des static var les rends mutables et elles perdent du coup leur sens Constants

Ensuite si tu codes sous PHP 5.3+ il te reste le Late Static Binding qui fait des merveille dans le cadre où tu aurais besoin d'initialiser "descriptivement" des variables qui peuvent être déclarées comme const ou static et résolues toutes par le même appel à static::

Enfin, je me suis coltiné ce genre de problème et le recours au LSB m'a permis d'y apporter une soluce propre.
20/02/2011, 22h15
sql_ignorant

L'intérêt ?

Confiner la portée d'une constante !

Ainsi, tu peux disposer de constante portant le même nom mais dont la portée est différente. Par exemple, la classe Constants1 peux contenir $name qui concerne l'objet1, et la classe Constants2 qui contient aussi $name mais qui concerne l'objet2.
Bien sûr, je pourrais nommer mes constantes objet1_name et objet2_name, mais pourquoi rester au modèle de programmation des années 70 quand on peut utiliser des concepts plus modernes ?

Quant à LSB, ne le connaissant pas, je serai ravi que tu m'en donnes plus d'explication.

Citation:

la classe Constants1 peux contenir $name qui concerne l'objet1, et la classe Constants2 qui contient aussi $name mais qui concerne l'objet2.

Personnellement, je metterai directement ces constantes dans l'objet1 et l'objet2. Tu confines la portée de la constante à l'objet concerné et de plus tu ne perds pas le rapport fonctionnel (voire sémantique) entre la constante et l'objet rattaché.

Pour le LSB un exemple vaut mieux qu'un long discours :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
<?php
 
class Foo {
 
   const OPTION1 = 'a';
   const OPTION2 = 'b';
 
   static $staticVar = '1';
 
   # ici tu rappatries la valeur de OPTION1 de la classe enfant dans la classe parent
   # le code de la fonction est bien localisé dans la classe mère et s'exécute avec 
   # la valeur de la classe enfant !
   static function showOption1_LSB() {
      return static::OPTION1;
   }
 
   # ici tu rappatries la valeur de OPTION2 de la classe enfant dans la classe parent
   # OPTION2 n'est pas redéfinie dans la classe enfant donc la résolution s'arrête à la classe courante
   static function showOption2_LSB() {
      return static::OPTION2;
   }
 
   static function showOption1() {
      return self::OPTION1;
   }
 
   static function showOption2() {
      return self::OPTION2;
   }
 
   # ici tu rappatries la valeur de $staticVar de la classe enfant dans la classe parent
   # le code de la fonction est bien localisé dans la classe mère et s'exécute avec 
   # la valeur de la classe enfant !
   static function showStaticVar_LSB() {
      $v = static::$staticVar;
      return "Valeur de la variable statique résolue à la volée = $v";
   }
}
 
 
class Bar extends Foo {
   const OPTION1 = 'xyz';
   static $staticVar = '123456789';
}
 
 
echo 'LSB Option 1 = ', Bar::showOption1_LSB(), '<br />'; // affiche xyz (valeur localisée dans la classe enfant)
echo 'LSB Option 2 = ', Bar::showOption2_LSB(), '<br />'; // affiche b (valeur localisée dans la classe mère)
echo 'Option 1 = ', Bar::showOption1(), '<br />'; // affiche a (valeur localisée dans la classe mère)
echo 'Option 2 = ', Bar::showOption2(), '<br />'; // affiche b (valeur localisée dans la classe mère)
echo 'StaticVar = ', Bar::showStaticVar_LSB(), '<br />'; // affiche 123456789 (valeur localisée dans la classe enfant)
 
?>

L'intérêt principal du Late Static Binding est de factoriser et de loger le code des fonctions dans les classes mères (souvent abstract) et de l'exécuter avec les valeurs des classes enfants qui ne font que redéfinir juste des paramètres (constantes ou staticvar).
Je peux te garantir c'est très très pratique. Enfin une fois que tu y a goûté...