Vous avez un point parfaitement valide, des langages qui ne gardent pas trace du type d'une variable existent et sont appelés "typés dynamiquement". La catégorie comprend des langages tels que JavaScript, Perl, Lisp et Python.
L'avantage que nous tirons d'un langage de type statique est une vérification supplémentaire des erreurs au moment de la compilation.
Supposons, par exemple, que vous disposez de la méthode suivante:
public addCustomerContact(Customer client, Employee contact) {
...
}
Il serait possible, si vous avez un client bob
et un employé james
dans votre code, d'appeler par erreur addCustomerContact(james, bob)
, ce qui n'est pas valide. Mais si le compilateur ne connaît pas les types de variables, il ne peut pas vous avertir que vous avez effectué un appel non valide, à la place, une erreur se produit lors de l'exécution ... et puisque les langages à typage dynamique ne vérifient pas le type de paramètres transmis aux méthodes, ce problème se produit chaque fois que votre code essaie d'utiliser les propriétés client uniquement de l' james
objet ou les propriétés employé uniquement de l' bob
objet. Cela peut être longtemps après que la paire (james, bob) ait été ajoutée à la liste des contacts clients.
Maintenant, vous vous demandez peut-être pourquoi le compilateur ne peut pas encore déduire le type de james
et bob
et nous avertir? Cela peut parfois être possible, mais si les variables n'ont vraiment aucun type, alors nous pourrions faire ce qui suit:
var james;
var bob;
if (getRandomNumber() > 0.5) {
james = new Customer();
bob = new Employee();
} else {
james = new Employee();
bob = new Customer();
}
Il est parfaitement légal d'attribuer une valeur à une variable, car nous avons dit que les variables n'ont pas de type. Cela signifie également que nous ne pouvons pas toujours connaître le type d'une variable, car elle peut être de différents types en fonction de différents chemins d'exécution.
En général, les langages typés dynamiquement sont utilisés pour les langages de script, où il n'y a pas d'étape de compilation, et donc les erreurs de compilation n'existent pas, ce qui signifie que les frappes supplémentaires nécessaires pour donner le type de variables ne seraient pas très utiles.
Il existe également des avantages distincts pour les langages typés dynamiquement, principalement en termes de moins de code nécessaire pour implémenter la même conception: les interfaces n'ont pas besoin d'être écrites, car tout est "typé canard" (nous nous soucions uniquement des méthodes / propriétés d'un objet). , pas à quelle classe appartient l'objet), il n'est pas nécessaire de donner aux variables un type explicite ... avec le compromis que nous découvrons un peu moins de bugs avant de commencer à exécuter notre code.