Die dynamisch getippten Sprachen, die ich kenne, lassen die Entwickler niemals die Variablentypen spezifizieren oder haben zumindest eine sehr eingeschränkte Unterstützung dafür.
JavaScript bietet beispielsweise keinen Mechanismus zum Erzwingen von Variablentypen, wenn dies zweckmäßig ist. PHP können Sie einige Arten von Methodenargumenten angeben, aber es gibt keine Möglichkeit , einheimische Arten zu verwenden ( int, stringusw.) für die Argumente, und es gibt keine Möglichkeit , Typen für irgendetwas zu erzwingen andere als Argumente.
Gleichzeitig wäre es zweckmäßig, in einigen Fällen den Typ einer Variablen in einer dynamisch typisierten Sprache anzugeben, anstatt die Typprüfung manuell durchzuführen.
Warum gibt es eine solche Einschränkung? Ist es aus technischen / Performance-Gründen (ich nehme an, es ist im Fall von JavaScript) oder nur aus politischen Gründen (was, glaube ich, der Fall von PHP ist)? Ist dies ein Fall für andere dynamisch typisierte Sprachen, mit denen ich nicht vertraut bin?
Bearbeiten: Nach den Antworten und Kommentaren hier ein Beispiel zur Verdeutlichung: Nehmen wir an, wir haben die folgende Methode in normalem PHP:
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.
}Mit einigem Aufwand kann dies umgeschrieben werden als (siehe auch Programmierung durch Verträge in 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.
}Die gleiche Methode würde jedoch wie folgt geschrieben, wenn PHP optional native Typen für Argumente akzeptieren würde:
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.
}Welches ist kürzer zu schreiben? Welches ist leichter zu lesen?