perl - 如何从模式中获取未知数量的捕获？

Question

假设我有一个模式:

<cell> cell1=cell2 <pin> pin1=pin2 pin3=pin4 <type> type1=type2

如您所见，该模式可以有多个值(在这种情况下 pin 有 2 组 pin 名称)。金额未知。

我将如何解析这个？这是我到目前为止所拥有的，但这并没有帮助，因为它没有考虑模式是否有超过 2 组引脚。

my $pattern = "<cell> cell1=cell2 <pin> pin1=pin2 pin3=pin4 <type> type1=type2";

if ( $pattern =~ m#\<cell\> (\w*=\w*) \<pin\> (\w*=\w*) \<type\> (\w*=\w*)#) {

my $cell_name = $1;
my $pin_name = $2;
my $type_name = $3;
}

如您所见，这仅在只有一组引脚名称时才有效。但是我希望它能够适应多个未知的引脚名称集。我想我必须像数组或哈希一样构造，但考虑到未知的多个引脚集，我不确定获取这些值的最佳方法是什么。

我希望能够将 cell_name、pin_name 和 type_name 存储为包含值集的数组或散列。

Answer 1

你的问题比 Why do I get the first capture group only? 有点棘手。但其中一些想法可能会有所帮助。诀窍是停止考虑以单一模式做所有事情。

如果这确实是您的输入，我很想匹配 = 周围的事物组。列表上下文中的匹配，例如分配给哈希，返回匹配列表:

use Data::Dumper;

my $input = "<cell> cell1=cell2 <pin> pin1=pin2 pin3=pin4 <type> type1=type2";
my %values = $input =~ m/ (\S+) = (\S+) /gx;

print Dumper( \%values );

=之前的东西变成键，后面的东西变成值:

$VAR1 = {
          'pin1' => 'pin2',
          'type1' => 'type2',
          'cell1' => 'cell2',
          'pin3' => 'pin4'
        };

但生活可能并不那么容易。示例名称可能没有真正的 pin、cell 等。

不过，我还喜欢做另一件事，因为我想念 sscan 带来的所有乐趣。您可以通过一次匹配其中的一部分来遍历字符串，然后在下一次匹配时，从您离开的地方开始。首先是全部内容:

use v5.10;

use Data::Dumper;

my $input = "<cell> cell1=cell2 <pin> pin1=pin2 pin3=pin4 <type> type1=type2";

my %hash;
while( 1 ) {
    state $type;

    if( $input =~ /\G < (.*?) > \s* /xgc ) {
        $type = $1;
        }
    elsif( $input =~ /\G (\S+) = (\S+) \s* /xgc ) {
        $hash{$type}{$1}{$2}++;
        }
    else { last }
    }

print Dumper( \%hash );

还有数据结构，真的没关系，可以是你喜欢的任何东西:

$VAR1 = {
          'type' => {
                      'type1' => {
                                   'type2' => 1
                                 }
                    },
          'pin' => {
                     'pin1' => {
                                 'pin2' => 1
                               },
                     'pin3' => {
                                 'pin4' => 1
                               }
                   },
          'cell' => {
                      'cell1' => {
                                   'cell2' => 1
                                 }
                    }
        };

但是让我们先谈谈他的。首先，所有匹配都在标量上下文中，因为它们位于 if-elsif-else 分支的条件部分。这意味着他们只会进行下一场比赛。

但是，我使用 \G 锚定了每个模式的开头。当我在标量上下文中使用 /g 标志时，这使得模式匹配字符串的开头或上一个成功匹配停止的位置。

但是，我想尝试几种模式，所以其中一些会失败。这就是 /c 标志出现的地方。它不会在失败时重置匹配位置。这意味着 \G anchor 不会在匹配失败时重置。所以，我可以尝试一种模式，如果不行，就从下一个相同的位置开始。

所以，当我遇到尖括号中的东西时，我会记住那个类型。直到我在尖括号中匹配另一个东西，这就是我匹配的东西的类型。现在，当我匹配 (\S+) = (\S+) 时，我可以将匹配项分配给正确的类型。

要观察这种情况，您可以输出记住的字符串位置。每个标量都维护自己的光标，pos(VAR) 返回该位置:

use v5.10;

use Data::Dumper;

my $input = "<cell> cell1=cell2 <pin> pin1=pin2 pin3=pin4 <type> type1=type2";

my %hash;
while( 1 ) {
    state $type;

    say "Starting matches at " . ( pos($input) // 0 );
    if( $input =~ /\G < (.*?) > \s* /xgc ) {
        $type = $1;
        say "Matched <$type>, left off at " . pos($input);
        }
    elsif( $input =~ /\G (\S+) = (\S+) \s* /xgc ) {
        $hash{$type}{$1}{$2}++;
        say "Matched <$1|$2>, left off at " . pos($input);
        }
    else {
        say "Nothing left to do, left off at " . pos($input);
        last;
        }
    }

print Dumper( \%hash );

在 Dumper 输出之前，您现在可以看到标量上下文中的全局匹配遍历字符串:

Starting matches at 0
Matched <cell>, left off at 7
Starting matches at 7
Matched <cell1|cell2>, left off at 19
Starting matches at 19
Matched <pin>, left off at 25
Starting matches at 25
Matched <pin1|pin2>, left off at 35
Starting matches at 35
Matched <pin3|pin4>, left off at 45
Starting matches at 45
Matched <type>, left off at 52
Starting matches at 52
Matched <type1|type2>, left off at 63
Starting matches at 63
Nothing left to do, left off at 63

---

最后，作为奖励，这里有一个递归的体面语法可以做到这一点。对于您提供的内容，这肯定是矫枉过正，但在更棘手的情况下会做得更好。除了说它产生相同的数据结构外，我不会解释它:

use v5.10;

use Parse::RecDescent;
use Data::Dumper;

my $grammar = <<~'HERE';
    startrule: context_pairlist(s)
    context_pairlist: context /\s*/ pair(s)
    context: '<' /[^>]+/ '>'
        { $::context = $item[2] }
    pair: /[A-Za-z0-9]+/ '=' /[A-Za-z0-9]+/
        { main::build_hash( $::context, @item[1,3] ) }
    HERE

my $parser = Parse::RecDescent->new( $grammar );

my %hash;
sub build_hash {
    my( $context, $name, $value ) = @_;
    $hash{$context}{$name}{$value}++;
    }

my $input = "<cell> cell1=cell2 <pin> pin1=pin2 pin3=pin4 <type> type1=type2";
$parser->startrule( $input );

say Dumper( \%hash );