[POO] PHP est il polymorphique ?

Bonjour,

Tout est dans le titre.

a+

très souvent google est ton ami
il suffit de bien le nourrir
http://www.devshed.com/c/a/PHP/PHP-5-and-Polymorphism/
etc.

Salut

Pour répondre en clair, en effet PHP n'est pas polymorphique au sens traditionnel du terme (plusieurs fonctions avec des noms identiques mais des signatures différentes).

Pourtant, fondamentalement, le polymorphisme est le principe de pouvoir appeler la même fonction ou méthode avec paramètres qui peuvent être différents aussi bien en nombre qu'en type. En ce sens, PHP est polymorphique à l'extrême puisque le type n'existe pas, et que le nombre de paramètres est potentiellement dynamique. Il n'est pas nécessaire en PHP de déclarer les paramètres dans la déclaration d'une fonction, puisqu'on peut récupérer tous les paramètres envoyés lors de l'appel à la fonction. Si je déclare une fonction avec 2 paramètres, rien ne m'empêche de l'appeler avec 7 paramètres et de tous les utiliser... Oui, PHP le permet ;)

Pour le nombre variable de paramètres selon l'appel :

Code:

1
2
3
4
5
6
7
8
9
<?php
function foo($param1, $param2)
{
    echo func_num_args().'<br/>';
}
 
foo(1, 2, 3);
foo(1, 2, 3, 4, 5, 6, 7);
foo(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);

Bien entendu, puisque PHP est un langage à types dynamiques, il est aussi possible de donner à une fonction des paramètres de type différent selon l'appel :

Code:

1
2
3
4
5
6
7
8
9
<?php
function bar($param)
{
    echo gettype($param).'<br/>';
}
 
bar(1);
bar('deux');
bar(new stdClass());

Ce qui, si on mélange les deux principes à l'extrême, peut devenir quelque chose d'imbuvable comme :

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
<?php
function foobar()
{
    $params = func_get_args();
    $types = array();
    foreach($params as $name => $value)
    {
        if(is_null($value))
        {
            $types[$name] = 'null (pas de type)';
        }
        elseif(is_object($value))
        {
            $types[$name] = 'objet de classe '.get_class($value);
        }
        elseif(is_array($value))
        {
            $types[$name] = 'tableau de '.count($value).' éléments';
        }
        elseif(is_resource($value))
        {
            $types[$name] = 'ressource '.get_resource_type($value);
        }
        elseif(is_scalar($value))
        {
            if(is_bool($value))
            {
                $types[$name] = 'booléen';
            }
            elseif(is_numeric($value))
            {
                if(is_int($value))
                {
                    $types[$name] = 'entier';
                }
                elseif(is_float($value))
                {
                    $types[$name] = 'flottant';
                }
                else
                {
                    $types[$name] = gettype($value);
                }
            }
            elseif(is_string($value))
            {
                if(function_exists($value))
                {
                    $types[$name] = 'fonction';
                }
                elseif(is_dir($value))
                {
                    $types[$name] = 'répertoire';
                }
                elseif(is_file($value))
                {
                    if(is_executable($value))
                    {
                        $types[$name] = 'fichier exécutable';
                    }
                    elseif(is_link($value))
                    {
                        $types[$name] = 'lien système';
                    }
                    else
                    {
                        $types[$name] = 'fichier standard';
                    }
                }
                else
                {
                    $types[$name] = gettype($value);
                }
            }
        }
        else
        {
            $types[$name] = gettype($value);
        }
    }
 
    echo'<pre>'.print_r($types, TRUE).'</pre>';
}
 
foobar(1, 'deux', new stdClass());
foobar('un', new stdClass(), 3);
foobar(__FILE__, dirname(__FILE__), 'foobar');
foobar(fopen(__FILE__, 'r'));

Citation:

Envoyé par Yogui

Ce qui, si on mélange les deux principes à l'extrême, peut devenir quelque chose d'imbuvable

Certaines personnes de mon entourage pensent que ce genre de procédé rend les fonctions plus permissives et évolutives.

Du coup, elles sont bien les seules à pouvoir travailler sur ces fonctions qui, à la moindre modification de travers, fait péter toute l'application. Le polymorphisme, oui, mais à petites doses ...

l'autre inconvénient est que comme php n'offre pas de syntaxe standard pour cela (comme les accesseurs/mutateurs -__get/__set- d'une classe), et bien aucun IDE ne le prend en charge.
Cela à donc tendance à compliquer le développement.