Ce qui est de taper canard ?

Question

Je suis tombé sur le terme duck tapant tout en lisant les sujets au hasard sur le logiciel en ligne et ne comprenait pas complètement il.

Ce qui est « duck typing » ?

Answer 1

C'est un terme utilisé dans la dynamique des langues qui n'ont pas de typage fort.

L'idée est que vous n'avez pas besoin d'un type pour invoquer une méthode sur un objet - si une méthode est définie sur elle, vous pouvez l'invoquer.

Le nom vient de l'expression "Si ça ressemble à un canard et les charlatans comme un canard, c'est un canard".

Wikipédia a beaucoup plus d'informations.

Answer 2

Duck-typing signifie qu'une opération n' a pas été formellement spécifier les exigences que c'est opérandes doivent répondre, mais juste l'essaie avec ce qui est donné.

Contrairement à ce que d'autres ont dit, ce ne sont pas nécessairement liées à la dynamique des langues ou des problèmes de succession.

Exemple de tâche: Appel à une méthode Quak sur un objet.

Sans l'aide de duck-typing, une fonction f faire de cette tâche afin de préciser à l'avance que c'est un argument à l'appui d'une méthode Quak. Une façon courante est l'utilisation des interfaces

interface IQuak { void Quak(); }

void f(IQuak x) { k.Quak(); }

Appelant f(42) échoue, mais, f(donald) fonctionne tant que donald est une instance d'un IQuak-sous-type.

Une autre approche est structurelle de taper , mais de nouveau, la méthode Quak() est formellement spécifié quelque chose qui ne peut pas le prouver quaks à l'avance sera la cause d'un compilateur à l'échec.

def f(x : { def Quak() : Unit }) = x.Quak() 

On pourrait même écrire

f :: Quakable a => a -> IO ()
f = quak

en Haskell, où l' Quakable typeclass assure l'existence de notre méthode.

---

Alors, comment est - duck-typing changer cela?

Eh bien, comme je l'ai dit, un canard système de typage ne spécifie pas d'exigences, mais essaie juste si quelque chose fonctionne.

Ainsi, un système de type dynamique que Python utilise toujours le duck-typing:

def f(x):
    x.Quak()

Si f obtient un x soutenir un Quak(), tout est parfait, sinon, il va se planter au moment de l'exécution.

Mais le duck-typing ne signifie pas typage dynamique à tous - en fait, il est très populaire, mais totalement statique duck-typing approche qui ne donnent pas toutes les exigences:

template <typename T>
void f(T x) { x.Quak(); } 

La fonction n'est pas de dire qu'il veut des x peut Quak, donc au lieu de cela, il essaie juste au moment de la compilation , et si tout fonctionne, c'est bien.

Answer 3

Wikipedia a une assez explication détaillée:

http://en.wikipedia.org/wiki/Duck_typing

duck-typing est un style de dynamique tapant dans lequel un objet courant ensemble de méthodes et de propriétés détermine la validité de la sémantique, plutôt que son héritage d'un particulier de la classe ou de la mise en œuvre d'un de l'interface.

Le point important à noter est probable qu'avec le duck-typing un développeur est plus concernés par les parties de l'objet qui sont consommés plutôt que de le sous-jacent est de type.

Answer 4

Je sais que je ne donne pas de réponse générale. En Ruby, nous n'avons pas déclarer les types de variables ou méthodes - tout est juste une sorte d'objet. Donc, la Règle est "les Classes ne Sont pas les Types"

En Ruby, la classe n'est jamais (OK, presque jamais) le type. Au lieu de cela, le type d'un objet est défini par ce que l'objet peut faire. En Ruby, nous appelons cela le duck-typing. Si un objet marche comme un canard et parle comme un canard, alors que l'interprète est heureux de le traiter comme s'il s'agissait d'un canard.

Par exemple, vous pouvez écrire une routine pour ajouter les informations de la chanson à une chaîne. Si vous venez d'un C# ou Java arrière-plan, vous pourriez être tenté d'écrire ceci: Par exemple, vous pouvez écrire une routine pour ajouter les informations de la chanson à une chaîne. Si vous venez d'un C# ou Java arrière-plan, vous pourriez être tenté d'écrire ceci: Par exemple, vous pouvez écrire une routine pour ajouter les informations de la chanson à une chaîne. Si vous venez d'un C# ou Java arrière-plan, vous pourriez être tenté d'écrire ceci:

def append_song(result, song)
# test we're given the right parameters unless result.kind_of?(String)
fail TypeError.new("String expected") end
unless song.kind_of?(Song)
fail TypeError.new("Song expected")
end
result << song.title << " (" << song.artist << ")" end
result = ""
append_song(result, song) # => "I Got Rhythm (Gene Kelly)"

Embrasser Ruby duck-typing, et vous voulez écrire quelque chose de beaucoup plus simple:

def append_song(result, song)
result << song.title << " (" << song.artist << ")"
end
result = ""
append_song(result, song) # => "I Got Rhythm (Gene Kelly)"

Vous n'avez pas besoin de vérifier le type des arguments. S'ils prennent en charge << (dans le cas de résultat) ou le titre et l'artiste (dans le cas de la chanson), tout simplement. Si elles ne le faites pas, votre méthode lève une exception de toute façon (tout comme elle l'aurait fait si vous aviez vérifié les types). Mais sans la vérifier, votre méthode est soudain beaucoup plus souple. Vous pouvez passer un tableau, un texte, d'un fichier, ou tout autre objet qui ajoute à l'aide de <<, et il serait juste de travail.enter code here Vous n'avez pas besoin de vérifier le type des arguments. S'ils prennent en charge << (dans le cas de résultat) ou le titre et l'artiste (dans le cas de la chanson), tout simplement. Si elles ne le faites pas, votre méthode lève une exception de toute façon (tout comme elle l'aurait fait si vous aviez vérifié les types). Mais sans la vérifier, votre méthode est soudain beaucoup plus souple. Vous pouvez passer un tableau, un texte, d'un fichier, ou tout autre objet qui ajoute à l'aide de <<, et il serait juste de travail. Vous n'avez pas besoin de vérifier le type des arguments. S'ils prennent en charge << (dans le cas de résultat) ou le titre et l'artiste (dans le cas de la chanson), tout simplement. Si elles ne le faites pas, votre méthode lève une exception de toute façon (tout comme elle l'aurait fait si vous aviez vérifié les types). Mais sans la vérifier, votre méthode est soudain beaucoup plus souple. Vous pouvez passer un tableau, un texte, d'un fichier, ou tout autre objet qui ajoute à l'aide de <<, et il serait juste de travail.