面向对象的 Perl 构造函数语法和命名参数

Question

我对 Perl 构造函数中发生的事情有点困惑。我找到了这两个示例 perldoc perlbot。

package Foo;

#In Perl, the constructor is just a subroutine called new.
sub new {
  #I don't get what this line does at all, but I always see it. Do I need it?
  my $type = shift;

  #I'm turning the array of inputs into a hash, called parameters.
  my %params = @_;

  #I'm making a new hash called $self to store my instance variables?
  my $self = {};

  #I'm adding two values to the instance variables called "High" and "Low".
  #But I'm not sure how $params{'High'} has any meaning, since it was an
  #array, and I turned it into a hash.
  $self->{'High'} = $params{'High'};
  $self->{'Low'} = $params{'Low'};

  #Even though I read the page on [bless][2], I still don't get what it does.
  bless $self, $type;
}

另一个例子是：

package Bar;

sub new {
  my $type = shift;

  #I still don't see how I can just turn an array into a hash and expect things
  #to work out for me.
  my %params = @_;
  my $self = [];

  #Exactly where did params{'Left'} and params{'Right'} come from?
  $self->[0] = $params{'Left'};
  $self->[1] = $params{'Right'};

  #and again with the bless.
  bless $self, $type;
}

这是使用这些对象的脚本：

package main;

$a = Foo->new( 'High' => 42, 'Low' => 11 );
print "High=$a->{'High'}\n";
print "Low=$a->{'Low'}\n";

$b = Bar->new( 'Left' => 78, 'Right' => 40 );
print "Left=$b->[0]\n";
print "Right=$b->[1]\n";

我已将我一直遇到的问题/困惑作为注释注入到代码中。

Answer 1

要回答您问题的主要要点，因为哈希可以初始化为 key => 的列表。值 对，您可以将这样的列表发送到函数，然后将 @_ 分配给哈希。这是在 Perl 中执行命名参数的标准方法。

例如，

sub foo { 
    my %stuff = @_;
    ...
}

foo( beer => 'good', vodka => 'great' );

这将导致子例程 foo 中的 %stuff 具有包含两个键的哈希：beer 和 vodka ，以及相应的值。

现在，在 OO Perl 中，还有一些额外的问题。每当您使用箭头 (->) 运算符调用方法时，箭头左侧的任何内容都会粘贴到 @_ 数组的开头。

因此，如果您说 Foo->new( 1, 2, 3 );

然后在构造函数中，@_ 将如下所示：( 'Foo', 1, 2, 3 )。

因此，我们使用 shift，它不带参数隐式地对 @_ 进行操作，从 @_ 中获取第一项，并将其分配给$类型。之后，@_只剩下我们的名称/值对，为了方便起见，我们可以将其直接分配给哈希值。

然后我们使用该 $type 值来表示 bless。 bless 所做的就是获取一个引用（在第一个示例中是哈希引用）并说“此引用与特定包关联”。阿拉卡扎姆，你有一个目标。

请记住，$type 包含字符串“Foo”，这是我们包的名称。如果您没有为bless指定第二个参数，它将使用当前包的名称，这在本例中也可以工作，但不会< /em> 适用于继承的构造函数。

Answer 2

.1.在 Perl 中，构造函数只是一个名为 new 的子例程。

是的，按照惯例 new 是一个构造函数。它也可以执行初始化或不执行初始化。 new 应该在成功时返回一个对象，或者在发生阻止对象创建的错误时抛出异常 (die/croak)。

您可以将构造函数命名为任何您喜欢的名称，拥有任意数量的构造函数，甚至可以将 bless 对象构建到您想要的任何名称空间中（这并不是一个好主意）。

.2.我根本不明白 my $type = shift; 做了什么，但我总是看到它。我需要它吗？

不带参数的 shift 从 @_ 头部取出一个参数，并将其分配给 $type。 -> 运算符将调用者（左侧）作为第一个参数传递给子例程。所以这一行从参数列表中获取类名。而且，是的，你确实需要它。

.3.输入数组如何成为 %params 哈希？ my %params = @_;

对哈希的赋值是在列表上下文中完成的，列表项对被分组为键/值对。因此 %foo = 1, 2, 3, 4; 创建一个哈希，使得 $foo{1} == 2 且 $foo{3} = = 4 。这通常是为了为子例程创建命名参数。如果子传递奇数个参数，则在启用警告的情况下将生成警告。

.4. 'my $self = {};` 是做什么的？

此行创建一个匿名哈希引用并将其分配给词法作用域变量 $self。哈希引用将存储对象的数据。通常，散列中的键与对象属性具有一对一的映射。因此，如果 Foo 类具有属性“size”和“color”，如果您检查 Foo 对象的内容，您将看到类似 $foo = { size =>; 'm'，颜色=> '黑色'};。

.5.给定 $self->{'High'} = $params{'High'}; $params{'High'} 来自哪里？

此代码依赖于传递给 new 的参数。如果像 Foo->new( High => 46 ) 那样调用 new，那么根据问题 3 创建的哈希将具有键 的值高（46）。在这种情况下，它相当于说 $self->{High} = 46。但如果像 Foo->new() 那样调用该方法，则没有可用的值，并且我们有 $self->{High} = undef。

.6. bless 有什么作用？

bless 获取引用并与特定包关联，以便您可以使用它来进行方法调用。通过一个参数，引用与当前包相关联。对于两个参数，第二个参数指定与引用关联的包。最好始终使用两个参数形式，以便您的构造函数可以由子类继承并仍然正常运行。

最后，我将重写基于散列的对象访问器，就像我使用经典的 OO Perl 编写它一样。

package Foo;

use strict;
use warnings;
use Carp qw(croak);

sub new {
    my $class = shift;

    croak "Illegal parameter list has odd number of values" 
        if @_ % 2;

    my %params = @_;

    my $self = {};
    bless $self, $class;

    # This could be abstracted out into a method call if you 
    # expect to need to override this check.
    for my $required (qw{ name rank serial_number  });
        croak "Required parameter '$required' not passed to '$class' constructor"
            unless exists $params{$required};  
    }

    # initialize all attributes by passing arguments to accessor methods.
    for my $attrib ( keys %params ) {

        croak "Invalid parameter '$attrib' passed to '$class' constructor"
            unless $self->can( $attrib );

        $self->$attrib( $params{$attrib} );
    }

    return $self;
}

Answer 3

您的问题与 OO Perl 无关。您对数据结构感到困惑。

可以使用列表或数组来初始化哈希：

my @x = ('High' => 42, 'Low' => 11);
my %h = @x;

use Data::Dumper;
print Dumper \%h;

$VAR1 = {
          'Low' => 11,
          'High' => 42
        };

当您在 blessed 引用上调用方法时，该引用将被添加到该方法接收的参数列表中：

#!/usr/bin/perl

package My::Mod;

use strict;
use warnings;

use Data::Dumper;
$Data::Dumper::Indent = 0;

sub new { bless [] => shift }

sub frobnicate { Dumper(\@_) }

package main;

use strict;
use warnings;

my $x = My::Mod->new;

# invoke instance method
print $x->frobnicate('High' => 42, 'Low' => 11);

# invoke class method
print My::Mod->frobnicate('High' => 42, 'Low' => 11);

# call sub frobnicate in package My::Mod
print My::Mod::frobnicate('High' => 42, 'Low' => 11);

输出：

$VAR1 = [bless( [], 'My::Mod' ),'High',42,'Low',11];
$VAR1 = ['My::Mod','High',42,'Low',11];
$VAR1 = ['High',42,'Low',11];

Answer 4

一些尚未处理的问题：

在 Perl 中，构造函数只是一个
名为new的子例程。

不完全是。将构造函数称为 new 只是一种约定。您可以随意称呼它。从 Perl 的角度来看，这个名字没有什么特别的。

祝福$self，$type；

您的两个示例都没有显式返回 bless 的结果。我希望你知道他们无论如何都是隐含地这样做的。

Answer 5

如果将数组分配给散列，perl 会将数组中的交替元素视为键和值。你的数组看起来像

my @array = (key1, val1, key2, val2, key3, val3, ...);

当你将其分配给 %hash 时，你会得到

my %hash = @array;
# %hash = ( key1 => val1, key2 => val2, key3 => val3, ...);

这是 Perl 列表/哈希构造语法中的另一种说法， "," 和 "=>" 意思是一样的。

Answer 6

在 Perl 中，子例程的所有参数都通过预定义数组 @_ 传递。

shift 删除并返回 @_ 数组中的第一项。在 Perl OO 中，这是方法调用者——通常是构造函数的类名和其他方法的对象。

哈希值会展平为列表并可以通过列表进行初始化。模拟子例程的命名参数是一个常见的技巧。例如，

Employee->new(name => 'Fred Flintstone', occupation => 'quarry worker');

忽略类名（已移出），奇数元素成为散列键，偶数元素成为相应的值。

my $self = {} 创建一个新的哈希引用来保存实例数据。 bless 函数将普通哈希引用 $self 转换为对象。它所做的只是添加一些元数据，将引用标识为属于该类。

Answer 7

是的，我知道我在这里有点像死灵法师，但是......

虽然所有这些答案都很棒，但我想我应该提到驼鹿。 Moose 使构造函数变得简单（package Foo;use Moose; 自动提供一个名为 new 的构造函数（尽管如果您愿意，可以覆盖名称“new”）），但是 < a href="http://search.cpan.org/dist/Moose/lib/Moose/Manual/Construction.pod" rel="nofollow">不会剥夺任何可配置性（如果您需要的话）。

一旦我浏览了 Moose 的文档（总体来说相当不错，如果你适当地谷歌搜索的话，还有更多的教程片段），我再也没有回头。