代码之家  ›  专栏  ›  技术社区  ›  Steven A. Lowe

duck类型与旧的“variant”类型和/或接口有何不同?

  •  44
  • Steven A. Lowe  · 技术社区  · 18 年前

    忙着做我自己的研究,有人能简单地告诉我:

    • “duck类型”和旧skool“variant类型”之间的区别,以及
    • 有 使用duck类型来完成?

    duck typing illustration courtesy of The Register

    我并不想因为怀疑这个“新”结构的力量而显得像禽鸟,我也不是因为拒绝做研究而回避这个问题,但我最近看到的关于它的蜂拥而至的炒作让我大吃一惊。看起来像 不

    附录:感谢迄今为止的示例。在我看来,使用类似“O-”的东西;can(Blah)'相当于执行反射查找(这可能不便宜),和/或与表示(O是IBlah)大致相同,编译器可能可以为您检查(O是IBlah),但后者的优点是将我的IBlah接口与您的IBlah接口区分开来,而其他两个接口则没有。诚然,每个方法都有很多微小的接口,这会让事情变得一团糟,但检查许多单独的方法也是如此。。。

    …所以我还是不明白。它是一个神奇的省时工具,还是一个崭新的袋子里装着同样的旧东西?哪里有这样的例子 要求 鸭子打字?

    10 回复  |  直到 9 年前
        1
  •  32
  •   Tim Rutter    7 年前

    在这里的一些答案中,我看到一些术语的错误使用,这导致人们提供错误的答案。

    因此,在我给出答案之前,我将提供一些定义:

    1. 大多数语言都具有“progress”属性。然而,有许多不符合“保全”财产的要求。一个很好的例子,是C++(和C)。例如,在C++中强制任何内存地址都可以表现为它是任何类型的。这基本上允许程序员随时违反类型系统。下面是一个简单的例子:

      struct foo
      {
          int x;
          iny y;
          int z;
      }
      
      char * x = new char[100];
      foo * pFoo = (foo *)x;
      foo aRealFoo;
      *pFoo = aRealFoo;
      

    2. 弱类型

    3. 如果在编译时验证了语言的类型系统,则该语言是静态类型的。静态类型语言可以是像C一样的“弱类型”语言,也可以是像C#一样的强类型语言。

    4. 动态类型化语言是在运行时验证类型的语言。许多语言在某种程度上混合了静态和动态类型。例如,C#将在运行时动态验证许多强制转换,因为不可能在编译时检查它们。其他示例包括Java、VB和Objective-C等语言。

      还有一些语言是“完全”或“大部分”动态类型的,如“lisp”、“ruby”和“Smalltalk”

    5. Duck类型与静态、动态、弱或强类型完全正交。这是一种编写代码的实践,它将与对象一起工作,而不管其底层类型标识如何。例如,以下VB.NET代码:

      function Foo(x as object) as object
          return x.Quack()
      end function
      

      无论传递到“Foo”的对象的类型是什么,只要它定义了一个名为“Quack”的方法,它都将工作。也就是说,如果对象看起来像鸭子,走路像鸭子,说话像鸭子,那么它就是鸭子。Duck类型有多种形式。可以有静态duck类型、动态duck类型、强duck类型和弱duck类型。C++模板函数是“弱静态鸭类型”的一个很好的例子。“JaredPar”帖子中的示例展示了“强静态duck类型”的示例。VB中的后期绑定(或Ruby或Python中的代码)支持“强动态鸭子类型”。

    6. 变种

      变量是一种动态类型化的数据结构,可以保存一系列预定义的数据类型,包括字符串、整数类型、日期和com对象。然后,它定义了一系列用于分配、转换和操作存储在变体中的数据的操作。变体是否为强类型取决于使用它的语言。例如,VB6程序中的变体是强类型的。VB运行时确保用VB代码编写的操作符合变体的键入规则。通过VB中的变量类型将字符串添加到IUnknown将导致运行时错误。但是,在C++中,变量类型弱,因为所有C++类型都是弱类型的。

    好啊现在,我已经给出了定义,现在我可以回答你的问题了:

    然而,使用变体并不能真正提供很多验证。静态类型的duck类型机制,如JaredPar所描述的,提供了duck类型的优点,以及编译器的一些额外验证。这真的很有帮助。

        2
  •  19
  •   John Topley    16 年前

    简单的答案是variant类型是弱类型的,而duck类型是强类型的。

    鸭子打字可以很好地概括为“如果它走路像鸭子,看起来像鸭子,像鸭子一样动作,那么它就是鸭子。”计算机科学术语认为鸭子是下面的界面。

    interface IDuck {
      void Quack();
    }
    

    现在让我们来看看达菲

    class Daffy {
      void Quack() {
        Console.WriteLine("Thatsssss dispicable!!!!");
      }
    }
    

    在这种情况下,达菲实际上不是一个傻瓜。然而,它的行为就像一只鸭子。很明显,Daffy实际上是一只鸭子,为什么要让Daffy实现IDuck呢。

    IDuck d = new Daffy();
    d.Quack();
    

    Quack方法现在可以在“d”上调用,并具有完全的类型安全性。此赋值或方法调用中不可能出现运行时类型错误。

        3
  •  5
  •   Mark Cidade    18 年前

    Duck类型只是动态类型或后期绑定的另一个术语。使用运行时中可能定义或未定义的任何成员访问(例如,obj.anywhere)解析/编译的变量对象是duck类型。

        4
  •  4
  •   Germán    18 年前

    要求 假设您有一个从某个第三方库获取并使用密封类Duck的对象的方法。您希望使该方法可测试。Duck有一个非常大的API(有点像ServletRequest),您只需要关心其中的一小部分。你如何测试它?

    一种方法是让方法采用一些庸医的东西。然后,您可以简单地创建一个嘎嘎作响的模拟对象。

        5
  •  3
  •   BuddyJoe    18 年前

    试着阅读维基百科关于鸭子打字的文章的第一段。
    Duck typing on Wikipedia


    如果我有另一个类具有如下方法:
    public void runsomerunable(IRunnable rn){…}

    在duck类型友好的语言中,我可以将任何具有Run()方法的类传入RunSomeRunnable()方法。

    “如果它像鸭子一样跑”

    变体至少更像.NET中的对象。

        6
  •  2
  •   FlySwat    18 年前

    @肯特·弗雷德里克

    通过使用显式接口,您的示例完全可以不用duck类型来完成……是的,更丑陋,但这并非不可能。

    public interface ICreature { }
    public interface IFly { fly();}
    public interface IWalk { walk(); }
    public interface IQuack { quack(); }
    // ETC
    
    // Animal Class
    public class Duck : ICreature, IWalk, IFly, IQuack
    {
        fly() {};
        walk() {};
        quack() {};
    }
    
    public class Rhino: ICreature, IWalk
    {
        walk();
    }
    
    // In the method
    List<ICreature> creatures = new List<ICreature>();
    creatures.Add(new Duck());
    creatures.Add(new Rhino());   
    
    foreach (ICreature creature in creatures)
    {
        if (creature is IFly)        
             (creature as IFly).fly();        
        if (creature is IWalk) 
             (creature as IWalk).walk();         
    }
    // Etc
    
        7
  •  2
  •   Jason Baker    18 年前

    关于你的要求,你应该 需要

    我说,如果你喜欢使用静态输入,那么就使用它。但您至少应该尝试使用duck类型(如果可能的话,在一个非常重要的项目中使用它)。

    要更直接地回答您:

    两者都有。你仍然在攻击同样的问题。你只是换了一种方式而已。有时候,这就是你为节省时间所需要做的一切(即使没有其他理由强迫自己以不同的方式做事)。

    它是拯救全人类免于灭绝的灵丹妙药吗?不,任何告诉你不是这样的人都是狂热者。

        8
  •  1
  •   Josh Kelley    18 年前

    Duck类型改为使用动态类型。在duck类型下,如果变量恰好支持int、float或string在特定上下文中支持的特定方法,则变量可能可用作int、float或string。

    对于web应用程序,假设我希望我的用户信息来自LDAP而不是数据库,但我仍然希望我的用户信息可供基于数据库和ORM的web框架的其余部分使用。

    使用变体:没有运气。我可以创建一个变量,该变量可以包含UserFromDbRecord对象或UserFromLdap对象,但UserFromLdap对象将不可用于期望来自FromDbRecord层次结构的对象的例程。

    使用duck类型:我可以使用我的userfromdap类并添加几个方法,使其像UserFromDbRecord类一样工作。我不需要复制整个FromDbRecord接口,只需要复制我需要使用的例程即可。如果我做对了,这是一个非常强大和灵活的技术。如果我做错了,它会产生非常混乱和脆弱的代码(如果DB库或LDAP库发生更改,代码会被破坏)。

        9
  •  1
  •   John Topley    16 年前

    我认为duck类型的核心是如何使用它。我们使用方法检测和实体的内省来知道如何处理它,而不是预先声明它是什么

    它在OO语言中可能更实用,因为在OO语言中,原语不是原语,而是对象。

    看 喜欢任何东西,但是你可以通过问它来了解它是什么。

    有一件事我不相信不打字是可信的。

    sub dance { 
         my $creature = shift;
         if( $creature->can("walk") ){ 
             $creature->walk("left",1);
             $creature->walk("right",1); 
             $creature->walk("forward",1);
             $creature->walk("back",1);
         }
         if( $creature->can("fly") ){ 
              $creature->fly("up"); 
              $creature->fly("right",1); 
              $creature->fly("forward",1); 
              $creature->fly("left", 1 ); 
              $creature->fly("back", 1 ); 
              $creature->fly("down");
         } else if ( $creature->can("walk") ) { 
             $creature->walk("left",1);
             $creature->walk("right",1); 
             $creature->walk("forward",1);
             $creature->walk("back",1);
         } else if ( $creature->can("splash") ) { 
             $creature->splash( "up" ) for ( 0 .. 4 ); 
         }
         if( $creature->can("quack") ) { 
             $creature->quack();
         }
     }
    
     my @x = ();  
     push @x, new Rhinoceros ; 
     push @x, new Flamingo; 
     push @x, new Hyena; 
     push @x, new Dolphin; 
     push @x, new Duck;
    
     for my $creature (@x){
    
        new Thread(sub{ 
           dance( $creature ); 
        }); 
     }
    

        10
  •  0
  •   zefciu    16 年前

    使用duck类型可以执行的所有操作都可以通过接口执行。Duck类型是快速且舒适的,但一些人认为它可能会导致错误(如果两个不同的方法/属性名称相同)。接口是安全和明确的,但人们可能会说“为什么要说显而易见的?”。休息是火焰。每个人都选择适合自己的,没有人是“正确的”。