En programación de computadores, o **tipado de pato** (**duck typing**) é un estilo de tipado dinámico no cal o conxunto de métodos e propiedades actuais dos obxectos determinan a sintaxe válida, fronte á herdanza dunha clase particular. O nome deste concepto refírese ó testeo pato, atribuído a James Whitcomb Riley, que se mostra de seguido:

*Se camiña coma un parrulo e fai o son coma os parrulos, entón pode chamárselle parrulo.*
O **duck typing** refírese só a aqueles aspectos do obxecto que está empregándose, fronte ós tipos de obxectos en si mesmos. Por exemplo, nunha linguaxe de tipado non-pato, un pode crear unha función que recolla un obxecto de tipo Pato e chamar os métodos camiña e cuaquea. Nunha linguaxe de tipo pato, a función equivalente podería recoller un obxecto de calquera tipo e chamar ós métodos de ese camiña e *cuaquea* de ese obxecto. Se o obxecto non ten os métodos que son chamados a función devolve un erro en tempo de execución. 
Esta acción de que calquera obxecto que teña e acepte os métodos camiña e *cuaquea* é o que evoca á mención e por iso recolle o nome do tipo pato.

Comparación con outros sistemas de tipado
-----------------------------------------

### Comparación con tipos de sistemas de tipado estruturais

O tipado Pato é similar, pero distínguese do tipado estruturado, xa que os tipos de esquemas de compatibilidade e equivalencia son determinados polo tipo de estrutura: onde o *duck typing* estea presente, o tipo de compatibilidade e equivalencia son determinados *só pola parte do tipo estruturado ó que se está accedendo*.

### Comparación con interfaces

As interfaces poden prover os mesmos beneficios do tipado pato pero o tipado pato distínguese en que non hai interfaces definidas explicitamente. Por exemplo, se unha libraría de terceiros Java implementa unha clase que non se permite modificar, non podes empregar unha instancia da clase no canto dunha interface que teñas definida por ti mesmo. O tipado pato permitirá facer isto.

### Comparación con modelos ou tipos 'universais'

As funcións modelo ou métodos ós que se lle aplica o testeo pato en contextos de tipado estático; isto recolle tódalas vantaxas e desvantaxas de tipado dinámico contra estático en xeral. O tipado Pato permite ser máis flexible que só cos métodos *actualmente chamados como en tempo de execución* que precisan ser implementados, mentres que os modelos requiren implementación de tódolos métodos que *non poidan ser comprobados inaccesiblemente en tempo de compilación*

O seguintes exemplos inclúen a linguaxe C++ con modelos, xeradores Java, e outros.

### En Python

En Python o tipado pato é moi empregado Python. O Python Tutorial's Glossary define o tipado pato como segue:

> 
> 
> O estilo de programación "Python" determina o tipo de obxecto mediante a inspección dos seus métodos ou firmas de atributos fronte a unha relación explícita ós tipos de obxectos ("Se semella coma un parrulo e fai o ruído dun parrulo, entón debe ser un parrulo."). Enfatizando nas interfaces fronte ós tipos específicos, o código ben deseñado impulsa a súa flexibilidade permitindo unha substitución polimórfica. O tipado Pato evita a comprobación `type()` ou `isinstance()`. No canto, normalmente leva a cabo a comprobación `hasattr()` ou programación*EAFP* (Easier to Ask Forgiveness than Permission - Máis doado pedir excusas có permiso).
> 
> 

O exemplo estándar do tipado pato en Python é a aparencia das clases. As clases poden implementar algúns ou tódolos métodos de `file` e poden ser empregados onde `file` poida ser empregado normalmente. Por exemplo, `GzipFile` implementa un obxecto semellante a file. Para acceder a datos comprimidos en gzip. `cStringIO` Permite tratar unha cadea Python coma un ficheiro. Sockets e ficheiros comparten a maioría dos métodos. Así e todo Socket contén o método `tell()` e non pode ser empregado no mesmo lugar que `GzipFile`. Isto mostra a flexibilidade do "duck typing": un obxecto que semella un ficheiro pode implementar só métodos para os que está capacitado e consecuentemente pode ser empregado en situacións onde é preciso.

### En Ruby

O tipado Pato é unha parte fundamental na codificación Ruby. O libro "Pickaxe" (Programming Ruby), escrito por Dave Thomas e Andrew Hunt, ten máis dunha descrición completa do tipado dinánimco, ademais de explicar os seus perigos e os seus beneficios.

### En Coldfusion

A linguaxe de programación de aplicacións web ColdFusion permite que os argumentos das funcións sexan especificados como o tipo *any*. Para este tipo de argumento, pode pasárselle un obxecto calquera e o método chamado vinculado dinamicamente en tempo de execución. Se un obxecto non implementa o método chamado, lánzase unha excepción a cal pódese recoller e manter correctamente.

### En Smalltalk

A linguaxe de programación orientada a obxectos Smalltalk non ten declaración de tipos para as variables ou para os argumentos dos métodos e polo tanto naturalmente suporta duck typing.
As clases que implementan o mesmo protocolo normalmente pertencen á mesma xerarquía de herdanza, pero non é requirida.

### En Objective-C

Objective-C, un cruzamento entre C e Smalltalk, permite a declaración de obxectos do tipo 'id' e enviarlle calquera mensaxe, coma Smalltalk. O emisor pode comprobar o obxecto para ver a que tipo de mensaxe responde, o obxecto pode decidir no momento de recepción da mensaxe se responde a ela ou non, se o emisor envía unha mensaxe que o receptor non poida responder, recóllese unha excepción. Isto é, o tipado dinámico está soportado completamente por Objective-C.

Véxase tamén
------------

### Ligazóns externas

* Tipado Pato: Ruby Arquivado 17 de xullo de 2011 en Wayback Machine.
* Como tipar Pato? - a psicoloxía do tipado estático en Ruby Arquivado 30 de agosto de 2011 en Wayback Machine.
* Tipado Pato no glosario da documentación en Python
* Dr. Dobbs June 01 2005: "Templates and Duck Typing"
* Javascript 'typeof' limitations and duck typing

|  |  |
| --- | --- |
| Control de autoridades | 
* Wd: Q374282
* MAG: 22811154

 |