什么是鸭子打字？

我知道我没有给出笼统的答案。在 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)"

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

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

在 duck typing 中：

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

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

鸭打字：

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

这通常称为溯因（溯因推理或也称为追溯，我认为这是一个更清晰的定义）：

从 C（结论，我们看到的）和 R（规则，我们知道的），我们接受/决定/假设 P（前提，属性），换句话说，一个给定的事实……鸭子医学诊断的基础：C = 走路，说话，R = 像一只鸭子，P = 它是一只鸭子

回到编程：

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

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

...

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

那么，上面的例子就是这样吗？ Duck 打字本质上是不打字吗？或者我们应该称之为隐式类型？

Duck Typing 不是 Type Hinting！

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

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

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

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

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

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');

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

function __construct(StorageInterface $storage) ...

希望它有所帮助；）

使用鸭子类型技术的树遍历

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

我认为将动态类型、静态类型和鸭子类型混为一谈会让人感到困惑。鸭子类型是一个独立的概念，甚至像 Go 这样的静态类型语言也可以有一个实现鸭子类型的类型检查系统。如果类型系统将检查（声明的）对象的方法而不检查类型，则可以将其称为鸭子类型语言。

鸭子打字这个词是一个谎言。

您会看到“如果它像鸭子一样走路，像鸭子一样嘎嘎叫，那么它就是鸭子。”这句话在这里一次又一次地重复。

但这不是鸭式打字（或我们通常所说的鸭式打字）的意义所在。我们正在讨论的所有 Duck Typing 都是关于试图对某些东西强制执行命令。看东西是不是嘎嘎，不管它说的是什么。但是没有推论该对象是否是鸭子。

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

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

例如，在 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 看起来不像鸭子，也不叫，因此不是鸭子！

鸭子打字：

let anAnimal 

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

anAnimal.walk()

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

以下将适用于结构类型：

IAnimal anAnimal

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

就是这样，我们中的许多人已经直观地知道鸭式打字。

善意狩猎 - 马特达蒙鸭打字场景

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

克拉克：没问题。我只是希望你能给我一些关于什么是鸭子打字的见解？我的论点是打鸭式没有很好的定义，也不是很牢固

威尔：[打断]……强类型也不是。当然这是你的论点。你是一名一年级的研究生：你刚刚读完一些关于鸭子打字的文章，可能是在 StackOverflow 上，直到下个月当你到达四人帮时，你才会相信这一点，然后你就会将谈论 Google Go 和 Ocaml 如何成为具有结构子绑定结构的统计类型语言。这将持续到明年，直到你可能会在这里反刍 Matz，谈论你知道的 Pre-Ruby 3.0 乌托邦和子类型对 GC 的内存分配影响。

克拉克：[吃惊]事实上我不会，因为马茨严重低估了——

WILL：“Matz 大大低估了 Ruby 3.0 的 GC 对性能的影响。你从 Donald Knuth，计算机编程的艺术，第 98 页得到的，对吗？是的，我也读过。你会为我们剽窃整个事情吗？ ——你对这件事有什么——你自己的想法吗？或者——那是你的事吗，你陷入了一个松弛的线程，你读了一些关于 r/ruby 的晦涩的段落，然后你假装，你把它当成你自己的——你自己的想法只是为了给一些女孩留下好印象，让我的朋友难堪？

[克拉克惊呆了]

威尔：看到像你这样的人的可悲之处在于，大约 50 年后你会开始自己思考，你会想出生活中有三个确定性的事实。一，不要那样做。第二，如果它像鸭子一样走路，那么它就是鸭子。第三，您通过 Ben Koshy 的堆栈溢出答案以零美分获得的教育投入了 150 美元。

克拉克：是的，但是我将获得学位，并且您将通过在我们去滑雪旅行的路上通过汽车的反应为我的孩子提供一些便宜的 html。

威尔：[微笑]是的，也许吧。但至少我不会是非原创的。

（一拍）

威尔：你对此有意见吗？我想我们可以走出去做一些代码练习吗？

克拉克：没问题

一段时间以后：

威尔：你喜欢苹果吗？

克拉克不知所措。嗯？

威尔：你喜欢他们的苹果吗？ （Boom：Will 将一封信砸在窗户上。）我必须得到 Google 的报价！ （给克拉克的录取通知书显示了他的面试答案：对冒泡排序算法的正确回答和鸭子走路的图片）

结束

（这是 old answer here 的脚注：）

我试图以我的方式理解这句著名的句子：“Python 不在乎一个对象是否是真正的鸭子。它只关心对象是否，首先是“嘎嘎”，其次是“像鸭子”。

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

作者指出，duck typing 让您可以创建自己的类，这些类具有自己的内部数据结构——但可以使用普通的 Python 语法进行访问。