Duck typing (original) (raw)
Duck-typing (anglická výslovnost [dak ˈtajpiŋ], česky kachní typování) je způsob dynamického typování, kdy se posuzuje objekt nikoli z hlediska jím deklarovaných předků nebo implementovaných rozhraní, ale jen na základě jeho metod.Původ systému je přisuzován větě Jamese Whitcomba Rileyho: „Pokud vidím ptáka, který chodí jako kachna, plave jako kachna a kváká jako kachna, tak o tomto ptáku tvrdím, že je to kachna.“
| Property | Value |
|---|---|
| dbo:abstract | Duck-typing (anglická výslovnost [dak ˈtajpiŋ], česky kachní typování) je způsob dynamického typování, kdy se posuzuje objekt nikoli z hlediska jím deklarovaných předků nebo implementovaných rozhraní, ale jen na základě jeho metod.Původ systému je přisuzován větě Jamese Whitcomba Rileyho: „Pokud vidím ptáka, který chodí jako kachna, plave jako kachna a kváká jako kachna, tak o tomto ptáku tvrdím, že je to kachna.“ (cs) تنويع البط (بالإنجليزية: Duck typing) في برمجة الحاسوب هي تطبيق لاختبار البط — «إذا كانت تمشي مثل البطة وتبطبط مثل البطة، فيجب أن تكون بطة» — لتحديد إمكانية استخدام كائن لغرض معين. بالتنويع العادي، يتم تحديد الملاءمة حسب نوع الكائن. في تنويع البط، يتم تحديد ملاءمة الكائن من خلال وجود طرق وخصائص معينة، بدلاً من نوع الكائن نفسه. (ar) Duck-Typing ist ein Konzept der objektorientierten Programmierung, bei dem der Typ eines Objektes nicht durch seine Klasse beschrieben wird, sondern durch das Vorhandensein bestimmter Methoden oder Attribute. Es handelt sich gewissermaßen um die Anwendung des Ententests in der Informatik, in Anlehnung an James Whitcomb Rileys Gedicht: “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” „Wenn ich einen Vogel sehe, der wie eine Ente läuft, wie eine Ente schwimmt und wie eine Ente schnattert, dann nenne ich diesen Vogel eine Ente.“ Duck-Typing ist charakteristisch für objektorientierte Skriptsprachen wie Python, Groovy, PHP und Ruby. Beim Duck-Typing wird zur Laufzeit des Programms geprüft, ob ein Objekt die entsprechenden Merkmale unterstützt. Dies führt wie bei allen dynamischen Typsystemen zu einer erhöhten Flexibilität, reduziert aber ebenso die Möglichkeit, statisch zur Übersetzungszeit Fehler im Programm zu finden. In Sprachen wie Java und D, sowie C# bis Version 3.0, ist es erforderlich, bei der Definition einer Klasse anzugeben, welche Interfaces implementiert werden sollen. Diese Sprachen erlauben es somit nicht, nach der Fertigstellung einer Klasse festzulegen, dass die Klasse zusätzlich noch ein anderes Interface implementiert (selbst wenn alle Methoden vorhanden sind, und die Objekte somit die gesamte Funktionalität schon bereitstellen). In C++ bieten Funktionstemplates eine Art Duck-Typing zur Kompilierzeit. Ältere GCC-Versionen boten daneben auch sogenannte Signatures an. Diese lassen sich wie Interfaces deklarieren und nutzen, sie sind jedoch unabhängig von der Klassenhierarchie, sodass beispielsweise für eine Ente nicht erneut deklariert werden muss, dass sie schnattern kann, also die Signature implementiert. Dies entspricht den Interface genannten Strukturen in Go. (de) Duck typing in computer programming is an application of the duck test—"If it walks like a duck and it quacks like a duck, then it must be a duck"—to determine whether an object can be used for a particular purpose. With nominative typing, an object is of a given type if it is declared to be (or if a type's association with the object is inferred through mechanisms such as object inheritance). In duck typing, an object is of a given type if it has all methods and properties required by that type. Duck typing can be viewed as a usage-based structural equivalence between a given object and the requirements of a type. See structural typing for a further explanation of structural type equivalence. (en) En programmation informatique, le duck typing (traduction : typage canard) est un style de typage dynamique de certains[Lesquels ?] langages de programmation orientés objet. En duck typing, la sémantique d'un objet, c'est-à-dire son type dans le contexte où il est utilisé, est déterminée par l'ensemble de ses méthodes et de ses attributs, et non, comme il l'est habituellement, par un type défini et nommé explicitement par le programmeur dans les systèmes à typage nominatif. C'est l'équivalent du typage structurel pour les langages à typage statique, comme OCaml. Le nom du système est une référence au test du canard (attribué à James Whitcomb Riley) : « Si je vois un oiseau qui vole comme un canard, cancane comme un canard, et nage comme un canard, alors j'appelle cet oiseau un canard ». Ainsi, un objet d'une classe A donnée peut être considéré pour certaines opérations comme un objet d'une autre classe B, totalement différente (il n'est justement pas nécessaire qu'il y ait héritage entre les deux classes), à condition que les méthodes et les attributs de B qui sont utilisés dans les opérations soient aussi présents dans A. En typage canard, le programmeur se concentre sur les caractéristiques des objets qui sont réellement utilisées plutôt que sur le type de l'objet lui-même. Par exemple, dans un langage typé nominativement, il peut créer une fonction qui prend en paramètre un objet de type Canard et utiliser ses méthodes marcher et cancaner. Dans un langage canard-typé, la fonction équivalente accepterait en paramètre un objet de n'importe quel type et appellerait ses méthodes marcher et cancaner. S'il s'avère à l'exécution que l'objet ne possède pas les méthodes qui sont appelées, la fonction lève une erreur d'exécution. (fr) En los lenguajes de programación orientados a objetos, se conoce como duck typing o tipado pato el estilo de tipificación dinámica de datos en que el conjunto actual de métodos y propiedades determina la validez semántica, en vez de que lo hagan la herencia de una clase en particular o la implementación de una interfaz específica. El nombre del concepto se refiere a la prueba del pato, una humorada de razonamiento inductivo atribuida a (ver más abajo), que pudo ser como sigue: "Cuando veo un ave que camina como un pato, nada como un pato y suena como un pato, a esa ave yo la llamo un pato." En duck typing, el programador solo se ocupa de los aspectos del objeto que van a usarse, y no del tipo de objeto que se trata. Por ejemplo en un lenguaje sin duck-typing uno puede crear una función que toma un objeto de tipo Pato y llama los métodos "caminar" y "parpar" de ese objeto. En un lenguaje con duck-typing, la función equivalente tomaría un objeto de cualquier tipo e invocaría los métodos caminar y parpar. Si el objeto tratado no tiene los métodos pedidos, la función enviará una señal de error en tiempo de ejecución. Este hecho de que la función acepte cualquier tipo de objeto que implemente correctamente los métodos solicitados es lo que evoca la cita precedente y da nombre a la forma de tipificación. El Duck typing usualmente es acompañado por el hábito de no probar el tipo de los argumentos en los métodos y funciones, y en vez de eso confiar en la buena documentación, el código claro y la prueba para asegurar el uso correcto. Los usuarios de lenguajes con tipificado estático al iniciarse con lenguajes de tipificado dinámico a menudo se ven tentados a agregar chequeos de tipo estáticos (previos a ejecución), desaprovechando la flexibilidad y beneficios del duck typing y restringiendo el dinamismo del lenguaje. (es) ダック・タイピング（英: duck typing）とは、Smalltalk、Perl、PHP、Python、Ruby、JavaScriptなどの動的型付けに対応したオブジェクト指向プログラミング言語に特徴的な、型付けのスタイル（作法）のひとつである。ダック・タイピングはポリモーフィズム（多態性）を実現する手段のひとつとして使われる。 Pythonのリファレンスでは、ダック・タイピングは「あるオブジェクトが正しいインタフェースを持っているかどうかを決定するために、オブジェクトの型を見ることはしないプログラミングスタイルである」と説明されている。代わりに、オブジェクトが持つメソッドや属性（フィールドまたはプロパティ）が単純に呼ばれたり使われたりする。特定の型よりもインタフェースを重視することで、うまく設計されたコードは、ポリモーフィックな代入の許可による柔軟性を向上する。 (ja) Nei linguaggi di programmazione orientati agli oggetti, il duck typing (lett. "tipizzazione ad anatra") si riferisce a uno stile di tipizzazione dinamica dove la semantica di un oggetto è determinata dall'insieme corrente dei suoi metodi e delle sue proprietà anziché dal fatto di estendere una particolare classe o implementare una specifica interfaccia. Il nome del concetto si riferisce al test dell'anatra attribuito a James Whitcomb Riley che può essere formulato come segue: «Quando vedo un uccello che cammina come un'anatra, nuota come un'anatra e starnazza come un'anatra, chiamo quell'uccello "anatra"». Nel duck typing si è interessati solo agli aspetti di un oggetto che sono usati invece che al tipo dell'oggetto stesso. Per esempio in un linguaggio non duck-tipizzato si può creare una funzione che prende un oggetto di tipo Anatra(duck) e chiama i metodi starnazza(quack) e cammina(walk) di quell'oggetto. In un linguaggio duck-tipizzato, la funzione equivalente avrebbe preso un oggetto di qualunque tipo e chiamato i metodi walk e quack di quell'oggetto. Se quindi l'oggetto non ha i metodi chiamati, la funzione segnala un errore in run-time. È quest'azione di ogni oggetto avente i corretti metodi quack e walk che vengono accettati dalla funzione che evoca la citazione e quindi il nome di questa forma di tipizzazione. Il duck typing è avvantaggiato abitualmente dal non dover testare per il tipo di argomento in metodi e corpi di funzione, basandosi sulla documentazione, codice pulito e prove per assicurare un uso corretto. Gli utenti che provengono da linguaggi tipizzati staticamente sono abitualmente tentati di aggiungere questo controllo statico dei tipi prima del run-time, reprimendo i benefici e la flessibilità del duck typing e vincolando il dinamismo del linguaggio. (it) 컴퓨터 프로그래밍 분야에서 덕 타이핑(duck typing)은 동적 타이핑의 한 종류로, 객체의 변수 및 메소드의 집합이 객체의 타입을 결정하는 것을 말한다. 클래스 상속이나 인터페이스 구현으로 타입을 구분하는 대신, 덕 타이핑은 객체가 어떤 타입에 걸맞은 변수와 메소드를 지니면 객체를 해당 타입에 속하는 것으로 간주한다. “덕 타이핑”이라는 용어는 다음과 같이 표현될 수 있는 덕 테스트에서 유래했다. (덕은 영어로 오리를 의미한다.) 만약 어떤 새가 오리처럼 걷고, 헤엄치고, 꽥꽥거리는 소리를 낸다면 나는 그 새를 오리라고 부를 것이다. 덕 타이핑에서는, 객체의 타입보다 객체가 사용되는 양상이 더 중요하다. 예를 들면, 덕 타이핑이 없는 프로그래밍 언어로는 오리 타입의 객체를 인자로 받아 객체의 걷기 메소드와 꽥꽥거리기 메소드를 차례로 호출하는 함수를 만들 수 있다. 반면에, 같은 함수를 덕 타이핑이 지원되는 언어에서는 인자로 받는 객체의 타입을 검사하지 않도록 만들 수 있다. 걷기 메소드나 꽥꽥거리기 메소드를 호출 할 시점에서 객체에 두 메소드가 없다면 런타임 에러가 발생하고, 두 메소드가 제대로 구현되어 있다면 함수는 정상적으로 작동한다. 여기에는 인자로 받은 객체가 걷기 메소드와 꽥꽥거리기 메소드를 갖고 있다면 객체를 오리 타입으로 간주하겠다는 암시가 깔려있다. 바로 이 점이 앞에서 인용한 덕 테스트의 사상과 일치하기 때문에 덕 타이핑이라는 이름이 붙었다. (ko) Duck typing – rozpoznawanie typu obiektu nie na podstawie deklaracji, ale przez badanie metod udostępnionych przez obiekt. Technika ta wywodzi się z powiedzenia: „jeśli chodzi jak kaczka i kwacze jak kaczka, to musi być kaczką”. Duck typing zazwyczaj wykorzystuje się w dynamicznych językach programowania takich jak Python, Ruby, Groovy czy JavaScript. W językach z typowaniem statycznym częściej stosuje się polimorfizm. (pl) Duck-typing is een term uit de informatica waarmee een bepaalde eigenschap van het type-systeem van een programmeertaal aangeduid wordt. In een programmeertaal met duck-typing is het mogelijk objecten aan te passen door nieuwe methoden of attributen aan deze objecten toe te voegen. (nl) Duck typing är ett koncept inom objektorienterad programmering. Det är en tillämpning av anktestet, det vill säga, om det går som en anka och kvackar som en anka då måste det vara en anka. Testet används för att avgöra om ett objekt kan användas i en viss operation. Vid normal typning bestäms lämpligheten av ett objekts datatyp. Vid duck typing bestäms ett objekts lämplighet av förekomsten av vissa metoder och egenskaper snarare än själva objektets datatyp. (sv) Неявная типизация, латентная типизация или утиная типизация (англ. Duck typing) в ООП-языках — определение факта реализации определённого интерфейса объектом без явного указания или наследования этого интерфейса, а просто по реализации полного набора его методов. (ru) Em programação de computadores com linguagens de programação orientadas a objetos, duck typing (em português literal tipagem pato) é um estilo de tipagem em que os métodos e propriedades de um objeto determinam a semântica válida, em vez de sua herança de uma classe particular ou implementação de uma interface explicita. O nome do conceito refere-se ao teste do pato, atribuído à (ver a história abaixo), que pode ser expressa como se segue: Quando eu vejo um pássaro que caminha como um pato, nada como um pato e grasna como um pato, eu chamo aquele pássaro de pato. (pt) 鸭子类型（英語：duck typing）在程序设计中是动态类型的一种风格。在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由「当前方法和属性的集合」决定。这个概念的名字来源于由提出的鸭子测试（见下面的“”章节），“鸭子测试”可以这样表述： “当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。” 在鸭子类型中，关注点在于对象的行为，能做什么；而不是关注对象所属的类型。例如，在不使用鸭子类型的语言中，我们可以编写一个函数，它接受一个类型为「鸭子」的对象，并调用它的「走」和「叫」方法。在使用鸭子类型的语言中，这样的一个函数可以接受一个任意类型的对象，并调用它的「走」和「叫」方法。如果这些需要被调用的方法不存在，那么将引发一个运行时错误。任何拥有这样的正确的「走」和「叫」方法的对象都可被函数接受的这种行为引出了以上表述，这种决定类型的方式因此得名。 鸭子类型通常得益于「不」测试方法和函数中参数的类型，而是依赖文档、清晰的代码和测试来确保正确使用。 在常规类型中，我们能否在一个特定场景中使用某个对象取决于这个对象的类型，而在鸭子类型中，则取决于这个对象是否具有某种属性或者方法——即只要具备特定的属性或方法，能通过鸭子测试，就可以使用。 (zh) Неявна типізація, латентна типізація або качина типізація (калька з англ. Duck typing) — різновид динамічної типізації, застосовуваної в деяких мовах програмування, коли межі використання об'єкта визначаються його поточним набором методів і властивостей, на противагу успадкуванню від певного класу. Тобто вважається, що об'єкт реалізує інтерфейс, якщо він містить всі методи цього інтерфейсу, незалежно від зв'язків в ієрархії наслідування та приналежності до якогось конкретного класу. Назва терміна походить від англійського «duck test» («качиний тест»), який в оригіналі звучить так: «If it looks like a duck, swims like a duck and quacks like a duck, then it probably is a duck».(«Якщо воно виглядає як качка, плаває як качка і крякає як качка, то це напевно і є качка»). Качина типізація вирішує такі проблеми ієрархічної типізації як: * неможливість явно вказати (шляхом наслідування) на сумісність інтерфейсу з усіма справжніми і майбутніми інтерфейсами, з якими він ідейно сумісний; * експоненціальне збільшення числа зв'язків в ієрархії типів при хоча б частковій спробі це зробити. Іншим близьким підходом є структурні підтипи в OCaml, де типи об'єктів сумісні, якщо сумісні сигнатури їхніх методів, незалежно від оголошеного наслідування, причому все це перевіряється під час компіляції програми. (uk) |
| dbo:wikiPageExternalLink | https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/invoke/MethodHandle.html |
| dbo:wikiPageID | 440018 (xsd:integer) |
| dbo:wikiPageLength | 6236 (xsd:nonNegativeInteger) |
| dbo:wikiPageRevisionID | 1124409947 (xsd:integer) |
| dbo:wikiPageWikiLink | dbr:Python_(programming_language) dbr:Method_(computer_programming) dbr:Nominative_typing dbr:Boo_(programming_language) dbr:Run_time_(program_lifecycle_phase) dbr:Generic_programming dbr:Object_(computer_science) dbr:Elm_(programming_language) dbr:Unreachable_code dbc:Articles_with_example_pseudocode dbr:Adapter_pattern dbr:TypeScript dbr:Type_system dbr:Duck_test dbr:D_(programming_language) dbr:Dynamic_programming_language dbr:Protocol_(object-oriented_programming) dbr:Java_(programming_language) dbc:Object-oriented_programming dbc:Articles_with_example_Python_(programming_language)_code dbc:Type_theory dbr:Template_metaprogramming dbr:Reflection_(computer_programming) dbr:Loose_coupling dbr:Extension_method dbr:Structural_type_system dbr:Monkey_patch dbr:Structural_typing dbr:Object_inheritance dbr:UFCS |
| dbp:wikiPageUsesTemplate | dbt:Reflist dbt:Short_description dbt:Type_systems |
| dcterms:subject | dbc:Articles_with_example_pseudocode dbc:Object-oriented_programming dbc:Articles_with_example_Python_(programming_language)_code dbc:Type_theory |
| gold:hypernym | dbr:Layer |
| rdf:type | dbo:AnatomicalStructure yago:Abstraction100002137 yago:ArtificialLanguage106894544 yago:Cognition100023271 yago:Communication100033020 yago:Concept105835747 yago:Content105809192 yago:Idea105833840 yago:Language106282651 yago:ProgrammingLanguage106898352 yago:PsychologicalFeature100023100 yago:WikicatProgrammingLanguageConcepts yago:WikicatProgrammingLanguages |
| rdfs:comment | Duck-typing (anglická výslovnost [dak ˈtajpiŋ], česky kachní typování) je způsob dynamického typování, kdy se posuzuje objekt nikoli z hlediska jím deklarovaných předků nebo implementovaných rozhraní, ale jen na základě jeho metod.Původ systému je přisuzován větě Jamese Whitcomba Rileyho: „Pokud vidím ptáka, který chodí jako kachna, plave jako kachna a kváká jako kachna, tak o tomto ptáku tvrdím, že je to kachna.“ (cs) تنويع البط (بالإنجليزية: Duck typing) في برمجة الحاسوب هي تطبيق لاختبار البط — «إذا كانت تمشي مثل البطة وتبطبط مثل البطة، فيجب أن تكون بطة» — لتحديد إمكانية استخدام كائن لغرض معين. بالتنويع العادي، يتم تحديد الملاءمة حسب نوع الكائن. في تنويع البط، يتم تحديد ملاءمة الكائن من خلال وجود طرق وخصائص معينة، بدلاً من نوع الكائن نفسه. (ar) Duck typing in computer programming is an application of the duck test—"If it walks like a duck and it quacks like a duck, then it must be a duck"—to determine whether an object can be used for a particular purpose. With nominative typing, an object is of a given type if it is declared to be (or if a type's association with the object is inferred through mechanisms such as object inheritance). In duck typing, an object is of a given type if it has all methods and properties required by that type. Duck typing can be viewed as a usage-based structural equivalence between a given object and the requirements of a type. See structural typing for a further explanation of structural type equivalence. (en) ダック・タイピング（英: duck typing）とは、Smalltalk、Perl、PHP、Python、Ruby、JavaScriptなどの動的型付けに対応したオブジェクト指向プログラミング言語に特徴的な、型付けのスタイル（作法）のひとつである。ダック・タイピングはポリモーフィズム（多態性）を実現する手段のひとつとして使われる。 Pythonのリファレンスでは、ダック・タイピングは「あるオブジェクトが正しいインタフェースを持っているかどうかを決定するために、オブジェクトの型を見ることはしないプログラミングスタイルである」と説明されている。代わりに、オブジェクトが持つメソッドや属性（フィールドまたはプロパティ）が単純に呼ばれたり使われたりする。特定の型よりもインタフェースを重視することで、うまく設計されたコードは、ポリモーフィックな代入の許可による柔軟性を向上する。 (ja) Duck typing – rozpoznawanie typu obiektu nie na podstawie deklaracji, ale przez badanie metod udostępnionych przez obiekt. Technika ta wywodzi się z powiedzenia: „jeśli chodzi jak kaczka i kwacze jak kaczka, to musi być kaczką”. Duck typing zazwyczaj wykorzystuje się w dynamicznych językach programowania takich jak Python, Ruby, Groovy czy JavaScript. W językach z typowaniem statycznym częściej stosuje się polimorfizm. (pl) Duck-typing is een term uit de informatica waarmee een bepaalde eigenschap van het type-systeem van een programmeertaal aangeduid wordt. In een programmeertaal met duck-typing is het mogelijk objecten aan te passen door nieuwe methoden of attributen aan deze objecten toe te voegen. (nl) Duck typing är ett koncept inom objektorienterad programmering. Det är en tillämpning av anktestet, det vill säga, om det går som en anka och kvackar som en anka då måste det vara en anka. Testet används för att avgöra om ett objekt kan användas i en viss operation. Vid normal typning bestäms lämpligheten av ett objekts datatyp. Vid duck typing bestäms ett objekts lämplighet av förekomsten av vissa metoder och egenskaper snarare än själva objektets datatyp. (sv) Неявная типизация, латентная типизация или утиная типизация (англ. Duck typing) в ООП-языках — определение факта реализации определённого интерфейса объектом без явного указания или наследования этого интерфейса, а просто по реализации полного набора его методов. (ru) Em programação de computadores com linguagens de programação orientadas a objetos, duck typing (em português literal tipagem pato) é um estilo de tipagem em que os métodos e propriedades de um objeto determinam a semântica válida, em vez de sua herança de uma classe particular ou implementação de uma interface explicita. O nome do conceito refere-se ao teste do pato, atribuído à (ver a história abaixo), que pode ser expressa como se segue: Quando eu vejo um pássaro que caminha como um pato, nada como um pato e grasna como um pato, eu chamo aquele pássaro de pato. (pt) 鸭子类型（英語：duck typing）在程序设计中是动态类型的一种风格。在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由「当前方法和属性的集合」决定。这个概念的名字来源于由提出的鸭子测试（见下面的“”章节），“鸭子测试”可以这样表述： “当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。” 在鸭子类型中，关注点在于对象的行为，能做什么；而不是关注对象所属的类型。例如，在不使用鸭子类型的语言中，我们可以编写一个函数，它接受一个类型为「鸭子」的对象，并调用它的「走」和「叫」方法。在使用鸭子类型的语言中，这样的一个函数可以接受一个任意类型的对象，并调用它的「走」和「叫」方法。如果这些需要被调用的方法不存在，那么将引发一个运行时错误。任何拥有这样的正确的「走」和「叫」方法的对象都可被函数接受的这种行为引出了以上表述，这种决定类型的方式因此得名。 鸭子类型通常得益于「不」测试方法和函数中参数的类型，而是依赖文档、清晰的代码和测试来确保正确使用。 在常规类型中，我们能否在一个特定场景中使用某个对象取决于这个对象的类型，而在鸭子类型中，则取决于这个对象是否具有某种属性或者方法——即只要具备特定的属性或方法，能通过鸭子测试，就可以使用。 (zh) Duck-Typing ist ein Konzept der objektorientierten Programmierung, bei dem der Typ eines Objektes nicht durch seine Klasse beschrieben wird, sondern durch das Vorhandensein bestimmter Methoden oder Attribute. Es handelt sich gewissermaßen um die Anwendung des Ententests in der Informatik, in Anlehnung an James Whitcomb Rileys Gedicht: “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” „Wenn ich einen Vogel sehe, der wie eine Ente läuft, wie eine Ente schwimmt und wie eine Ente schnattert, dann nenne ich diesen Vogel eine Ente.“ (de) En los lenguajes de programación orientados a objetos, se conoce como duck typing o tipado pato el estilo de tipificación dinámica de datos en que el conjunto actual de métodos y propiedades determina la validez semántica, en vez de que lo hagan la herencia de una clase en particular o la implementación de una interfaz específica. El nombre del concepto se refiere a la prueba del pato, una humorada de razonamiento inductivo atribuida a (ver más abajo), que pudo ser como sigue: (es) En programmation informatique, le duck typing (traduction : typage canard) est un style de typage dynamique de certains[Lesquels ?] langages de programmation orientés objet. En duck typing, la sémantique d'un objet, c'est-à-dire son type dans le contexte où il est utilisé, est déterminée par l'ensemble de ses méthodes et de ses attributs, et non, comme il l'est habituellement, par un type défini et nommé explicitement par le programmeur dans les systèmes à typage nominatif. C'est l'équivalent du typage structurel pour les langages à typage statique, comme OCaml. (fr) 컴퓨터 프로그래밍 분야에서 덕 타이핑(duck typing)은 동적 타이핑의 한 종류로, 객체의 변수 및 메소드의 집합이 객체의 타입을 결정하는 것을 말한다. 클래스 상속이나 인터페이스 구현으로 타입을 구분하는 대신, 덕 타이핑은 객체가 어떤 타입에 걸맞은 변수와 메소드를 지니면 객체를 해당 타입에 속하는 것으로 간주한다. “덕 타이핑”이라는 용어는 다음과 같이 표현될 수 있는 덕 테스트에서 유래했다. (덕은 영어로 오리를 의미한다.) 만약 어떤 새가 오리처럼 걷고, 헤엄치고, 꽥꽥거리는 소리를 낸다면 나는 그 새를 오리라고 부를 것이다. (ko) Nei linguaggi di programmazione orientati agli oggetti, il duck typing (lett. "tipizzazione ad anatra") si riferisce a uno stile di tipizzazione dinamica dove la semantica di un oggetto è determinata dall'insieme corrente dei suoi metodi e delle sue proprietà anziché dal fatto di estendere una particolare classe o implementare una specifica interfaccia. Il nome del concetto si riferisce al test dell'anatra attribuito a James Whitcomb Riley che può essere formulato come segue: «Quando vedo un uccello che cammina come un'anatra, nuota come un'anatra e starnazza come un'anatra, chiamo quell'uccello "anatra"». (it) Неявна типізація, латентна типізація або качина типізація (калька з англ. Duck typing) — різновид динамічної типізації, застосовуваної в деяких мовах програмування, коли межі використання об'єкта визначаються його поточним набором методів і властивостей, на противагу успадкуванню від певного класу. Тобто вважається, що об'єкт реалізує інтерфейс, якщо він містить всі методи цього інтерфейсу, незалежно від зв'язків в ієрархії наслідування та приналежності до якогось конкретного класу. Назва терміна походить від англійського «duck test» («качиний тест»), який в оригіналі звучить так: (uk) |
| rdfs:label | تنويع البط (ar) Duck-typing (cs) Duck-Typing (de) Duck typing (es) Duck typing (en) Duck typing (fr) Duck typing (it) 덕 타이핑 (ko) Duck-typing (nl) ダック・タイピング (ja) Duck typing (pl) Duck typing (pt) Утиная типизация (ru) Duck typing (sv) Качина типізація (uk) 鸭子类型 (zh) |
| owl:sameAs | freebase:Duck typing yago-res:Duck typing wikidata:Duck typing dbpedia-ar:Duck typing dbpedia-cs:Duck typing dbpedia-de:Duck typing dbpedia-es:Duck typing dbpedia-fa:Duck typing dbpedia-fr:Duck typing dbpedia-gl:Duck typing dbpedia-it:Duck typing dbpedia-ja:Duck typing dbpedia-ko:Duck typing http://ml.dbpedia.org/resource/ഡക്ക്_ടൈപ്പിംഗ് dbpedia-ms:Duck typing dbpedia-nl:Duck typing dbpedia-pl:Duck typing dbpedia-pt:Duck typing dbpedia-ru:Duck typing dbpedia-simple:Duck typing dbpedia-sv:Duck typing dbpedia-th:Duck typing dbpedia-tr:Duck typing dbpedia-uk:Duck typing dbpedia-zh:Duck typing https://global.dbpedia.org/id/3TWCv |
| prov:wasDerivedFrom | wikipedia-en:Duck_typing?oldid=1124409947&ns=0 |
| foaf:isPrimaryTopicOf | wikipedia-en:Duck_typing |
| is dbo:wikiPageRedirects of | dbr:Duck_Typing dbr:Duck_typed dbr:DuckTyping dbr:Duck_Type dbr:Duck_type |
| is dbo:wikiPageWikiLink of | dbr:Python_(programming_language) dbr:Ruby_(programming_language) dbr:Boo_(programming_language) dbr:Jsish dbr:Phalanger_(compiler) dbr:Urbiscript dbr:Intersection_type dbr:Null_object_pattern dbr:Crystal_(programming_language) dbr:Rust_(programming_language) dbr:SPARQL dbr:Generic_programming dbr:Python_syntax_and_semantics dbr:Elixir_(programming_language) dbr:Go_(programming_language) dbr:Apache_Groovy dbr:Lua_(programming_language) dbr:Bogus_(Ruby) dbr:StarLogo dbr:Function_object dbr:Polymorphism_(computer_science) dbr:TypeScript dbr:Type_Tunnel_pattern dbr:Type_system dbr:Late_binding dbr:Latent_typing dbr:ALGOL_68 dbr:ECMAScript dbr:Flapjax dbr:Nuitka dbr:Flow-sensitive_typing dbr:Iterator dbr:Protocol_(object-oriented_programming) dbr:Harbour_(programming_language) dbr:JScript dbr:JScript_.NET dbr:JavaScript dbr:Covariance_and_contravariance_(computer_science) dbr:Abstract_syntax_tree dbr:Abstract_type dbr:Lasso_(programming_language) dbr:Duck_Typing dbr:Duck_typed dbr:Mock_trainwreck dbr:Modern_C++_Design dbr:C_Sharp_4.0 dbr:PicoLisp dbr:Pnuts dbr:Source_(programming_language) dbr:MetaPost dbr:Oberon-2 dbr:Railo dbr:SenseTalk dbr:XRuby dbr:Virtual_method_table dbr:Netstring dbr:Extension_method dbr:Extensionality dbr:Structural_type_system dbr:Subtyping dbr:Strong_and_weak_typing dbr:Polymorphic_association dbr:Uniform_Function_Call_Syntax dbr:DuckTyping dbr:Duck_Type dbr:Duck_type |
| is dbp:typing of | dbr:Ruby_(programming_language) dbr:Boo_(programming_language) dbr:Jsish dbr:Urbiscript dbr:Crystal_(programming_language) dbr:Elixir_(programming_language) dbr:Apache_Groovy dbr:Lua_(programming_language) dbr:StarLogo dbr:TypeScript dbr:Flapjax dbr:JScript dbr:JScript_.NET dbr:JavaScript dbr:PicoLisp dbr:Pnuts dbr:Source_(programming_language) dbr:MetaPost dbr:SenseTalk |
| is rdfs:seeAlso of | dbr:Polymorphism_(computer_science) |
| is owl:differentFrom of | dbr:Duct_tape |
| is foaf:primaryTopic of | wikipedia-en:Duck_typing |