Les langages typés dynamiquement que je connais ne permettent jamais aux développeurs de spécifier les types de variables, ou du moins ont un support très limité pour cela.
JavaScript, par exemple, ne fournit aucun mécanisme pour appliquer les types de variables lorsque cela est pratique. PHP vous permet de spécifier certains types d'arguments de méthode, mais il n'y a aucun moyen d'utiliser les types natifs ( int, string, etc.) pour les arguments, et il n'y a pas moyen de faire respecter les types pour autre chose que des arguments.
Dans le même temps, il serait pratique d'avoir le choix de spécifier dans certains cas le type d'une variable dans un langage typé dynamiquement, au lieu de faire la vérification de type manuellement.
Pourquoi existe-t-il une telle limitation? Est-ce pour des raisons techniques / de performances (je suppose que c'est dans le cas de JavaScript), ou uniquement pour des raisons politiques (ce qui est, je crois, le cas de PHP)? Est-ce un cas pour d'autres langues typées dynamiquement que je ne connais pas?
Edit: en suivant les réponses et les commentaires, voici un exemple de clarification: disons que nous avons la méthode suivante en PHP simple:
public function CreateProduct($name, $description, $price, $quantity)
{
// Check the arguments.
if (!is_string($name)) throw new Exception('The name argument is expected to be a string.');
if (!is_string($description)) throw new Exception('The description argument is expected to be a string.');
if (!is_float($price) || is_double($price)) throw new Exception('The price argument is expected to be a float or a double.');
if (!is_int($quantity)) throw new Exception('The quantity argument is expected to be an integer.');
if (!$name) throw new Exception('The name argument cannot be an empty string.');
if ($price <= 0) throw new Exception('The price argument cannot be less or equal to zero.');
if ($price < 0) throw new Exception('The price argument cannot be less than zero.');
// We can finally begin to write the actual code.
// TODO: Implement the method here.
}Avec quelques efforts, cela peut être réécrit comme (voir aussi Programmation par contrats en PHP ):
public function CreateProduct($name, $description, $price, $quantity)
{
Component::CheckArguments(__FILE__, __LINE__, array(
'name' => array('value' => $name, 'type' => VTYPE_STRING),
'description' => array('value' => $description, 'type' => VTYPE_STRING),
'price' => array('value' => $price, 'type' => VTYPE_FLOAT_OR_DOUBLE),
'quantity' => array('value' => $quantity, 'type' => VTYPE_INT)
));
if (!$name) throw new Exception('The name argument cannot be an empty string.');
if ($price <= 0) throw new Exception('The price argument cannot be less or equal to zero.');
if ($price < 0) throw new Exception('The price argument cannot be less than zero.');
// We can finally begin to write the actual code.
// TODO: Implement the method here.
}Mais la même méthode serait écrite comme suit si PHP acceptait éventuellement des types natifs pour les arguments:
public function CreateProduct(string $name, string $description, double $price, int $quantity)
{
// Check the arguments.
if (!$name) throw new Exception('The name argument cannot be an empty string.');
if ($price <= 0) throw new Exception('The price argument cannot be less or equal to zero.');
if ($price < 0) throw new Exception('The price argument cannot be less than zero.');
// We can finally begin to write the actual code.
// TODO: Implement the method here.
}Lequel est le plus court à écrire? Lequel est le plus facile à lire?