1. 鸭子类型(Duck Typing)
    2. duck typing 是动态类型的一种风格，是多态（polymorphism）的一种形式
    3. 鸭子类型是动态编程语言中常见的概念，而 ts 是静态类型的，但 ts 中的结构化类型系统可以模拟鸭子类型
    4. 一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由”当前方法和属性的集合”决定
    5. 可以这样表述：”当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”
    6. 在鸭子类型中，关注点在于对象的行为能做什么，而不是关注对象所属的类型
    7. 例如，在不使用鸭子类型的语言中，我们可以编写一个函数，它接受一个类型为”鸭子”的对象，并调用它的”走”和”叫”方法。在使用鸭子类型的语言中，这样的一个函数可以接受一个任意类型的对象，并调用它的”走”和”叫”方法。如果这些需要被调用的方法不存在，那么将引发一个运行时错误。任何拥有这样的正确的”走”和”叫”方法的对象都可被函数接受的这种行为引出了以上表述，这种决定类型的方式因此得名。
    1. interface IPoint {
    2.   x: number
    3.   y: number
    4. }
    5. function addPoints(p1: IPoint, p2: IPoint): IPoint {
    6.   var x = p1.x + p2.x
    7.   var y = p1.y + p2.y
    8.   return { x: x, y: y }
    9. }
    11. // 正确
    12. var newPoint = addPoints({ x: 3, y: 4 }, { x: 5, y: 1 })
    14. // 错误
    15. var newPoint2 = addPoints({ x: 1 }, { x: 4, y: 3 })
    16. // 报错：
    17. // 类型“{ x: number; }”的参数不能赋给类型“IPoint”的参数。
    18. // 类型 "{ x: number; }" 中缺少属性 "y"，但类型 "IPoint" 中需要该属性。ts(2345)
    1. // 定义一个表示"能叫和走的动物"的接口
    2. interface IDuck {
    3.   walk(): void;
    4.   quack(): void;
    5. }
    7. // 定义一个鸭子类
    8. class Duck implements IDuck {
    9.   walk() {
    10.     console.log("The duck waddles.");
    11.   }
    12.   quack() {
    13.     console.log("The duck quacks.");
    14.   }
    15. }
    17. // 定义一个人类，注意这里并没有明确实现IDuck接口，但它有walk和quack方法
    18. class Person {
    19.   walk() {
    20.     console.log("The person walks.");
    21.   }
    22.   quack() {
    23.     console.log("The person imitates a duck.");
    24.   }
    25. }
    27. // 这个函数需要一个IDuck类型的参数，但是鸭子类型允许我们传入任何有walk和quack方法的对象
    28. function makeItQuack(duck: IDuck) {
    29.   duck.walk();
    30.   duck.quack();
    31. }
    33. const duck = new Duck();
    34. const person = new Person();
    36. makeItQuack(duck);
    37. // The duck waddles.
    38. // The duck quacks.
    40. makeItQuack(person);
    41. // The person walks.
    42. // The person imitates a duck.