什么是鸭子打字？

Question

鸭子打字在软件开发中意味着什么？

Answer 1

它是在没有 强类型。

这个想法是，您不需要指定类型来调用对象上的现有方法 - 如果在其上定义了方法，您就可以调用它。

这个名字来源于一句话“如果它看起来像鸭子并且嘎嘎叫起来像鸭子，那么它就是鸭子”。

维基百科有更多信息。

Answer 2

鸭子打字
意味着操作没有正式指定其操作数必须满足的要求，而只是用给定的内容尝试。

与其他人所说的不同，这不一定与动态语言或继承问题有关。

示例任务：在对象上调用一些方法Quack。

如果不使用鸭子类型，执行此任务的函数f必须提前指定其参数必须支持某种方法Quack。一种常见的方法是使用接口

interface IQuack { 
    void Quack();
}

void f(IQuack x) { 
    x.Quack(); 
}

调用 f(42) 失败，但只要 donald 是一个实例，f(donald) 就可以工作IQuack 子类型。

另一种方法是结构类型 - 但同样，方法Quack()被正式指定为任何不能提前证明它是quack的东西都会导致编译器失败。

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

我们甚至可以用 Haskell 编写

f :: Quackable a => a -> IO ()
f = quack

，其中 Quackable 类型类确保我们方法的存在。

---

So how does **duck typing** change this?

嗯，正如我所说，鸭子类型系统没有指定要求，但只是尝试是否有效。

因此，像 Python 这样的动态类型系统总是使用鸭子类型：

def f(x):
    x.Quack()

如果 f 得到一个支持 Quack() 的 x，那么一切都很好，如果不，它会在运行时崩溃。

但鸭子类型根本不意味着动态类型 - 事实上，有一种非常流行但完全静态的鸭子类型方法，它也没有给出任何要求：

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

该函数不会以任何方式表明它需要一些 x 可以Quack，所以它只是在编译时尝试，如果一切正常，那就没问题了。

Answer 3

简单解释

什么是鸭子类型？

“如果它像鸭子一样行走，像......等一样嘎嘎叫” - 是的，但这是什么意思？？！

我们对“物体”感兴趣能做什么，而不是他们是什么。

让我们用一个例子来解压它：

有关更多详细信息，请参阅下文：

Duck Typing 功能示例：

想象我有一根魔杖。它具有特殊的权力。如果我挥动魔杖并对一辆车说“开车！”，那么它就会开车了！

对其他事情也有效吗？不确定：所以我在卡车上尝试一下。哇——它也能开车！然后我在飞机、火车和 1 Woods 上尝试（它们是一种人们用来“击球”高尔夫球的高尔夫球杆）。 他们都开车！

但是它能用在茶杯上吗？错误：KAAAA-BOOOOOOM！结果不太好。 ====>茶杯不能开车！！呃！？

这基本上就是鸭子类型的概念。这是一个先试后买系统。如果有效的话，一切都好。但如果失败了，就像手榴弹还在你手里一样，它就会在你脸上爆炸。

换句话说，我们感兴趣的是对象可以做什么，而不是对象是什么。

C# 或 Java 等语言怎么样？

如果我们关心对象实际上是什么，那么我们的魔术将只对预设的、授权的类型起作用 - 在本例中是汽车，但对其他可以驾驶的对象将失败：卡车、轻便摩托车、嘟嘟车等。它不适用于卡车，因为我们的魔杖预计它仅适用于汽车。

换句话说，在这种情况下，魔杖非常仔细地观察对象是什么（它是汽车吗？），而不是对象可以做什么（例如是否汽车、卡车等都可以驾驶）。

让卡车开起来的唯一方法是，如果你能以某种方式让魔杖同时期待卡车和汽车（也许通过“实现通用接口”）。这可以通过一种称为“多态性”的技术或使用“接口”来完成 - 它们有点相同。如果您喜欢卡通并需要解释，请查看我的界面卡通。

摘要：关键要点

在鸭子类型中，重要的是对象实际上可以做什么，而不是对象是什么。

代码示例

但是高尔夫球杆如何能像汽车一样“驾驶”呢？他们不一样吗？如果您使用像 Ruby 这样的语言，我们不关心对象是什么：

class Car
   def drive
      "I"m driving a Car!"
   end
end

class GolfClub
   def drive
      "I"m driving a golf club!"
   end 
end

def test_drive(item)   
   item.drive # don't care what it is, all i care is that it can "drive"
end

car = Car.new
test_drive(car) #=> "I'm driving a Car"

club = GolfClub.new
test_drive(club) #=> "I"m driving a GolfClub"

# welcome to duck typing!

PS。我想删掉学术上的废话：这个答案并不科学，但希望它能让你通过类比对正在发生的事情有一个模糊的理解。

聚苯硫醚。如果你想笑并且有空闲时间，请查看：Matt Damon 在善意狩猎中对鸭子打字的解释；）

Answer 4

假设您正在设计一个简单的函数，该函数获取 Bird 类型的对象并调用其 walk() 方法。您可以想到两种方法：

1. 这是我的函数，我必须确保它只接受 Bird 类型，否则代码将无法编译。如果有人想使用我的函数，他们必须知道我只接受Bird。
2. 我的函数获取任何对象，我只需调用该对象的walk() 方法。因此，如果对象可以walk()那么它是正确的。如果不能，我的功能就会失败。因此，这里对象是Bird还是其他东西并不重要，重要的是它可以walk()（这是鸭子打字）。

必须考虑到，鸭子打字在某些情况下可能很有用。例如，Python 经常使用鸭子类型。

---

有用的阅读

• 有一些关于 Java、Python、JavaScript 的鸭子类型的好例子
  等https://en.wikipedia.org/wiki/Duck_typing。
• 这也是一个很好的答案，它描述了动态的优点
  打字及其缺点：什么是动态类型的所谓生产力提升？

Answer 5

我看到很多答案都重复了老套路：

如果它看起来像鸭子并且嘎嘎叫起来像鸭子，那么它就是鸭子

，然后深入解释如何使用鸭子类型，或者一个似乎进一步混淆概念的示例。

我没有找到那么多帮助。

这是我发现的关于鸭子类型的简单英语答案的最佳尝试：

鸭子类型意味着一个对象是由它可以做什么来定义的，而不是由

这意味着我们不太关心对象的类/类型，而更关心可以对其调用哪些方法以及可以对其执行哪些操作。 我们不关心它的类型，我们关心它能做什么。

Answer 6

别做庸医；我支持你：

“鸭子打字” := “尝试方法，不要检查类型”

_{注意：:= 可以读作 “定义为”。}

“鸭子类型”的意思是：只需在传入的任何对象上尝试方法（函数调用），而不是首先检查对象的类型看看该方法是否是对此类类型的有效调用。

我们将其称为“尝试方法，不要检查类型”输入，“方法调用”类型检查”，或者简称为“方法调用类型”。

在下面的较长解释中，我将更详细地解释这一点，并帮助您理解“鸭子打字”这个荒谬、深奥且令人困惑的术语。

---

更长的解释：

死

Answer 7

维基百科有一个相当详细的解释：

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

鸭子打字是一种动态风格
输入当前对象的位置
方法和属性集
确定有效的语义，而不是
比它从特定的继承
特定的类或实现
界面。

重要的一点是，对于鸭子类型，开发人员可能更关心所使用的对象的部分，而不是实际的底层类型。

Answer 8

马特·达蒙在《善意狩猎

记录》中解释了鸭子打字如下。 视频链接位于此处。。

CHUCKIE：好吧，我们会有问题吗？

克拉克：没问题。我只是希望你能给我一些关于鸭子打字实际上是什么的见解？我的观点是鸭子绑定没有明确定义，强

WILL: [interrupting] 也没有明确定义……强类型也没有明确定义。当然这是你的论点。你是一年级研究生：你刚刚读完一些关于鸭子打字的文章，可能是在 Rails 论坛上，你会确信这一点，直到下个月你到达四人帮，然后你我们将讨论 Google Go 和 Ocaml 如何成为具有结构子绑定结构的统计类型语言。这种情况会持续到明年，直到您可能会在这里反复回忆 Matz，谈论 Ruby 3.0 之前的乌托邦以及 GC 上子类型的内存分配效果。

CLARK：[大吃一惊]事实上我不会，因为 Matz 大大低估了 -

WILL 的影响：“Matz 大大低估了 Ruby 3.0 的 GC 对性能的影响。你是从 Donald Knuth 那里得到的，《计算机编程的艺术》，第 98 页，对吗？是的，我也读过这句话，你是否打算为我们抄袭整个内容——你自己对此事有什么想法吗？你的东西，你进入堆栈溢出，你读了一些关于 r/ruby 的晦涩难懂的文章，然后你假装，你把它当作你自己的——你自己的想法只是为了给一些女孩留下深刻的印象，让我的朋友难堪

？

意志：看到像你这样的人的悲伤之处在于，大约 50 年后，你将开始自己进行一些思考，然后你会发现以下事实：存在三个确定性第一，不要这样做。第二，如果它像鸭子一样行走，那么它就是鸭子。第三，你在通过堆栈溢出答案可以得到的教育上投入了一百五十美元。本·科希。

CLARK：是的，但我会获得学位，并且在我们去滑雪旅行的路上，您将通过在得来速餐厅的 React 为我的孩子们提供一些便宜的 html。

WILL：[微笑]是的，也许吧。但至少我不会没有原创性。

（稍顿）

WILL：你有问题³吗？我想我们可以出去解决问题。

克拉克：没问题

一段时间后：

威尔：你喜欢苹果吗？

克拉克就像，是吧？

威尔：你喜欢这些苹果吗？ （砰：威尔将一封信猛地撞在窗户上。）我必须接受谷歌的报价！ （向克拉克展示了录取通知书，其中显示了他的面试答案：一张鸭子行走、说话、行为像鹅的照片。）

滚动积分。

结束。

（这是旧答案的脚注：）

³代码问题的出现。

Answer 9

我知道我没有给出笼统的答案。在 Ruby 中，我们不声明变量或方法的类型——一切都只是某种对象。
所以规则是“类不是类型”

在 Ruby 中，类永远不是（好吧，几乎永远不是）类型。相反，对象的类型更多地由该对象可以执行的操作来定义。在 Ruby 中，我们称之为鸭子类型。如果一个物体像鸭子一样走路并且像鸭子一样说话，那么解释器很乐意将其视为鸭子。

例如，您可能正在编写一个例程来将歌曲信息添加到字符串中。如果您有 C# 或 Java 背景，您可能会想这样写：

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)"

拥抱 Ruby 的鸭子类型，您会写出更简单的东西：

def append_song(result, song)
    result << song.title << " (" << song.artist << ")"
end

result = ""
append_song(result, song) # => "I Got Rhythm (Gene Kelly)"

您不需要检查参数的类型。如果他们支持<< （就结果而言）或标题和艺术家（就歌曲而言），一切都会正常进行。如果不这样做，您的方法无论如何都会抛出异常（就像检查类型时会发生的情况一样）。但如果没有检查，你的方法突然变得更加灵活。您可以向它传递一个数组、一个字符串、一个文件或使用 << 附加的任何其他对象，它就会正常工作。

Answer 10

看看语言本身可能会有所帮助；它经常对我有帮助（我的母语不是英语）。

在鸭子打字中：

1）打字这个词并不意味着在键盘上打字（就像我脑海中持久的图像一样），它意味着确定“什么类型一个东西的就是那个东西？”

2）duck这个词表达了如何确定；这是一种“松散”的确定，例如：“如果它像鸭子一样行走......那么它就是鸭子”。它是“松散的”，因为这个东西可能是鸭子，也可能不是，但它是否真的是鸭子并不重要；它是鸭子。重要的是我可以用它做我能用鸭子做的事情，并期望鸭子表现出的行为。我可以给它喂面包屑，它可能会朝我冲过来，或者冲向我，或者后退……但它不会像灰熊那样吞噬我。

Answer 11

鸭子打字：

如果它像鸭子一样说话和走路，那么它就是鸭子

这通常称为溯因（溯因推理，也称为逆向，一种更清晰的推理我认为的定义）：

• 来自C（结论，我们所看到的）和R（规则，我们所知道的< /em>），我们接受/决定/假设P（前提，属性）换句话说是给定的事实

  ...医学诊断的基础

  与鸭子：C = 走路、说话、R = 像鸭子、P = 这是一只鸭子

  ，

回到编程：

• 对象o有方法/属性mp1和接口/输入T
  需要/定义mp1

• 对象 o 具有方法/属性 mp2 和接口/类型 T 需要/定义mp2

• ...

因此，不仅仅是在任何对象上接受 mp1...，只要它满足 的某些定义mp1...，编译器/运行时也应该可以接受断言 o 的类型为 T

那么，上面的示例是否属于这种情况？ Duck 打字本质上根本就不是打字吗？或者我们应该称之为隐式类型？

Answer 12

鸭子打字不是类型提示！

基本上，为了使用“鸭子类型”，您不会通过使用通用接口来针对特定类型，而是针对更广泛的子类型（不是谈论继承，当我指的是子类型时，我指的是适合相同配置文件的“事物”） 。

您可以想象一个存储信息的系统。为了写入/读取信息，您需要某种存储和信息。

存储类型可能是：文件、数据库、会话等。

无论存储类型如何，该界面都会让您知道可用的选项（方法），这意味着此时还没有实现任何内容！换句话说，接口对如何存储信息一无所知。

每个存储系统都必须通过实现完全相同的方法来知道该接口的存在。

interface StorageInterface
{
   public function write(string $key, array $value): bool;
   public function read(string $key): array;
}


class File implements StorageInterface
{
    public function read(string $key): array {
        //reading from a file
    }

    public function write(string $key, array $value): bool {
         //writing in a file implementation
    }
}


class Session implements StorageInterface
{
    public function read(string $key): array {
        //reading from a session
    }

    public function write(string $key, array $value): bool {
         //writing in a session implementation
    }
}


class Storage implements StorageInterface
{
    private $_storage = null;

    function __construct(StorageInterface $storage) {
        $this->_storage = $storage;
    }

    public function read(string $key): array {
        return $this->_storage->read($key);
    }

    public function write(string $key, array $value): bool {
        return ($this->_storage->write($key, $value)) ? true : false;
    }
}

所以现在，每次您需要写入/读取信息时：

$file = new Storage(new File());
$file->write('filename', ['information'] );
echo $file->read('filename');

$session = new Storage(new Session());
$session->write('filename', ['information'] );
echo $session->read('filename');

在此示例中，您最终会在存储构造函数中使用 Duck Typing：

function __construct(StorageInterface $storage) ...

希望它有所帮助；）

Answer 13

使用鸭子打字技术进行树遍历

def traverse(t):
    try:
        t.label()
    except AttributeError:
        print(t, end=" ")
    else:
        # Now we know that t.node is defined
        print('(', t.label(), end=" ")
        for child in t:
            traverse(child)
        print(')', end=" ")

Answer 14

在编程中，类型可以分为名义类型和结构类型。名义类型考虑类型的整个结构。那么从谁那里继承的等等。它们显然比结构类型更复杂。例如，在 C# 和 Java 中，一种使用名义类型。

结构类型根本不考虑这些点。对于结构类型，只有单一类型的结构很重要。那么它看起来怎么样。以一个类为例。它是否具有相同的参数和预期的类型。这称为鸭子打字。鸭子打字起源于鸭子测试。

Dugtest 的意思是：如果某物看起来像鸭子。如果它像鸭子一样游泳。如果它像鸭子一样嘎嘎叫。那么它就是一只鸭子。相反：如果测试用例不适用，那么它就不是鸭子。 (https://en.wikipedia.org/wiki/Duck_test)

Answer 15

我认为混合动态类型、静态类型和鸭子类型是很混乱的。鸭子类型是一个独立的概念，甚至像 Go 这样的静态类型语言也可以有一个实现鸭子类型的类型检查系统。如果类型系统将检查（声明的）对象的方法而不是类型，那么它可以称为鸭子类型语言。

Answer 16

鸭子打字这个术语是一个谎言<​​/strong>。

你会看到这句成语“如果它走起来像鸭子，嘎嘎叫起来像鸭子，那么它就是鸭子。”这句话在这里一次又一次地重复。

但这不是鸭子类型（或者我们通常所说的鸭子类型）我们所讨论的鸭子打字就是试图对某物施加命令，无论它是什么，但并不能推断该物体是否是一个物体。 对于真正

的鸭子类型，请参阅类型类。
现在遵循这样的成语：“如果它像鸭子一样行走，像鸭子一样嘎嘎叫，那么它就是鸭子。”对于类型类，如果一个类型实现了类型类定义的所有方法，那么它可以被视为成员因此，如果有一个类型类 Duck 定义了某些方法（quack 和 walk-like-duck），则任何实现这些相同方法的都可以被视为 Duck（无需继承该类型类）。需要继承Duck）。

Answer 17

在鸭子类型中，对象的适用性（例如，在函数中使用）是根据是否实现了某些方法和/或属性来确定的，而不是根据该对象的类型来确定的。

例如，在 Python 中，len 函数可以与实现 __len__ 方法的任何对象一起使用。它不关心该对象是否属于某种类型，例如字符串、列表、字典或 MyAwesomeClass，只要这些对象实现了 __len__ 方法，len 将与他们。

class MyAwesomeClass:
    def __init__(self, str):
        self.str = str
    
    def __len__(self):
        return len(self.str)

class MyNotSoAwesomeClass:
    def __init__(self, str):
        self.str = str

a = MyAwesomeClass("hey")
print(len(a))  # Prints 3

b = MyNotSoAwesomeClass("hey")
print(len(b))  # Raises a type error, object of type "MyNotSoAwesomeClass" has no len()

换句话说，MyAwesomeClass 看起来像鸭子，并且嘎嘎叫，因此是鸭子，而 MyNotSoAwesomeClass 看起来不像鸭子，也不会嘎嘎叫，因此不是鸭子！

Answer 18

鸭子类型：

let anAnimal 

if (some condition) 
  anAnimal = getHorse()
else
  anAnimal = getDog()

anAnimal.walk()

上面的函数调用在结构类型中不起作用

以下将适用于结构类型：

IAnimal anAnimal

if (some condition) 
      anAnimal = getHorse()
    else
      anAnimal = getDog()
    
anAnimal.walk()

仅此而已，我们中的许多人已经知道鸭子类型是直观的。

Answer 19

我尝试以我的方式理解这句名言：
“Python 并不关心对象是否是真正的鸭子。
它所关心的是对象是否，首先是“嘎嘎”，其次是“像鸭子”。”

有一个很好的网站。 http://www.voidspace.org.uk/python/articles/duck_typing.shtml#id14

作者指出，鸭子类型可以让你创建自己的类，这些类具有
它们自己的内部数据结构 - 但可以使用正常的 Python 语法进行访问。