Using $this when not in object context

Version imprimable

Bonjour,

Jusqu' php5.6 je me servais des appels statiques pour stocker des résultats de traitements communs dans les objets appelants:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class traitment_commun { function getParam() { $this->param = 'traitement quelconque'; } } class appelant { function __construct() traitment_commun::getParam(); echo $this->param; //'traitement quelconque' }
Et hop n'importe quel script appelant pouvait récupérer le résultat d'un traitement commun dans ses propriétés.

Mais depuis php7 la ligne $this->param = 'traitement quelconque' donne l'erreur donnée dans le sujet

Quelle est maintenant la méthode appropriée pour obtenir ce même résultat ?

Salut,

PHP 7 a fait un énorme nettoyage dans les syntaxes exotiques.
Si tu déclares une classe avec une méthode non statique alors la norme exige qu'elle ne soit pas appelable avec une syntaxe statique.
PHP 7 n'a fait que s'aligner drastiquement sur les normes en vigueur. Heureusement d'ailleurs.
D'ailleurs ton code était étrange...

Ton code doit ressembler dorénavant à quelque chose dans le genre :
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 class traitment_commun { private $param; public function run() { $this->param = 'traitement quelconque'; } public function getParam() { return $this->param; } } class appelant { private $resultat; public function __construct() { $trt = new traitment_commun(); $trt->run(); $this->resultat = $trt->getParam(); } }
Je t'invite également à profiter pleinement du typage statique (ça réduit énormément les risques de trous de sécurité), facilite le débogage et améliore ton sommeil ;)

Bref, va falloir apprendre la POO plus sérieusement. PHP 7+ ne tolère plus aucune fantaisie dans la syntaxe.

Merci pour cette réponse

L'utilisation de trait pourrait-elle répondre à mon problème sans trop alourdir la syntaxe (j'ai des centaines de lignes à modifier) ?:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 trait traitment_commun { function getParam() { $this->param = 'traitement quelconque'; } } class appelant { use trait; function __construct() $this->getParam(); echo $this->param; //'traitement quelconque' }

12/08/2019, 16h10
CosmoKnacki

Je trouve qu'un exemple concret ne serait pas de trop pour pouvoir répondre à ta question.

extrait de code réel

Voici quelques exemples de traitements communs (modifiés depuis l'ouverture de la discussion par l'ajout de l'objet $o en paramètre qui est le $this de l'objet appelant, pour répondre rapidement à mon problème):

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
54
55
56
57
 
class traitements_communs{
...
/**
   * Get Common filters
   * Sets peid and exercice filters from Jrequest in caller's $this context
   *
   */
  function getCommonFilters( &$o )
  {
    $jinput = new JInput();
    $o->filter_peid 			= $jinput->get( 'filter_peid', 0, 'integer' );
    $o->filter_exercice 		= $jinput->get( 'filter_exercice', edfHelper::get_last_exercice(), 'string' );
    $o->filter_theme_id		= $jinput->get( 'filter_theme_id', 1, 'integer' );
  }
 
  /**
   * Get parameter from view group
   *
   * @param unknown_type $param
   * @param unknown_type $value
   * @return	unknown	view's value if setted or JRequest' value
   */
  static function getRequestState( $param, $default = null, $type = null ) {
    global $app;
    $jinput = new Jinput();
    $view = $jinput->getString('view');
    if ( !empty( $view ) ) $view .= ".";
 
    return $app->getUserStateFromRequest( $view . $param, $param, $default, $type );
  }
 
  /**
   * Restores parameters(s) from Request view. group
   *
   * @param array $params	edf filters if null
   */
  function restoreRequestState( &$o, $params = null ) {
    global $app;
    $_REQUEST = $o->states->request;
 
    $jinput = new Jinput();
    $view = $jinput->get('view');
    $params = edfFilters::getValues( $view );
 
    if ( !empty( $view ) ) $view .= ".";
 
    if (isset( $params ) ) foreach ( $params as $param=>$d ){
      if ( isset( $o->states->registry->$param )) $value = $o->states->registry->$param;
      else $value = null;
      if ( is_string( $view. $param) ) $app->setUserState( $view . $param, $value );
    }
  }
}
 
//utilisation d'un traitement commun:
traitements_communs::getCommonFilters( $this )

Pour bien fixer les idées, à l'origine la fonction getCommonFilter était ainsi:

Code:

1
2
3
4
5
6
7
  function getCommonFilters()
  {
    $jinput = new JInput();
    $this->filter_peid 			= $jinput->get( 'filter_peid', 0, 'integer' );
    $this->filter_exercice 		= $jinput->get( 'filter_exercice', edfHelper::get_last_exercice(), 'string' );
    $this->filter_theme_id		= $jinput->get( 'filter_theme_id', 1, 'integer' );
  }

et l'appel:

Code:

traitements_communs::getCommonFilters( )

Vous noterez qu'au passage je vais perdre en performances en passant l'objet en paramètres.

Citation:

Envoyé par kmchen

ajout de l'objet $o en paramètre qui est le $this de l'objet appelant, pour répondre rapidement à mon problème):

Vous noterez qu'au passage je vais perdre en performances en passant l'objet en paramètres.

Déjà tous les objets sont passés par référence, donc le & devant ne sert à rien.
Ensuite pour ce qui est des performance, je ne m'en soucierai pas trop si j'étais toi.
C'est le propre de tout langage de savoir passer des arguments et retourner d'autres valeurs
Comme tu cherches à factoriser ton code, c'est normal que du coup tu te retrouves avec des arguments dans tes appels de fonctions.

Ce qui me pose plus de problèmes c'est le fait que tu traînes partout global $app; et ensuite la manière de présenter ton code :
Code:

1 2 3 4 5 if (isset( $params ) ) foreach ( $params as $param=>$d ){ if ( isset( $o->states->registry->$param )) $value = $o->states->registry->$param; else $value = null; if ( is_string( $view. $param) ) $app->setUserState( $view . $param, $value ); }
ça pique sévère d'autant qu'il n'y plus aucune utilité de condenser à mort son code dans la mesure où les fichiers PHP ne sont parsés qu'une seule fois et que c'est le résultat mis en cache qui est ressorti à chaque appel, il suffit d'activer le gestionnaire de cache opcache