Discussion :

[wafiwafi]

Bonjour,
J’ai un un problème sur le typage que j’explique sous forme d’exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class A 
{
public function FA()
  {
//Bla Bla bla
   }
 
}
 
class B 
{
//fonction ayant comme argument un tableau
public function FB(array $tab)
{			 
for ($numero = 0; $numero < 4; $numero++)
	{
	$tab[$numero]->FA();		
	}
}
}

Dans la méthode FB, sur les élément du tableaux ( dans mon cas des objets de type A) la méthode FA est appelée. Ma question est : Comment le compil va savoir que dans le tableau il y a des objets qui peuvent appeler cette méthode (FA) ? je ne peux pas typer le tableau dès le début au lieu de array ?
Merci à vous

[Tsilefy]

Comment le compil va savoir que dans le tableau il y a des objets qui peuvent appeler cette méthode (FA) ? je ne peux pas typer le tableau dès le début au lieu de array ?

L'interpréteur (et non le compilateur) ne sait pas à l'avance. Il va juste essayer de lancer la méthode FA de l'objet. Si l'objet a cette méthode, ça marche; si l'objet n'a pas la méthode, il lance une erreur.

Tu ne peux pas typer le tableau (il y avait une RFC de ce genre pour PHP 5.6 mais elle a été rejetée). C'est donc à toi de vérifier chaque élément du tableau en utilisant instanceof.

[wafiwafi]

ok, ça m'est très utile.
Merci beaucoup.

[CosmoKnacki]

L'idéal serait de ne pas passer de tableau à ta fonction mais une instance d'une classe C implémentant (au minimum) l'interface ArrayAccess. L'intérêt est que le contrôle du type des items se fait dans la classe en question au lieu de se faire dans la classe B où il n'a rien à faire. La fonction FB se contentera de contrôler avec un typehint que le paramètre est bien une instance de C. Exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
class C implements ArrayAccess {
  private $_array = [];
 
  public function offsetSet($offset, $value) {
    // on contrôle le type à chaque ajout.
    // NB: ici on ne peut pas utiliser de typehint car l'interface ArrayAccess l'interdit.
    if (!$value instanceof A)
      throw new InvalidArgumentException('La valeur n\'est pas une instance de A');
 
    if (is_null($offset))
      $this->_array[] = $value;
    else
      $this->_array[$offset] = $value;
 
  }
 
  public function offsetExists($offset) {
    return isset($this->_array[$offset]);
  }
 
  public function offsetUnset($offset) {
    unset($this->_array[$offset]);
  }
 
  public function offsetGet($offset) {
    return isset($this->_array[$offset]) ? $this->_array[$offset] : null;
  }
}
 
class B
{
  public function FB(C $tab) {
    for ($numero = 0; $numero < 4; $numero++) {
      $tab[$numero]->FA();
    }
  }
}
 
$tab = new C;
 
try {
  $tab[] = new A;
  $tab[] = new A;
  $tab[] = new A;
  $tab[] = new A; // $tab[] = 6;
} catch (InvalidArgumentException $e) {
  echo $e->getMessage() . ':' . PHP_EOL;
  echo $e->getTraceAsString() . PHP_EOL;
  exit(1);
}
 
$objB = new B;
$objB->FB($tab);

Si tu as besoin d'autres aspects du type Array, tu peux implémenter l'interface Iterator (qui permet notamment de parcourir une instance de C avec foreach) où carrément en la faisant hériter de la classe ArrayObject.

[wafiwafi]

Remarquable!
J'applique ça et je reviens mettre un mot.
Un grand merci

[wafiwafi]

Bonjour,

La classe C se focalise sur les instances de type A puisqu'elle procède à une vérification.
J'aimerais rendre cet aspect polymorphe! C'est à dire à la création d'un objet C, j'indique le type à vérifier. possible?
Merci
Cordialement