Comment est-duck-typing différente de l'ancienne "variante" de type et/ou des interfaces?

Question

Je continue à voir la phrase "duck typing" galvaudé, et a même couru à travers un exemple de code ou deux. Je suis trop paresseux occupé à faire mes propres recherches, quelqu'un peut me dire, brièvement:

• la différence entre un canard de type " et un old-skool 'variante de type', et
• fournir un exemple d'endroit où je pourrais préférer duck-typing sur la variante de la dactylographie, et
• donner un exemple de quelque chose que je voudrais avoir à utiliser de canard à taper pour l'accomplir?

Je ne veux pas paraître volaille en vient à douter de la puissance de ce "nouveau" construire, et je ne suis pas esquive la question en refusant de faire de la recherche, mais je suis quacking à tous, le flocage hype j'ai été voir à ce sujet dernièrement. Il ressemble à aucune frappe (aka typage dynamique) pour moi, donc je ne vois pas les avantages tout de suite.

ADDENDUM: Merci pour les exemples jusqu'à présent. Il me semble qu'en utilisant quelque chose comme "O->(Bla)" est équivalent à faire une réflexion de recherche (qui n'est probablement pas bon marché), et/ou est environ la même chose que de dire O est IBlah) dont le compilateur pourrait être en mesure de vérifier pour vous, mais ce dernier a l'avantage de distinguer mon IBlah interface de votre IBlah de l'interface tandis que les deux autres ne le font pas. Accordé, le fait d'avoir beaucoup de petites interfaces flottant autour pour chaque méthode serait gênant, mais là encore peut donc vérifier pour un grand nombre de méthodes individuelles...

...encore une fois, je suis tout simplement pas l'obtenir. Est-il un formidable gain de temps, ou de la même vieille chose dans un tout nouveau sac? Où en est l'exemple qui nécessite duck-typing?

Answer 1

Dans certaines des réponses ici, j'ai vu une mauvaise utilisation de la terminologie, ce qui a conduit les gens à donner de mauvaises réponses.

Donc, avant de donner ma réponse, je vais donner quelques définitions:

1. Fortement typé

   Une langue est fortement typé si elle applique le type de la sécurité d'un programme. Cela signifie qu'il garantit deux choses: quelque chose qu'on appelle le progrès et quelque chose appelé la préservation. Le progrès signifie que tous les "valablement tapé" programmes peuvent en fait être exécuté par l'ordinateur, Ils peuvent planter, ou de lancer une exception, ou courir pour une boucle infinie, mais en fait, ils peuvent être exécutés. Conservation signifie que si un programme est "valablement tapé" qu'il sera toujours "Valablement tapé", et qu'aucune variable (ou l'emplacement mémoire) contient une valeur qui n'est pas conforme à son type.

   La plupart des langues ont les "progrès" de la propriété. Il y a beaucoup, cependant, que ne satisfait pas la "préservation" de la propriété. Un bon exemple est le C++ (et C aussi). Par exemple, il est possible en C++ afin de le contraindre à n'importe quelle adresse mémoire à se comporter comme si c'était n'importe quel type. En fait cela permet aux programmeurs de violer le système de type tout le temps qu'ils veulent. Voici un exemple simple:

   struct foo
   {
       int x;
       iny y;
       int z;
   }
   
   
   char * x = new char[100];
   foo * pFoo = (foo *)x;
   foo aRealFoo;
   *pFoo = aRealFoo;
   

   Ce code permet à quelqu'un de prendre un tableau de caractères et d'écrire un "foo" d'instance. Si le C++ est fortement typé, ce ne serait pas possible. Type de coffre-fort langages, comme le C#, Java, VB, lisp, ruby, python, et bien d'autres, permettrait de lever une exception si vous avez essayé de jeter un tableau de caractères à un "foo" de l'instance.

2. Faiblement typé

   Quelque chose est faiblement typé si elle n'est pas fortement typé.

3. Typé statiquement

   Un langage statiquement typé si son type de système est vérifié au moment de la compilation. Un langage statiquement typé peut être soit "faiblement typé" comme C ou fortement typé comme le C#.

4. Dynamiquement typé

   Un typées dynamiquement langue est une langue où les types sont vérifiées au moment de l'exécution. Beaucoup de langues ont un mélange, de quelque sorte, entre statique et dynamique de la frappe. C#, par exemple, de vérifier le nombre de lancers dynamiquement à l'exécution, car il n'est pas possible de vérifier au moment de la compilation. D'autres exemples sont les langues comme Java, VB, et Objective-C.

   Il existe aussi quelques langues qui sont "tout à fait" ou "plutôt" typées dynamiquement, comme "lisp", "ruby", et "small talk"

5. Duck-typing

   Duck-typing est quelque chose qui est complètement orthogonale à la statique, de la dynamique, de la faiblesse, ou de taper fort. C'est la pratique de l'écriture de code qui fonctionne avec un objet quel que soit son type sous-jacent de l'identité. Par exemple, les suivantes VB.NET code:

   function Foo(x as object) as object
       return x.Quack()
   end function
   

   Va travailler, quel que soit le type de l'objet est passé dans "Foo", à condition que se définit une méthode dite de "Charlatan". C'est, si l'objet ressemble à un canard, marche comme un canard, et parle comme un canard, alors c'est un canard. Duck-typing vient dans beaucoup de formes. Il est possible d'avoir statique duck-typing, dynamique duck-typing, forte duck-typing, et la semaine duck-typing. C++ template fonctions sont un bon exemple de "la faiblesse de la statique duck-typing". L'exemple le montrer dans "JaredPar" post montre un exemple de "statique fort duck-typing". La liaison tardive dans VB (ou code en Ruby ou Python) permet de "dynamique forte de duck-typing".

6. Variante

   Une variante est une typées dynamiquement la structure de données qui peut contenir un éventail de types de données prédéfinis, y compris les chaînes, les types integer, des dates, et des objets com. Il définit ensuite un tas d'opérations de l'attribution, de la conversion et de manipulation des données stockées dans les variantes. Si une variante est fortement typé dépend de la langue dans lequel il est utilisé. Par exemple, une variante dans un VB 6 programme est fortement typé. Le VB runtime assure que les opérations écrite en VB code sera conforme aux règles de typage pour les variantes. Liant pour ajouter une chaîne à une IUnknown via le type de variant en VB va entraîner une erreur d'exécution. En C++, cependant, les variantes sont faiblement typé, car tous les types C++ sont faiblement typé.

OK.... maintenant que j'ai les définitions de la route, je peux maintenant répondre à votre question:

Une variante en VB 6, permet de duck-typing. Il y a de meilleures façons de faire duck-typing (Jared Par exemple est l'un des meilleurs), de variantes, mais vous pouvez le faire duck-typing avec des variantes. Qui est, vous pouvez écrire un morceau de code qui fonctionnera sur un objet quel que soit son type sous-jacent de l'identité.

Cependant, de le faire avec des variantes ne donne pas vraiment beaucoup de validation. Un typage statique canard type de mécanisme, comme celui JaredPar décrit donne les avantages de duck-typing, plus de la validation du compilateur. Qui peut être vraiment utile.

Answer 2

La réponse est simple variante est faiblement typé, tandis que le duck-typing est fortement typé.

Duck-typing peut se résumer joliment que "si ça marche comme un canard, ressemble à un canard, agit comme un canard, alors c'est un canard." C'informatique termes, pensez canard à l'interface suivante.

interface IDuck {
  void Quack();
}

Examinons, maintenant, Daffy

class Daffy {
  void Quack() {
    Console.WriteLine("Thatsssss dispicable!!!!");
  }
}

Daffy est pas vraiment une IDuck dans ce cas. Pourtant, il agit comme un Canard. Pourquoi faire Daffy mettre en œuvre IDuck quand il est bien évident que Daffy est en fait un canard.

C'est là que le Duck-typing. Il permet à un type sûr de conversion entre un type qui a tous les comportements d'un IDuck et un IDuck de référence.

IDuck d = new Daffy();
d.Quack();

Le Couac de la méthode peut être appelée maintenant sur "d" en toute sécurité. Il n'y a aucune chance de l'exécution, erreur de type dans cette mission ou un appel de méthode.

Answer 3

Duck-typing est juste un autre terme pour le typage dynamique ou à la fin de la liaison. Une variante de l'objet qui analyse/compile avec n'importe quel membre de l'accès (par exemple, obj.Quoi que ce soit) qui peuvent être ou ne pas être défini au cours de l'exécution est le duck-typing.

Answer 4

Sans doute rien n' exige de canard-typage, mais il peut être pratique dans certaines situations. Disons que vous avez une méthode qui prend et utilise un objet de la classe sealed Canard de certaines 3ème partie de la bibliothèque. Et vous voulez faire de la méthode vérifiable. Et le Canard a une très grosse API (un peu comme ServletRequest) de qui vous avez seulement besoin de soins sur un petit sous-ensemble. Comment avez-vous tester?

Une façon est de faire la méthode de prendre quelque chose qui charlatans. Ensuite, vous pouvez simplement créer un quacking objet fantaisie.

Answer 5

Essayez de lire le premier paragraphe de l'article de Wikipédia sur le duck-typing.
Duck-typing sur Wikipédia

Je peux avoir une interface (IRunnable) qui définit la méthode Run().
Si j'ai une autre classe avec une méthode comme ceci:
public void RunSomeRunnable(IRunnable rn) { ... }

Dans un canard de type amical de la langue j'ai pu passer dans n'importe quelle classe qui avait une méthode Run() dans le RunSomeRunnable() la méthode.
Dans un langage statiquement typé de la classe passée en RunSomeRunnable doit explicitement de mettre en œuvre la IRunnable interface.

"Si c'Run() comme un canard"

la variante est plus comme objet .NET au moins.