Typage dynamique

Le typage dynamique est une technique utilisée dans certains langages de programmation pour assigner le type de la valeur dénotée par la variable durant l'exécution du code.

Tous les langages de programmation permettent, directement ou indirectement, de manipuler des valeurs. Généralement, c'est par l'entremise de variables, qui sont une association (on dit aussi une liaison) entre un symbole et une valeur ou succession de valeurs, le symbole permettant au programmeur d'identifier et manipuler ces valeurs.

Le typage d'une variable consiste à associer à sa variable symbolique un « type » de donnée, permettant à l'ordinateur de savoir si celle-ci est de type numérique, textuel, etc., d'allouer en conséquence des zones de mémoire de dimension suffisantes pour stocker cette donnée, et éventuellement de vérifier que les manipulations programmées sur cette variable (opérations mathématiques, traitement de texte, etc.) sont cohérentes avec son type.

Le typage dynamique consiste à laisser l'ordinateur réaliser cette opération de typage « à la volée », lors de l'exécution du code, contrairement aux langages statiquement typés où l'analyse de type est effectuée en amont (en général lors de la compilation du programme). Indépendamment du moment où cette analyse est effectuée, la méthode de typage peut soit imposer des annotations explicites de types aux expressions du programme, soit disposer d'un mécanisme d'inférence de types. On notera que la plupart des langages à typage dynamique disposent de ce mécanisme. 

Le typage dynamique peut être une solution très commode pour le développement rapide de programmes, notamment lorsque le type des objets manipulés n'est pas forcément connu à l'avance, ou bien lorsque le programmeur veut permettre par commodité le changement de type d'une variable. Il est de plus nécessaire au développement d'un protocole à méta-objets — ou MOP — où le typage statique est interdit.

Exemples

Typage statique 
Par exemple, en langage C ou C++, l'extrait de programme suivant :

int a;
a = 5; 
int b = a + 1;

déclare une variable dénotée 'a', de type entier ('int'), puis lui affecte (la définit par) la valeur 5. Ensuite, une variable b, du même type, est définie et par la même occasion initialisée par le résultat de l'expression a + 1.
C++ est un langage à typage statique. En C++ moderne (après C++11), le mot clé auto permet de ne pas déclarer le type de certaines variables. Le type de la variable doit alors être inféré par le compilateur par analyse contextuelle.

int a = 1;
auto b = a + 1;

Typage dynamique 
En Common Lisp, on écrira :

  (let ((a 5)) ...)

 Le type de la donnée n'est pas associé au symbole qui dénote la variable mais est encodé dans la donnée elle-même. Ainsi, dans la portée du 'let', on peut interroger le type de la variable 'a' (c'est une application de la réflexivité) :

    (let ((a 5))
         (when (numberp a)
               (print "a est un nombre")) ...)

De plus, en cours d'exécution, 'a' pourrait recevoir un objet de type différent, si le programme l'autorise :

     (let ((a 5)
           (setf a "je suis une chaîne") ...)

Implications du typage dynamique 
La grande flexibilité que permet le typage dynamique se paye généralement par :
 une surconsommation de mémoire correspondant à l'encodage 'à la volée' du type dans la valeur ;
 une perte de temps lors des tests du programme, les erreurs de cohérence de type ne se détectant qu'à l'exécution de la ligne de code concernée, et non dès sa compilation ;
 une perte de performances due aux indirections supplémentaires ; ce surcoût à l'exécution est toutefois contrebalancé par l'accroissement de la puissance des ordinateurs actuels, et permet le développement rapide d'applications ;
 une perte de maintenabilité du code, le lecteur du code source pouvant avoir des difficultés à appréhender le type des variables, et plus encore à s'apercevoir que le code peut avoir été conçu en fonction de la variabilité de ce type.

Pour les opérations algorithmiques coûteuses, les langages de script comme Python, Tcl ou  Ruby peuvent s'interfacer à des bibliothèques écrites en langage de bas niveau comme le langage C. De plus, certains langages (en particulier Common Lisp) permettent une déclaration statique facultative du type, afin de prouver la cohérence du typage à la compilation et de supprimer les indirections.

Lorsqu'une fonction reçoit à l'exécution une donnée d'un type incorrect (erreur de type à l'exécution), une exception est alors levée.

Exemples 
 SmallTalk
 Common Lisp, Dylan, Scheme
 PHP, Perl, Tcl, Python, Ruby, Bash
 Erlang, Oz, Prolog
 Objective-C
 JavaScript

Voir aussi 
 Lambda-calcul
 Langage de programmation dynamique

Théorie des types

en:Type system#Dynamic typing